Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! N my_cmp.hnu [ /* Copyright (c) 2024, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
typedef int (*qsort_cmp)(const void *, const void *);
typedef int (*qsort_cmp2)(void *param, const void *a, const void *b);
#ifdef __cplusplus
}
#endif
PK ! 6 mysqld_ername.hnu [ /* Autogenerated file, please don't edit */
{ "ER_HASHCHK", 1000, "hashchk" },
{ "ER_NISAMCHK", 1001, "isamchk" },
{ "ER_NO", 1002, "NO" },
{ "ER_YES", 1003, "YES" },
{ "ER_CANT_CREATE_FILE", 1004, "Can\'t create file \'%-.200s\' (errno: %M)" },
{ "ER_CANT_CREATE_TABLE", 1005, "Can\'t create table %`s.%`s (errno: %M)" },
{ "ER_CANT_CREATE_DB", 1006, "Can\'t create database \'%-.192s\' (errno: %M)" },
{ "ER_DB_CREATE_EXISTS", 1007, "Can\'t create database \'%-.192s\'; database exists" },
{ "ER_DB_DROP_EXISTS", 1008, "Can\'t drop database \'%-.192s\'; database doesn\'t exist" },
{ "ER_DB_DROP_DELETE", 1009, "Error dropping database (can\'t delete \'%-.192s\', errno: %M)" },
{ "ER_DB_DROP_RMDIR", 1010, "Error dropping database (can\'t rmdir \'%-.192s\', errno: %M)" },
{ "ER_CANT_DELETE_FILE", 1011, "Error on delete of \'%-.192s\' (errno: %M)" },
{ "ER_CANT_FIND_SYSTEM_REC", 1012, "Can\'t read record in system table" },
{ "ER_CANT_GET_STAT", 1013, "Can\'t get status of \'%-.200s\' (errno: %M)" },
{ "ER_CANT_GET_WD", 1014, "Can\'t get working directory (errno: %M)" },
{ "ER_CANT_LOCK", 1015, "Can\'t lock file (errno: %M)" },
{ "ER_CANT_OPEN_FILE", 1016, "Can\'t open file: \'%-.200s\' (errno: %M)" },
{ "ER_FILE_NOT_FOUND", 1017, "Can\'t find file: \'%-.200s\' (errno: %M)" },
{ "ER_CANT_READ_DIR", 1018, "Can\'t read dir of \'%-.192s\' (errno: %M)" },
{ "ER_CANT_SET_WD", 1019, "Can\'t change dir to \'%-.192s\' (errno: %M)" },
{ "ER_CHECKREAD", 1020, "Record has changed since last read in table \'%-.192s\'; try restarting transaction" },
{ "ER_DISK_FULL", 1021, "Disk full (%s); waiting for someone to free some space... (errno: %M)" },
{ "ER_DUP_KEY", 1022, "Can\'t write; duplicate key in table \'%-.192s\'" },
{ "ER_ERROR_ON_CLOSE", 1023, "Error on close of \'%-.192s\' (errno: %M)" },
{ "ER_ERROR_ON_READ", 1024, "Error reading file \'%-.200s\' (errno: %M)" },
{ "ER_ERROR_ON_RENAME", 1025, "Error on rename of \'%-.210s\' to \'%-.210s\' (errno: %M)" },
{ "ER_ERROR_ON_WRITE", 1026, "Error writing file \'%-.200s\' (errno: %M)" },
{ "ER_FILE_USED", 1027, "\'%-.192s\' is locked against change" },
{ "ER_FILSORT_ABORT", 1028, "Sort aborted" },
{ "ER_FORM_NOT_FOUND", 1029, "View \'%-.192s\' doesn\'t exist for \'%-.192s\'" },
{ "ER_GET_ERRNO", 1030, "Got error %M from storage engine %s" },
{ "ER_ILLEGAL_HA", 1031, "Storage engine %s of the table %`s.%`s doesn\'t have this option" },
{ "ER_KEY_NOT_FOUND", 1032, "Can\'t find record in \'%-.192s\'" },
{ "ER_NOT_FORM_FILE", 1033, "Incorrect information in file: \'%-.200s\'" },
{ "ER_NOT_KEYFILE", 1034, "Index for table \'%-.200s\' is corrupt; try to repair it" },
{ "ER_OLD_KEYFILE", 1035, "Old key file for table \'%-.192s\'; repair it!" },
{ "ER_OPEN_AS_READONLY", 1036, "Table \'%-.192s\' is read only" },
{ "ER_OUTOFMEMORY", 1037, "Out of memory; restart server and try again (needed %d bytes)" },
{ "ER_OUT_OF_SORTMEMORY", 1038, "Out of sort memory, consider increasing server sort buffer size" },
{ "ER_UNEXPECTED_EOF", 1039, "Unexpected EOF found when reading file \'%-.192s\' (errno: %M)" },
{ "ER_CON_COUNT_ERROR", 1040, "Too many connections" },
{ "ER_OUT_OF_RESOURCES", 1041, "Out of memory." },
{ "ER_BAD_HOST_ERROR", 1042, "Can\'t get hostname for your address" },
{ "ER_HANDSHAKE_ERROR", 1043, "Bad handshake" },
{ "ER_DBACCESS_DENIED_ERROR", 1044, "Access denied for user \'%s\'@\'%s\' to database \'%-.192s\'" },
{ "ER_ACCESS_DENIED_ERROR", 1045, "Access denied for user \'%s\'@\'%s\' (using password: %s)" },
{ "ER_NO_DB_ERROR", 1046, "No database selected" },
{ "ER_UNKNOWN_COM_ERROR", 1047, "Unknown command" },
{ "ER_BAD_NULL_ERROR", 1048, "Column \'%-.192s\' cannot be null" },
{ "ER_BAD_DB_ERROR", 1049, "Unknown database \'%-.192s\'" },
{ "ER_TABLE_EXISTS_ERROR", 1050, "Table \'%-.192s\' already exists" },
{ "ER_BAD_TABLE_ERROR", 1051, "Unknown table \'%-.100T\'" },
{ "ER_NON_UNIQ_ERROR", 1052, "Column \'%-.192s\' in %-.192s is ambiguous" },
{ "ER_SERVER_SHUTDOWN", 1053, "Server shutdown in progress" },
{ "ER_BAD_FIELD_ERROR", 1054, "Unknown column \'%-.192s\' in \'%-.192s\'" },
{ "ER_WRONG_FIELD_WITH_GROUP", 1055, "\'%-.192s\' isn\'t in GROUP BY" },
{ "ER_WRONG_GROUP_FIELD", 1056, "Can\'t group on \'%-.192s\'" },
{ "ER_WRONG_SUM_SELECT", 1057, "Statement has sum functions and columns in same statement" },
{ "ER_WRONG_VALUE_COUNT", 1058, "Column count doesn\'t match value count" },
{ "ER_TOO_LONG_IDENT", 1059, "Identifier name \'%-.100T\' is too long" },
{ "ER_DUP_FIELDNAME", 1060, "Duplicate column name \'%-.192s\'" },
{ "ER_DUP_KEYNAME", 1061, "Duplicate key name \'%-.192s\'" },
{ "ER_DUP_ENTRY", 1062, "Duplicate entry \'%-.192T\' for key %d" },
{ "ER_WRONG_FIELD_SPEC", 1063, "Incorrect column specifier for column \'%-.192s\'" },
{ "ER_PARSE_ERROR", 1064, "%s near \'%-.80T\' at line %d" },
{ "ER_EMPTY_QUERY", 1065, "Query was empty" },
{ "ER_NONUNIQ_TABLE", 1066, "Not unique table/alias: \'%-.192s\'" },
{ "ER_INVALID_DEFAULT", 1067, "Invalid default value for \'%-.192s\'" },
{ "ER_MULTIPLE_PRI_KEY", 1068, "Multiple primary key defined" },
{ "ER_TOO_MANY_KEYS", 1069, "Too many keys specified; max %d keys allowed" },
{ "ER_TOO_MANY_KEY_PARTS", 1070, "Too many key parts specified; max %d parts allowed" },
{ "ER_TOO_LONG_KEY", 1071, "Specified key was too long; max key length is %d bytes" },
{ "ER_KEY_COLUMN_DOES_NOT_EXIST", 1072, "Key column \'%-.192s\' doesn\'t exist in table" },
{ "ER_BLOB_USED_AS_KEY", 1073, "BLOB column %`s can\'t be used in key specification in the %s table" },
{ "ER_TOO_BIG_FIELDLENGTH", 1074, "Column length too big for column \'%-.192s\' (max = %lu); use BLOB or TEXT instead" },
{ "ER_WRONG_AUTO_KEY", 1075, "Incorrect table definition; there can be only one auto column and it must be defined as a key" },
{ "ER_BINLOG_CANT_DELETE_GTID_DOMAIN", 1076, "Could not delete gtid domain. Reason: %s." },
{ "ER_NORMAL_SHUTDOWN", 1077, "%s (initiated by: %s): Normal shutdown" },
{ "ER_GOT_SIGNAL", 1078, "%s: Got signal %d. Aborting!" },
{ "ER_SHUTDOWN_COMPLETE", 1079, "%s: Shutdown complete" },
{ "ER_FORCING_CLOSE", 1080, "%s: Forcing close of thread %ld user: \'%-.48s\'" },
{ "ER_IPSOCK_ERROR", 1081, "Can\'t create IP socket" },
{ "ER_NO_SUCH_INDEX", 1082, "Table \'%-.192s\' has no index like the one used in CREATE INDEX; recreate the table" },
{ "ER_WRONG_FIELD_TERMINATORS", 1083, "Field separator argument is not what is expected; check the manual" },
{ "ER_BLOBS_AND_NO_TERMINATED", 1084, "You can\'t use fixed rowlength with BLOBs; please use \'fields terminated by\'" },
{ "ER_TEXTFILE_NOT_READABLE", 1085, "The file \'%-.128s\' must be in the database directory or be readable by all" },
{ "ER_FILE_EXISTS_ERROR", 1086, "File \'%-.200s\' already exists" },
{ "ER_LOAD_INFO", 1087, "Records: %ld Deleted: %ld Skipped: %ld Warnings: %ld" },
{ "ER_ALTER_INFO", 1088, "Records: %ld Duplicates: %ld" },
{ "ER_WRONG_SUB_KEY", 1089, "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" },
{ "ER_CANT_REMOVE_ALL_FIELDS", 1090, "You can\'t delete all columns with ALTER TABLE; use DROP TABLE instead" },
{ "ER_CANT_DROP_FIELD_OR_KEY", 1091, "Can\'t DROP %s %`-.192s; check that it exists" },
{ "ER_INSERT_INFO", 1092, "Records: %ld Duplicates: %ld Warnings: %ld" },
{ "ER_UPDATE_TABLE_USED", 1093, "Table \'%-.192s\' is specified twice, both as a target for \'%s\' and as a separate source for data" },
{ "ER_NO_SUCH_THREAD", 1094, "Unknown thread id: %lu" },
{ "ER_KILL_DENIED_ERROR", 1095, "You are not owner of thread %lld" },
{ "ER_NO_TABLES_USED", 1096, "No tables used" },
{ "ER_TOO_BIG_SET", 1097, "Too many strings for column %-.192s and SET" },
{ "ER_NO_UNIQUE_LOGFILE", 1098, "Can\'t generate a unique log-filename %-.200s.(1-999)" },
{ "ER_TABLE_NOT_LOCKED_FOR_WRITE", 1099, "Table \'%-.192s\' was locked with a READ lock and can\'t be updated" },
{ "ER_TABLE_NOT_LOCKED", 1100, "Table \'%-.192s\' was not locked with LOCK TABLES" },
{ "ER_UNUSED_17", 1101, "You should never see it" },
{ "ER_WRONG_DB_NAME", 1102, "Incorrect database name \'%-.100T\'" },
{ "ER_WRONG_TABLE_NAME", 1103, "Incorrect table name \'%-.100s\'" },
{ "ER_TOO_BIG_SELECT", 1104, "The SELECT would examine more than MAX_JOIN_SIZE rows; check your WHERE and use SET SQL_BIG_SELECTS=1 or SET MAX_JOIN_SIZE=# if the SELECT is okay" },
{ "ER_UNKNOWN_ERROR", 1105, "Unknown error" },
{ "ER_UNKNOWN_PROCEDURE", 1106, "Unknown procedure \'%-.192s\'" },
{ "ER_WRONG_PARAMCOUNT_TO_PROCEDURE", 1107, "Incorrect parameter count to procedure \'%-.192s\'" },
{ "ER_WRONG_PARAMETERS_TO_PROCEDURE", 1108, "Incorrect parameters to procedure \'%-.192s\'" },
{ "ER_UNKNOWN_TABLE", 1109, "Unknown table \'%-.192s\' in %-.32s" },
{ "ER_FIELD_SPECIFIED_TWICE", 1110, "Column \'%-.192s\' specified twice" },
{ "ER_INVALID_GROUP_FUNC_USE", 1111, "Invalid use of group function" },
{ "ER_UNSUPPORTED_EXTENSION", 1112, "Table \'%-.192s\' uses an extension that doesn\'t exist in this MariaDB version" },
{ "ER_TABLE_MUST_HAVE_COLUMNS", 1113, "A table must have at least 1 column" },
{ "ER_RECORD_FILE_FULL", 1114, "The table \'%-.192s\' is full" },
{ "ER_UNKNOWN_CHARACTER_SET", 1115, "Unknown character set: \'%-.64s\'" },
{ "ER_TOO_MANY_TABLES", 1116, "Too many tables; MariaDB can only use %d tables in a join" },
{ "ER_TOO_MANY_FIELDS", 1117, "Too many columns" },
{ "ER_TOO_BIG_ROWSIZE", 1118, "Row size too large. The maximum row size for the used table type, not counting BLOBs, is %ld. This includes storage overhead, check the manual. You have to change some columns to TEXT or BLOBs" },
{ "ER_STACK_OVERRUN", 1119, "Thread stack overrun: Used: %ld of a %ld stack. Use \'mariadbd --thread_stack=#\' to specify a bigger stack if needed" },
{ "ER_WRONG_OUTER_JOIN", 1120, "Cross dependency found in OUTER JOIN; examine your ON conditions" },
{ "ER_NULL_COLUMN_IN_INDEX", 1121, "Table handler doesn\'t support NULL in given index. Please change column \'%-.192s\' to be NOT NULL or use another handler" },
{ "ER_CANT_FIND_UDF", 1122, "Can\'t load function \'%-.192s\'" },
{ "ER_CANT_INITIALIZE_UDF", 1123, "Can\'t initialize function \'%-.192s\'; %-.80s" },
{ "ER_UDF_NO_PATHS", 1124, "No paths allowed for shared library" },
{ "ER_UDF_EXISTS", 1125, "Function \'%-.192s\' already exists" },
{ "ER_CANT_OPEN_LIBRARY", 1126, "Can\'t open shared library \'%-.192s\' (errno: %d, %-.128s)" },
{ "ER_CANT_FIND_DL_ENTRY", 1127, "Can\'t find symbol \'%-.128s\' in library" },
{ "ER_FUNCTION_NOT_DEFINED", 1128, "Function \'%-.192s\' is not defined" },
{ "ER_HOST_IS_BLOCKED", 1129, "Host \'%-.64s\' is blocked because of many connection errors; unblock with \'mariadb-admin flush-hosts\'" },
{ "ER_HOST_NOT_PRIVILEGED", 1130, "Host \'%-.64s\' is not allowed to connect to this MariaDB server" },
{ "ER_PASSWORD_ANONYMOUS_USER", 1131, "You are using MariaDB as an anonymous user and anonymous users are not allowed to modify user settings" },
{ "ER_PASSWORD_NOT_ALLOWED", 1132, "You must have privileges to update tables in the mysql database to be able to change passwords for others" },
{ "ER_PASSWORD_NO_MATCH", 1133, "Can\'t find any matching row in the user table" },
{ "ER_UPDATE_INFO", 1134, "Rows matched: %ld Changed: %ld Warnings: %ld" },
{ "ER_CANT_CREATE_THREAD", 1135, "Can\'t create a new thread (errno %M); if you are not out of available memory, you can consult the manual for a possible OS-dependent bug" },
{ "ER_WRONG_VALUE_COUNT_ON_ROW", 1136, "Column count doesn\'t match value count at row %lu" },
{ "ER_CANT_REOPEN_TABLE", 1137, "Can\'t reopen table: \'%-.192s\'" },
{ "ER_INVALID_USE_OF_NULL", 1138, "Invalid use of NULL value" },
{ "ER_REGEXP_ERROR", 1139, "Regex error \'%s\'" },
{ "ER_MIX_OF_GROUP_FUNC_AND_FIELDS", 1140, "Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) with no GROUP columns is illegal if there is no GROUP BY clause" },
{ "ER_NONEXISTING_GRANT", 1141, "There is no such grant defined for user \'%-.48s\' on host \'%-.64s\'" },
{ "ER_TABLEACCESS_DENIED_ERROR", 1142, "%-.100T command denied to user \'%s\'@\'%s\' for table %`s.%`s" },
{ "ER_COLUMNACCESS_DENIED_ERROR", 1143, "%-.32s command denied to user \'%s\'@\'%s\' for column \'%-.192s\' in table \'%-.192s\'" },
{ "ER_ILLEGAL_GRANT_FOR_TABLE", 1144, "Illegal GRANT/REVOKE command; please consult the manual to see which privileges can be used" },
{ "ER_GRANT_WRONG_HOST_OR_USER", 1145, "The host or user argument to GRANT is too long" },
{ "ER_NO_SUCH_TABLE", 1146, "Table \'%-.192s.%-.192s\' doesn\'t exist" },
{ "ER_NONEXISTING_TABLE_GRANT", 1147, "There is no such grant defined for user \'%-.48s\' on host \'%-.64s\' on table \'%-.192s\'" },
{ "ER_NOT_ALLOWED_COMMAND", 1148, "The used command is not allowed with this MariaDB version" },
{ "ER_SYNTAX_ERROR", 1149, "You have an error in your SQL syntax; check the manual that corresponds to your MariaDB server version for the right syntax to use" },
{ "ER_DELAYED_CANT_CHANGE_LOCK", 1150, "Delayed insert thread couldn\'t get requested lock for table %-.192s" },
{ "ER_TOO_MANY_DELAYED_THREADS", 1151, "Too many delayed threads in use" },
{ "ER_ABORTING_CONNECTION", 1152, "Aborted connection %ld to db: \'%-.192s\' user: \'%-.48s\' (%-.64s)" },
{ "ER_NET_PACKET_TOO_LARGE", 1153, "Got a packet bigger than \'max_allowed_packet\' bytes" },
{ "ER_NET_READ_ERROR_FROM_PIPE", 1154, "Got a read error from the connection pipe" },
{ "ER_NET_FCNTL_ERROR", 1155, "Got an error from fcntl()" },
{ "ER_NET_PACKETS_OUT_OF_ORDER", 1156, "Got packets out of order" },
{ "ER_NET_UNCOMPRESS_ERROR", 1157, "Couldn\'t uncompress communication packet" },
{ "ER_NET_READ_ERROR", 1158, "Got an error reading communication packets" },
{ "ER_NET_READ_INTERRUPTED", 1159, "Got timeout reading communication packets" },
{ "ER_NET_ERROR_ON_WRITE", 1160, "Got an error writing communication packets" },
{ "ER_NET_WRITE_INTERRUPTED", 1161, "Got timeout writing communication packets" },
{ "ER_TOO_LONG_STRING", 1162, "Result string is longer than \'max_allowed_packet\' bytes" },
{ "ER_TABLE_CANT_HANDLE_BLOB", 1163, "Storage engine %s doesn\'t support BLOB/TEXT columns" },
{ "ER_TABLE_CANT_HANDLE_AUTO_INCREMENT", 1164, "Storage engine %s doesn\'t support AUTO_INCREMENT columns" },
{ "ER_DELAYED_INSERT_TABLE_LOCKED", 1165, "INSERT DELAYED can\'t be used with table \'%-.192s\' because it is locked with LOCK TABLES" },
{ "ER_WRONG_COLUMN_NAME", 1166, "Incorrect column name \'%-.100s\'" },
{ "ER_WRONG_KEY_COLUMN", 1167, "The storage engine %s can\'t index column %`s" },
{ "ER_WRONG_MRG_TABLE", 1168, "Unable to open underlying table which is differently defined or of non-MyISAM type or doesn\'t exist" },
{ "ER_DUP_UNIQUE", 1169, "Can\'t write, because of unique constraint, to table \'%-.192s\'" },
{ "ER_BLOB_KEY_WITHOUT_LENGTH", 1170, "BLOB/TEXT column \'%-.192s\' used in key specification without a key length" },
{ "ER_PRIMARY_CANT_HAVE_NULL", 1171, "All parts of a PRIMARY KEY must be NOT NULL; if you need NULL in a key, use UNIQUE instead" },
{ "ER_TOO_MANY_ROWS", 1172, "Result consisted of more than one row" },
{ "ER_REQUIRES_PRIMARY_KEY", 1173, "This table type requires a primary key" },
{ "ER_NO_RAID_COMPILED", 1174, "This version of MariaDB is not compiled with RAID support" },
{ "ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE", 1175, "You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column" },
{ "ER_KEY_DOES_NOT_EXISTS", 1176, "Key \'%-.192s\' doesn\'t exist in table \'%-.192s\'" },
{ "ER_CHECK_NO_SUCH_TABLE", 1177, "Can\'t open table" },
{ "ER_CHECK_NOT_IMPLEMENTED", 1178, "The storage engine for the table doesn\'t support %s" },
{ "ER_CANT_DO_THIS_DURING_AN_TRANSACTION", 1179, "You are not allowed to execute this command in a transaction" },
{ "ER_ERROR_DURING_COMMIT", 1180, "Got error %M during COMMIT" },
{ "ER_ERROR_DURING_ROLLBACK", 1181, "Got error %M during ROLLBACK" },
{ "ER_ERROR_DURING_FLUSH_LOGS", 1182, "Got error %M during FLUSH_LOGS" },
{ "ER_ERROR_DURING_CHECKPOINT", 1183, "Got error %M during CHECKPOINT" },
{ "ER_NEW_ABORTING_CONNECTION", 1184, "Aborted connection %lld to db: \'%-.192s\' user: \'%-.48s\' host: \'%-.64s\'%-.64s (%-.64s)" },
{ "ER_UNUSED_10", 1185, "You should never see it" },
{ "ER_FLUSH_MASTER_BINLOG_CLOSED", 1186, "Binlog closed, cannot RESET MASTER" },
{ "ER_INDEX_REBUILD", 1187, "Failed rebuilding the index of dumped table \'%-.192s\'" },
{ "ER_MASTER", 1188, "Error from master: \'%-.64s\'" },
{ "ER_MASTER_NET_READ", 1189, "Net error reading from master" },
{ "ER_MASTER_NET_WRITE", 1190, "Net error writing to master" },
{ "ER_FT_MATCHING_KEY_NOT_FOUND", 1191, "Can\'t find FULLTEXT index matching the column list" },
{ "ER_LOCK_OR_ACTIVE_TRANSACTION", 1192, "Can\'t execute the given command because you have active locked tables or an active transaction" },
{ "ER_UNKNOWN_SYSTEM_VARIABLE", 1193, "Unknown system variable \'%-.*s\'" },
{ "ER_CRASHED_ON_USAGE", 1194, "Table \'%-.192s\' is marked as crashed and should be repaired" },
{ "ER_CRASHED_ON_REPAIR", 1195, "Table \'%-.192s\' is marked as crashed and last (automatic?) repair failed" },
{ "ER_WARNING_NOT_COMPLETE_ROLLBACK", 1196, "Some non-transactional changed tables couldn\'t be rolled back" },
{ "ER_TRANS_CACHE_FULL", 1197, "Multi-statement transaction required more than \'max_binlog_cache_size\' bytes of storage; increase this mariadbd variable and try again" },
{ "ER_SLAVE_MUST_STOP", 1198, "This operation cannot be performed as you have a running slave \'%2$*1$s\'; run STOP SLAVE \'%2$*1$s\' first" },
{ "ER_SLAVE_NOT_RUNNING", 1199, "This operation requires a running slave; configure slave and do START SLAVE" },
{ "ER_BAD_SLAVE", 1200, "The server is not configured as slave; fix in config file or with CHANGE MASTER TO" },
{ "ER_MASTER_INFO", 1201, "Could not initialize master info structure for \'%.*s\'; more error messages can be found in the MariaDB error log" },
{ "ER_SLAVE_THREAD", 1202, "Could not create slave thread; check system resources" },
{ "ER_TOO_MANY_USER_CONNECTIONS", 1203, "User %-.64s already has more than \'max_user_connections\' active connections" },
{ "ER_SET_CONSTANTS_ONLY", 1204, "You may only use constant expressions in this statement" },
{ "ER_LOCK_WAIT_TIMEOUT", 1205, "Lock wait timeout exceeded; try restarting transaction" },
{ "ER_LOCK_TABLE_FULL", 1206, "The total number of locks exceeds the lock table size" },
{ "ER_READ_ONLY_TRANSACTION", 1207, "Update locks cannot be acquired during a READ UNCOMMITTED transaction" },
{ "ER_DROP_DB_WITH_READ_LOCK", 1208, "DROP DATABASE not allowed while thread is holding global read lock" },
{ "ER_CREATE_DB_WITH_READ_LOCK", 1209, "CREATE DATABASE not allowed while thread is holding global read lock" },
{ "ER_WRONG_ARGUMENTS", 1210, "Incorrect arguments to %s" },
{ "ER_NO_PERMISSION_TO_CREATE_USER", 1211, "\'%s\'@\'%s\' is not allowed to create new users" },
{ "ER_UNION_TABLES_IN_DIFFERENT_DIR", 1212, "Incorrect table definition; all MERGE tables must be in the same database" },
{ "ER_LOCK_DEADLOCK", 1213, "Deadlock found when trying to get lock; try restarting transaction" },
{ "ER_TABLE_CANT_HANDLE_FT", 1214, "The storage engine %s doesn\'t support FULLTEXT indexes" },
{ "ER_CANNOT_ADD_FOREIGN", 1215, "Cannot add foreign key constraint for `%s`" },
{ "ER_NO_REFERENCED_ROW", 1216, "Cannot add or update a child row: a foreign key constraint fails" },
{ "ER_ROW_IS_REFERENCED", 1217, "Cannot delete or update a parent row: a foreign key constraint fails" },
{ "ER_CONNECT_TO_MASTER", 1218, "Error connecting to master: %-.128s" },
{ "ER_QUERY_ON_MASTER", 1219, "Error running query on master: %-.128s" },
{ "ER_ERROR_WHEN_EXECUTING_COMMAND", 1220, "Error when executing command %s: %-.128s" },
{ "ER_WRONG_USAGE", 1221, "Incorrect usage of %s and %s" },
{ "ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT", 1222, "The used SELECT statements have a different number of columns" },
{ "ER_CANT_UPDATE_WITH_READLOCK", 1223, "Can\'t execute the query because you have a conflicting read lock" },
{ "ER_MIXING_NOT_ALLOWED", 1224, "Mixing of transactional and non-transactional tables is disabled" },
{ "ER_DUP_ARGUMENT", 1225, "Option \'%s\' used twice in statement" },
{ "ER_USER_LIMIT_REACHED", 1226, "User \'%-.64s\' has exceeded the \'%s\' resource (current value: %ld)" },
{ "ER_SPECIFIC_ACCESS_DENIED_ERROR", 1227, "Access denied; you need (at least one of) the %-.128s privilege(s) for this operation" },
{ "ER_LOCAL_VARIABLE", 1228, "Variable \'%-.64s\' is a SESSION variable and can\'t be used with SET GLOBAL" },
{ "ER_GLOBAL_VARIABLE", 1229, "Variable \'%-.64s\' is a GLOBAL variable and should be set with SET GLOBAL" },
{ "ER_NO_DEFAULT", 1230, "Variable \'%-.64s\' doesn\'t have a default value" },
{ "ER_WRONG_VALUE_FOR_VAR", 1231, "Variable \'%-.64s\' can\'t be set to the value of \'%-.200T\'" },
{ "ER_WRONG_TYPE_FOR_VAR", 1232, "Incorrect argument type to variable \'%-.64s\'" },
{ "ER_VAR_CANT_BE_READ", 1233, "Variable \'%-.64s\' can only be set, not read" },
{ "ER_CANT_USE_OPTION_HERE", 1234, "Incorrect usage/placement of \'%s\'" },
{ "ER_NOT_SUPPORTED_YET", 1235, "This version of MariaDB doesn\'t yet support \'%s\'" },
{ "ER_MASTER_FATAL_ERROR_READING_BINLOG", 1236, "Got fatal error %d from master when reading data from binary log: \'%-.320s\'" },
{ "ER_SLAVE_IGNORED_TABLE", 1237, "Slave SQL thread ignored the query because of replicate-*-table rules" },
{ "ER_INCORRECT_GLOBAL_LOCAL_VAR", 1238, "Variable \'%-.192s\' is a %s variable" },
{ "ER_WRONG_FK_DEF", 1239, "Incorrect foreign key definition for \'%-.192s\': %s" },
{ "ER_KEY_REF_DO_NOT_MATCH_TABLE_REF", 1240, "Key reference and table reference don\'t match" },
{ "ER_OPERAND_COLUMNS", 1241, "Operand should contain %d column(s)" },
{ "ER_SUBQUERY_NO_1_ROW", 1242, "Subquery returns more than 1 row" },
{ "ER_UNKNOWN_STMT_HANDLER", 1243, "Unknown prepared statement handler (%.*s) given to %s" },
{ "ER_CORRUPT_HELP_DB", 1244, "Help database is corrupt or does not exist" },
{ "ER_CYCLIC_REFERENCE", 1245, "Cyclic reference on subqueries" },
{ "ER_AUTO_CONVERT", 1246, "Converting column \'%s\' from %s to %s" },
{ "ER_ILLEGAL_REFERENCE", 1247, "Reference \'%-.64s\' not supported (%s)" },
{ "ER_DERIVED_MUST_HAVE_ALIAS", 1248, "Every derived table must have its own alias" },
{ "ER_SELECT_REDUCED", 1249, "Select %u was reduced during optimization" },
{ "ER_TABLENAME_NOT_ALLOWED_HERE", 1250, "Table \'%-.192s\' from one of the SELECTs cannot be used in %-.32s" },
{ "ER_NOT_SUPPORTED_AUTH_MODE", 1251, "Client does not support authentication protocol requested by server; consider upgrading MariaDB client" },
{ "ER_SPATIAL_CANT_HAVE_NULL", 1252, "All parts of a SPATIAL index must be NOT NULL" },
{ "ER_COLLATION_CHARSET_MISMATCH", 1253, "COLLATION \'%s\' is not valid for CHARACTER SET \'%s\'" },
{ "ER_SLAVE_WAS_RUNNING", 1254, "Slave is already running" },
{ "ER_SLAVE_WAS_NOT_RUNNING", 1255, "Slave already has been stopped" },
{ "ER_TOO_BIG_FOR_UNCOMPRESS", 1256, "Uncompressed data size too large; the maximum size is %d (probably, length of uncompressed data was corrupted)" },
{ "ER_ZLIB_Z_MEM_ERROR", 1257, "ZLIB: Not enough memory" },
{ "ER_ZLIB_Z_BUF_ERROR", 1258, "ZLIB: Not enough room in the output buffer (probably, length of uncompressed data was corrupted)" },
{ "ER_ZLIB_Z_DATA_ERROR", 1259, "ZLIB: Input data corrupted" },
{ "ER_CUT_VALUE_GROUP_CONCAT", 1260, "Row %u was cut by %s)" },
{ "ER_WARN_TOO_FEW_RECORDS", 1261, "Row %lu doesn\'t contain data for all columns" },
{ "ER_WARN_TOO_MANY_RECORDS", 1262, "Row %lu was truncated; it contained more data than there were input columns" },
{ "ER_WARN_NULL_TO_NOTNULL", 1263, "Column set to default value; NULL supplied to NOT NULL column \'%s\' at row %lu" },
{ "ER_WARN_DATA_OUT_OF_RANGE", 1264, "Out of range value for column \'%s\' at row %lu" },
{ "WARN_DATA_TRUNCATED", 1265, "Data truncated for column \'%s\' at row %lu" },
{ "ER_WARN_USING_OTHER_HANDLER", 1266, "Using storage engine %s for table \'%s\'" },
{ "ER_CANT_AGGREGATE_2COLLATIONS", 1267, "Illegal mix of collations (%s,%s) and (%s,%s) for operation \'%s\'" },
{ "ER_DROP_USER", 1268, "Cannot drop one or more of the requested users" },
{ "ER_REVOKE_GRANTS", 1269, "Can\'t revoke all privileges for one or more of the requested users" },
{ "ER_CANT_AGGREGATE_3COLLATIONS", 1270, "Illegal mix of collations (%s,%s), (%s,%s), (%s,%s) for operation \'%s\'" },
{ "ER_CANT_AGGREGATE_NCOLLATIONS", 1271, "Illegal mix of collations for operation \'%s\'" },
{ "ER_VARIABLE_IS_NOT_STRUCT", 1272, "Variable \'%-.64s\' is not a variable component (can\'t be used as XXXX.variable_name)" },
{ "ER_UNKNOWN_COLLATION", 1273, "Unknown collation: \'%-.64s\'" },
{ "ER_SLAVE_IGNORED_SSL_PARAMS", 1274, "SSL parameters in CHANGE MASTER are ignored because this MariaDB slave was compiled without SSL support; they can be used later if MariaDB slave with SSL is started" },
{ "ER_SERVER_IS_IN_SECURE_AUTH_MODE", 1275, "Server is running in --secure-auth mode, but \'%s\'@\'%s\' has a password in the old format; please change the password to the new format" },
{ "ER_WARN_FIELD_RESOLVED", 1276, "Field or reference \'%-.192s%s%-.192s%s%-.192s\' of SELECT #%d was resolved in SELECT #%d" },
{ "ER_BAD_SLAVE_UNTIL_COND", 1277, "Incorrect parameter or combination of parameters for START SLAVE UNTIL" },
{ "ER_MISSING_SKIP_SLAVE", 1278, "It is recommended to use --skip-slave-start when doing step-by-step replication with START SLAVE UNTIL; otherwise, you will get problems if you get an unexpected slave\'s mariadbd restart" },
{ "ER_UNTIL_COND_IGNORED", 1279, "SQL thread is not to be started so UNTIL options are ignored" },
{ "ER_WRONG_NAME_FOR_INDEX", 1280, "Incorrect index name \'%-.100s\'" },
{ "ER_WRONG_NAME_FOR_CATALOG", 1281, "Incorrect catalog name \'%-.100s\'" },
{ "ER_WARN_QC_RESIZE", 1282, "Query cache failed to set size %llu; new query cache size is %lu" },
{ "ER_BAD_FT_COLUMN", 1283, "Column \'%-.192s\' cannot be part of FULLTEXT index" },
{ "ER_UNKNOWN_KEY_CACHE", 1284, "Unknown key cache \'%-.100s\'" },
{ "ER_WARN_HOSTNAME_WONT_WORK", 1285, "MariaDB is started in --skip-name-resolve mode; you must restart it without this switch for this grant to work" },
{ "ER_UNKNOWN_STORAGE_ENGINE", 1286, "Unknown storage engine \'%s\'" },
{ "ER_WARN_DEPRECATED_SYNTAX", 1287, "\'%s\' is deprecated and will be removed in a future release. Please use %s instead" },
{ "ER_NON_UPDATABLE_TABLE", 1288, "The target table %-.100s of the %s is not updatable" },
{ "ER_FEATURE_DISABLED", 1289, "The \'%s\' feature is disabled; you need MariaDB built with \'%s\' to have it working" },
{ "ER_OPTION_PREVENTS_STATEMENT", 1290, "The MariaDB server is running with the %s option so it cannot execute this statement" },
{ "ER_DUPLICATED_VALUE_IN_TYPE", 1291, "Column \'%-.100s\' has duplicated value \'%-.64s\' in %s" },
{ "ER_TRUNCATED_WRONG_VALUE", 1292, "Truncated incorrect %-.32T value: \'%-.128T\'" },
{ "ER_TOO_MUCH_AUTO_TIMESTAMP_COLS", 1293, "Incorrect table definition; there can be only one TIMESTAMP column with CURRENT_TIMESTAMP in DEFAULT or ON UPDATE clause" },
{ "ER_INVALID_ON_UPDATE", 1294, "Invalid ON UPDATE clause for \'%-.192s\' column" },
{ "ER_UNSUPPORTED_PS", 1295, "This command is not supported in the prepared statement protocol yet" },
{ "ER_GET_ERRMSG", 1296, "Got error %d \'%-.200s\' from %s" },
{ "ER_GET_TEMPORARY_ERRMSG", 1297, "Got temporary error %d \'%-.200s\' from %s" },
{ "ER_UNKNOWN_TIME_ZONE", 1298, "Unknown or incorrect time zone: \'%-.64s\'" },
{ "ER_WARN_INVALID_TIMESTAMP", 1299, "Invalid TIMESTAMP value in column \'%s\' at row %lu" },
{ "ER_INVALID_CHARACTER_STRING", 1300, "Invalid %s character string: \'%.64T\'" },
{ "ER_WARN_ALLOWED_PACKET_OVERFLOWED", 1301, "Result of %s() was larger than max_allowed_packet (%ld) - truncated" },
{ "ER_CONFLICTING_DECLARATIONS", 1302, "Conflicting declarations: \'%s%s\' and \'%s%s\'" },
{ "ER_SP_NO_RECURSIVE_CREATE", 1303, "Can\'t create a %s from within another stored routine" },
{ "ER_SP_ALREADY_EXISTS", 1304, "%s %s already exists" },
{ "ER_SP_DOES_NOT_EXIST", 1305, "%s %s does not exist" },
{ "ER_SP_DROP_FAILED", 1306, "Failed to DROP %s %s" },
{ "ER_SP_STORE_FAILED", 1307, "Failed to CREATE %s %s" },
{ "ER_SP_LILABEL_MISMATCH", 1308, "%s with no matching label: %s" },
{ "ER_SP_LABEL_REDEFINE", 1309, "Redefining label %s" },
{ "ER_SP_LABEL_MISMATCH", 1310, "End-label %s without match" },
{ "ER_SP_UNINIT_VAR", 1311, "Referring to uninitialized variable %s" },
{ "ER_SP_BADSELECT", 1312, "PROCEDURE %s can\'t return a result set in the given context" },
{ "ER_SP_BADRETURN", 1313, "RETURN is only allowed in a FUNCTION" },
{ "ER_SP_BADSTATEMENT", 1314, "%s is not allowed in stored procedures" },
{ "ER_UPDATE_LOG_DEPRECATED_IGNORED", 1315, "The update log is deprecated and replaced by the binary log; SET SQL_LOG_UPDATE has been ignored. This option will be removed in MariaDB 5.6" },
{ "ER_UPDATE_LOG_DEPRECATED_TRANSLATED", 1316, "The update log is deprecated and replaced by the binary log; SET SQL_LOG_UPDATE has been translated to SET SQL_LOG_BIN. This option will be removed in MariaDB 5.6" },
{ "ER_QUERY_INTERRUPTED", 1317, "Query execution was interrupted" },
{ "ER_SP_WRONG_NO_OF_ARGS", 1318, "Incorrect number of arguments for %s %s; expected %u, got %u" },
{ "ER_SP_COND_MISMATCH", 1319, "Undefined CONDITION: %s" },
{ "ER_SP_NORETURN", 1320, "No RETURN found in FUNCTION %s" },
{ "ER_SP_NORETURNEND", 1321, "FUNCTION %s ended without RETURN" },
{ "ER_SP_BAD_CURSOR_QUERY", 1322, "Cursor statement must be a SELECT" },
{ "ER_SP_BAD_CURSOR_SELECT", 1323, "Cursor SELECT must not have INTO" },
{ "ER_SP_CURSOR_MISMATCH", 1324, "Undefined CURSOR: %s" },
{ "ER_SP_CURSOR_ALREADY_OPEN", 1325, "Cursor is already open" },
{ "ER_SP_CURSOR_NOT_OPEN", 1326, "Cursor is not open" },
{ "ER_SP_UNDECLARED_VAR", 1327, "Undeclared variable: %s" },
{ "ER_SP_WRONG_NO_OF_FETCH_ARGS", 1328, "Incorrect number of FETCH variables" },
{ "ER_SP_FETCH_NO_DATA", 1329, "No data - zero rows fetched, selected, or processed" },
{ "ER_SP_DUP_PARAM", 1330, "Duplicate parameter: %s" },
{ "ER_SP_DUP_VAR", 1331, "Duplicate variable: %s" },
{ "ER_SP_DUP_COND", 1332, "Duplicate condition: %s" },
{ "ER_SP_DUP_CURS", 1333, "Duplicate cursor: %s" },
{ "ER_SP_CANT_ALTER", 1334, "Failed to ALTER %s %s" },
{ "ER_SP_SUBSELECT_NYI", 1335, "Subquery value not supported" },
{ "ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG", 1336, "%s is not allowed in stored function or trigger" },
{ "ER_SP_VARCOND_AFTER_CURSHNDLR", 1337, "Variable or condition declaration after cursor or handler declaration" },
{ "ER_SP_CURSOR_AFTER_HANDLER", 1338, "Cursor declaration after handler declaration" },
{ "ER_SP_CASE_NOT_FOUND", 1339, "Case not found for CASE statement" },
{ "ER_FPARSER_TOO_BIG_FILE", 1340, "Configuration file \'%-.192s\' is too big" },
{ "ER_FPARSER_BAD_HEADER", 1341, "Malformed file type header in file \'%-.192s\'" },
{ "ER_FPARSER_EOF_IN_COMMENT", 1342, "Unexpected end of file while parsing comment \'%-.200s\'" },
{ "ER_FPARSER_ERROR_IN_PARAMETER", 1343, "Error while parsing parameter \'%-.192s\' (line: \'%-.192s\')" },
{ "ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER", 1344, "Unexpected end of file while skipping unknown parameter \'%-.192s\'" },
{ "ER_VIEW_NO_EXPLAIN", 1345, "ANALYZE/EXPLAIN/SHOW can not be issued; lacking privileges for underlying table" },
{ "ER_FRM_UNKNOWN_TYPE", 1346, "File \'%-.192s\' has unknown type \'%-.64s\' in its header" },
{ "ER_WRONG_OBJECT", 1347, "\'%-.192s.%-.192s\' is not of type \'%s\'" },
{ "ER_NONUPDATEABLE_COLUMN", 1348, "Column \'%-.192s\' is not updatable" },
{ "ER_VIEW_SELECT_DERIVED", 1349, "View\'s SELECT contains a subquery in the FROM clause" },
{ "ER_VIEW_SELECT_CLAUSE", 1350, "View\'s SELECT contains a \'%s\' clause" },
{ "ER_VIEW_SELECT_VARIABLE", 1351, "View\'s SELECT contains a variable or parameter" },
{ "ER_VIEW_SELECT_TMPTABLE", 1352, "View\'s SELECT refers to a temporary table \'%-.192s\'" },
{ "ER_VIEW_WRONG_LIST", 1353, "View\'s SELECT and view\'s field list have different column counts" },
{ "ER_WARN_VIEW_MERGE", 1354, "View merge algorithm can\'t be used here for now (assumed undefined algorithm)" },
{ "ER_WARN_VIEW_WITHOUT_KEY", 1355, "View being updated does not have complete key of underlying table in it" },
{ "ER_VIEW_INVALID", 1356, "View \'%-.192s.%-.192s\' references invalid table(s) or column(s) or function(s) or definer/invoker of view lack rights to use them" },
{ "ER_SP_NO_DROP_SP", 1357, "Can\'t drop or alter a %s from within another stored routine" },
{ "ER_SP_GOTO_IN_HNDLR", 1358, "GOTO is not allowed in a stored procedure handler" },
{ "ER_TRG_ALREADY_EXISTS", 1359, "Trigger \'%s\' already exists" },
{ "ER_TRG_DOES_NOT_EXIST", 1360, "Trigger does not exist" },
{ "ER_TRG_ON_VIEW_OR_TEMP_TABLE", 1361, "Trigger\'s \'%-.192s\' is a view, temporary table or sequence" },
{ "ER_TRG_CANT_CHANGE_ROW", 1362, "Updating of %s row is not allowed in %strigger" },
{ "ER_TRG_NO_SUCH_ROW_IN_TRG", 1363, "There is no %s row in %s trigger" },
{ "ER_NO_DEFAULT_FOR_FIELD", 1364, "Field \'%-.192s\' doesn\'t have a default value" },
{ "ER_DIVISION_BY_ZERO", 1365, "Division by 0" },
{ "ER_TRUNCATED_WRONG_VALUE_FOR_FIELD", 1366, "Incorrect %-.32s value: \'%-.128T\' for column `%.192s`.`%.192s`.`%.192s` at row %lu" },
{ "ER_ILLEGAL_VALUE_FOR_TYPE", 1367, "Illegal %s \'%-.192T\' value found during parsing" },
{ "ER_VIEW_NONUPD_CHECK", 1368, "CHECK OPTION on non-updatable view %`-.192s.%`-.192s" },
{ "ER_VIEW_CHECK_FAILED", 1369, "CHECK OPTION failed %`-.192s.%`-.192s" },
{ "ER_PROCACCESS_DENIED_ERROR", 1370, "%-.32s command denied to user \'%s\'@\'%s\' for routine \'%-.192s\'" },
{ "ER_RELAY_LOG_FAIL", 1371, "Failed purging old relay logs: %s" },
{ "ER_PASSWD_LENGTH", 1372, "Password hash should be a %d-digit hexadecimal number" },
{ "ER_UNKNOWN_TARGET_BINLOG", 1373, "Target log not found in binlog index" },
{ "ER_IO_ERR_LOG_INDEX_READ", 1374, "I/O error reading log index file" },
{ "ER_BINLOG_PURGE_PROHIBITED", 1375, "Server configuration does not permit binlog purge" },
{ "ER_FSEEK_FAIL", 1376, "Failed on fseek()" },
{ "ER_BINLOG_PURGE_FATAL_ERR", 1377, "Fatal error during log purge" },
{ "ER_LOG_IN_USE", 1378, "A purgeable log is in use, will not purge" },
{ "ER_LOG_PURGE_UNKNOWN_ERR", 1379, "Unknown error during log purge" },
{ "ER_RELAY_LOG_INIT", 1380, "Failed initializing relay log position: %s" },
{ "ER_NO_BINARY_LOGGING", 1381, "You are not using binary logging" },
{ "ER_RESERVED_SYNTAX", 1382, "The \'%-.64s\' syntax is reserved for purposes internal to the MariaDB server" },
{ "ER_WSAS_FAILED", 1383, "WSAStartup Failed" },
{ "ER_DIFF_GROUPS_PROC", 1384, "Can\'t handle procedures with different groups yet" },
{ "ER_NO_GROUP_FOR_PROC", 1385, "Select must have a group with this procedure" },
{ "ER_ORDER_WITH_PROC", 1386, "Can\'t use ORDER clause with this procedure" },
{ "ER_LOGGING_PROHIBIT_CHANGING_OF", 1387, "Binary logging and replication forbid changing the global server %s" },
{ "ER_NO_FILE_MAPPING", 1388, "Can\'t map file: %-.200s, errno: %M" },
{ "ER_WRONG_MAGIC", 1389, "Wrong magic in %-.64s" },
{ "ER_PS_MANY_PARAM", 1390, "Prepared statement contains too many placeholders" },
{ "ER_KEY_PART_0", 1391, "Key part \'%-.192s\' length cannot be 0" },
{ "ER_VIEW_CHECKSUM", 1392, "View text checksum failed" },
{ "ER_VIEW_MULTIUPDATE", 1393, "Can not modify more than one base table through a join view \'%-.192s.%-.192s\'" },
{ "ER_VIEW_NO_INSERT_FIELD_LIST", 1394, "Can not insert into join view \'%-.192s.%-.192s\' without fields list" },
{ "ER_VIEW_DELETE_MERGE_VIEW", 1395, "Can not delete from join view \'%-.192s.%-.192s\'" },
{ "ER_CANNOT_USER", 1396, "Operation %s failed for %.256s" },
{ "ER_XAER_NOTA", 1397, "XAER_NOTA: Unknown XID" },
{ "ER_XAER_INVAL", 1398, "XAER_INVAL: Invalid arguments (or unsupported command)" },
{ "ER_XAER_RMFAIL", 1399, "XAER_RMFAIL: The command cannot be executed when global transaction is in the %.64s state" },
{ "ER_XAER_OUTSIDE", 1400, "XAER_OUTSIDE: Some work is done outside global transaction" },
{ "ER_XAER_RMERR", 1401, "XAER_RMERR: Fatal error occurred in the transaction branch - check your data for consistency" },
{ "ER_XA_RBROLLBACK", 1402, "XA_RBROLLBACK: Transaction branch was rolled back" },
{ "ER_NONEXISTING_PROC_GRANT", 1403, "There is no such grant defined for user \'%-.48s\' on host \'%-.64s\' on routine \'%-.192s\'" },
{ "ER_PROC_AUTO_GRANT_FAIL", 1404, "Failed to grant EXECUTE and ALTER ROUTINE privileges" },
{ "ER_PROC_AUTO_REVOKE_FAIL", 1405, "Failed to revoke all privileges to dropped routine" },
{ "ER_DATA_TOO_LONG", 1406, "Data too long for column \'%s\' at row %lu" },
{ "ER_SP_BAD_SQLSTATE", 1407, "Bad SQLSTATE: \'%s\'" },
{ "ER_STARTUP", 1408, "%s: ready for connections.\nVersion: \'%s\' socket: \'%s\' port: %d %s" },
{ "ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR", 1409, "Can\'t load value from file with fixed size rows to variable" },
{ "ER_CANT_CREATE_USER_WITH_GRANT", 1410, "You are not allowed to create a user with GRANT" },
{ "ER_WRONG_VALUE_FOR_TYPE", 1411, "Incorrect %-.32s value: \'%-.128T\' for function %-.32s" },
{ "ER_TABLE_DEF_CHANGED", 1412, "Table definition has changed, please retry transaction" },
{ "ER_SP_DUP_HANDLER", 1413, "Duplicate handler declared in the same block" },
{ "ER_SP_NOT_VAR_ARG", 1414, "OUT or INOUT argument %d for routine %s is not a variable or NEW pseudo-variable in BEFORE trigger" },
{ "ER_SP_NO_RETSET", 1415, "Not allowed to return a result set from a %s" },
{ "ER_CANT_CREATE_GEOMETRY_OBJECT", 1416, "Cannot get geometry object from data you send to the GEOMETRY field" },
{ "ER_FAILED_ROUTINE_BREAK_BINLOG", 1417, "A routine failed and has neither NO SQL nor READS SQL DATA in its declaration and binary logging is enabled; if non-transactional tables were updated, the binary log will miss their changes" },
{ "ER_BINLOG_UNSAFE_ROUTINE", 1418, "This function has none of DETERMINISTIC, NO SQL, or READS SQL DATA in its declaration and binary logging is enabled (you *might* want to use the less safe log_bin_trust_function_creators variable)" },
{ "ER_BINLOG_CREATE_ROUTINE_NEED_SUPER", 1419, "You do not have the SUPER privilege and binary logging is enabled (you *might* want to use the less safe log_bin_trust_function_creators variable)" },
{ "ER_EXEC_STMT_WITH_OPEN_CURSOR", 1420, "You can\'t execute a prepared statement which has an open cursor associated with it. Reset the statement to re-execute it" },
{ "ER_STMT_HAS_NO_OPEN_CURSOR", 1421, "The statement (%lu) has no open cursor" },
{ "ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG", 1422, "Explicit or implicit commit is not allowed in stored function or trigger" },
{ "ER_NO_DEFAULT_FOR_VIEW_FIELD", 1423, "Field of view \'%-.192s.%-.192s\' underlying table doesn\'t have a default value" },
{ "ER_SP_NO_RECURSION", 1424, "Recursive stored functions and triggers are not allowed" },
{ "ER_TOO_BIG_SCALE", 1425, "Too big scale specified for \'%-.192s\'. Maximum is %u" },
{ "ER_TOO_BIG_PRECISION", 1426, "Too big precision specified for \'%-.192s\'. Maximum is %u" },
{ "ER_M_BIGGER_THAN_D", 1427, "For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column \'%-.192s\')" },
{ "ER_WRONG_LOCK_OF_SYSTEM_TABLE", 1428, "You can\'t combine write-locking of system tables with other tables or lock types" },
{ "ER_CONNECT_TO_FOREIGN_DATA_SOURCE", 1429, "Unable to connect to foreign data source: %.64s" },
{ "ER_QUERY_ON_FOREIGN_DATA_SOURCE", 1430, "There was a problem processing the query on the foreign data source. Data source error: %-.64s" },
{ "ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST", 1431, "The foreign data source you are trying to reference does not exist. Data source error: %-.64s" },
{ "ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE", 1432, "Can\'t create federated table. The data source connection string \'%-.64s\' is not in the correct format" },
{ "ER_FOREIGN_DATA_STRING_INVALID", 1433, "The data source connection string \'%-.64s\' is not in the correct format" },
{ "ER_CANT_CREATE_FEDERATED_TABLE", 1434, "Can\'t create federated table. Foreign data src error: %-.64s" },
{ "ER_TRG_IN_WRONG_SCHEMA", 1435, "Trigger in wrong schema" },
{ "ER_STACK_OVERRUN_NEED_MORE", 1436, "Thread stack overrun: %ld bytes used of a %ld byte stack, and %ld bytes needed. Consider increasing the thread_stack system variable." },
{ "ER_TOO_LONG_BODY", 1437, "Routine body for \'%-.100s\' is too long" },
{ "ER_WARN_CANT_DROP_DEFAULT_KEYCACHE", 1438, "Cannot drop default keycache" },
{ "ER_TOO_BIG_DISPLAYWIDTH", 1439, "Display width out of range for \'%-.192s\' (max = %lu)" },
{ "ER_XAER_DUPID", 1440, "XAER_DUPID: The XID already exists" },
{ "ER_DATETIME_FUNCTION_OVERFLOW", 1441, "Datetime function: %-.32s field overflow" },
{ "ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG", 1442, "Can\'t update table \'%-.192s\' in stored function/trigger because it is already used by statement which invoked this stored function/trigger" },
{ "ER_VIEW_PREVENT_UPDATE", 1443, "The definition of table \'%-.192s\' prevents operation %-.192s on table \'%-.192s\'" },
{ "ER_PS_NO_RECURSION", 1444, "The prepared statement contains a stored routine call that refers to that same statement. It\'s not allowed to execute a prepared statement in such a recursive manner" },
{ "ER_SP_CANT_SET_AUTOCOMMIT", 1445, "Not allowed to set autocommit from a stored function or trigger" },
{ "ER_MALFORMED_DEFINER", 1446, "Invalid definer" },
{ "ER_VIEW_FRM_NO_USER", 1447, "View \'%-.192s\'.\'%-.192s\' has no definer information (old table format). Current user is used as definer. Please recreate the view!" },
{ "ER_UNUSED_30", 1448, "You should never see it" },
{ "ER_NO_SUCH_USER", 1449, "The user specified as a definer (\'%-.64s\'@\'%-.64s\') does not exist" },
{ "ER_FORBID_SCHEMA_CHANGE", 1450, "Changing schema from \'%-.192s\' to \'%-.192s\' is not allowed" },
{ "ER_ROW_IS_REFERENCED_2", 1451, "Cannot delete or update a parent row: a foreign key constraint fails (%s)" },
{ "ER_NO_REFERENCED_ROW_2", 1452, "Cannot add or update a child row: a foreign key constraint fails (%s)" },
{ "ER_SP_BAD_VAR_SHADOW", 1453, "Variable \'%-.64s\' must be quoted with `...`, or renamed" },
{ "ER_TRG_NO_DEFINER", 1454, "No definer attribute for trigger \'%-.192s\'.\'%-.192s\'. The trigger will be activated under the authorization of the invoker, which may have insufficient privileges. Please recreate the trigger" },
{ "ER_OLD_FILE_FORMAT", 1455, "\'%-.192s\' has an old format, you should re-create the \'%s\' object(s)" },
{ "ER_SP_RECURSION_LIMIT", 1456, "Recursive limit %d (as set by the max_sp_recursion_depth variable) was exceeded for routine %.192s" },
{ "ER_SP_PROC_TABLE_CORRUPT", 1457, "Failed to load routine %-.192s (internal code %d). For more details, run SHOW WARNINGS" },
{ "ER_SP_WRONG_NAME", 1458, "Incorrect routine name \'%-.192s\'" },
{ "ER_TABLE_NEEDS_UPGRADE", 1459, "Upgrade required. Please do \"REPAIR %s %`s\" or dump/reload to fix it!" },
{ "ER_SP_NO_AGGREGATE", 1460, "AGGREGATE is not supported for stored functions" },
{ "ER_MAX_PREPARED_STMT_COUNT_REACHED", 1461, "Can\'t create more than max_prepared_stmt_count statements (current value: %u)" },
{ "ER_VIEW_RECURSIVE", 1462, "%`s.%`s contains view recursion" },
{ "ER_NON_GROUPING_FIELD_USED", 1463, "Non-grouping field \'%-.192s\' is used in %-.64s clause" },
{ "ER_TABLE_CANT_HANDLE_SPKEYS", 1464, "The storage engine %s doesn\'t support SPATIAL indexes" },
{ "ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA", 1465, "Triggers can not be created on system tables" },
{ "ER_REMOVED_SPACES", 1466, "Leading spaces are removed from name \'%s\'" },
{ "ER_AUTOINC_READ_FAILED", 1467, "Failed to read auto-increment value from storage engine" },
{ "ER_USERNAME", 1468, "user name" },
{ "ER_HOSTNAME", 1469, "host name" },
{ "ER_WRONG_STRING_LENGTH", 1470, "String \'%-.70T\' is too long for %s (should be no longer than %d)" },
{ "ER_NON_INSERTABLE_TABLE", 1471, "The target table %-.100s of the %s is not insertable-into" },
{ "ER_ADMIN_WRONG_MRG_TABLE", 1472, "Table \'%-.64s\' is differently defined or of non-MyISAM type or doesn\'t exist" },
{ "ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT", 1473, "Too high level of nesting for select" },
{ "ER_NAME_BECOMES_EMPTY", 1474, "Name \'%-.64s\' has become \'\'" },
{ "ER_AMBIGUOUS_FIELD_TERM", 1475, "First character of the FIELDS TERMINATED string is ambiguous; please use non-optional and non-empty FIELDS ENCLOSED BY" },
{ "ER_FOREIGN_SERVER_EXISTS", 1476, "Cannot create foreign server \'%s\' as it already exists" },
{ "ER_FOREIGN_SERVER_DOESNT_EXIST", 1477, "The foreign server name you are trying to reference does not exist. Data source error: %-.64s" },
{ "ER_ILLEGAL_HA_CREATE_OPTION", 1478, "Table storage engine \'%-.64s\' does not support the create option \'%.64s\'" },
{ "ER_PARTITION_REQUIRES_VALUES_ERROR", 1479, "Syntax error: %-.64s PARTITIONING requires definition of VALUES %-.64s for each partition" },
{ "ER_PARTITION_WRONG_VALUES_ERROR", 1480, "Only %-.64s PARTITIONING can use VALUES %-.64s in partition definition" },
{ "ER_PARTITION_MAXVALUE_ERROR", 1481, "MAXVALUE can only be used in last partition definition" },
{ "ER_PARTITION_SUBPARTITION_ERROR", 1482, "Subpartitions can only be hash partitions and by key" },
{ "ER_PARTITION_SUBPART_MIX_ERROR", 1483, "Must define subpartitions on all partitions if on one partition" },
{ "ER_PARTITION_WRONG_NO_PART_ERROR", 1484, "Wrong number of partitions defined, mismatch with previous setting" },
{ "ER_PARTITION_WRONG_NO_SUBPART_ERROR", 1485, "Wrong number of subpartitions defined, mismatch with previous setting" },
{ "ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR", 1486, "Constant, random or timezone-dependent expressions in (sub)partitioning function are not allowed" },
{ "ER_NOT_CONSTANT_EXPRESSION", 1487, "Expression in %s must be constant" },
{ "ER_FIELD_NOT_FOUND_PART_ERROR", 1488, "Field in list of fields for partition function not found in table" },
{ "ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR", 1489, "List of fields is only allowed in KEY partitions" },
{ "ER_INCONSISTENT_PARTITION_INFO_ERROR", 1490, "The partition info in the frm file is not consistent with what can be written into the frm file" },
{ "ER_PARTITION_FUNC_NOT_ALLOWED_ERROR", 1491, "The %-.192s function returns the wrong type" },
{ "ER_PARTITIONS_MUST_BE_DEFINED_ERROR", 1492, "For %-.64s partitions each partition must be defined" },
{ "ER_RANGE_NOT_INCREASING_ERROR", 1493, "VALUES LESS THAN value must be strictly increasing for each partition" },
{ "ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR", 1494, "VALUES value must be of same type as partition function" },
{ "ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR", 1495, "Multiple definition of same constant in list partitioning" },
{ "ER_PARTITION_ENTRY_ERROR", 1496, "Partitioning can not be used stand-alone in query" },
{ "ER_MIX_HANDLER_ERROR", 1497, "The mix of handlers in the partitions is not allowed in this version of MariaDB" },
{ "ER_PARTITION_NOT_DEFINED_ERROR", 1498, "For the partitioned engine it is necessary to define all %-.64s" },
{ "ER_TOO_MANY_PARTITIONS_ERROR", 1499, "Too many partitions (including subpartitions) were defined" },
{ "ER_SUBPARTITION_ERROR", 1500, "It is only possible to mix RANGE/LIST partitioning with HASH/KEY partitioning for subpartitioning" },
{ "ER_CANT_CREATE_HANDLER_FILE", 1501, "Failed to create specific handler file" },
{ "ER_BLOB_FIELD_IN_PART_FUNC_ERROR", 1502, "A BLOB field is not allowed in partition function" },
{ "ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF", 1503, "A %-.192s must include all columns in the table\'s partitioning function" },
{ "ER_NO_PARTS_ERROR", 1504, "Number of %-.64s = 0 is not an allowed value" },
{ "ER_PARTITION_MGMT_ON_NONPARTITIONED", 1505, "Partition management on a not partitioned table is not possible" },
{ "ER_FEATURE_NOT_SUPPORTED_WITH_PARTITIONING", 1506, "Partitioned tables do not support %s" },
{ "ER_PARTITION_DOES_NOT_EXIST", 1507, "Wrong partition name or partition list" },
{ "ER_DROP_LAST_PARTITION", 1508, "Cannot remove all partitions, use DROP TABLE instead" },
{ "ER_COALESCE_ONLY_ON_HASH_PARTITION", 1509, "COALESCE PARTITION can only be used on HASH/KEY partitions" },
{ "ER_REORG_HASH_ONLY_ON_SAME_NO", 1510, "REORGANIZE PARTITION can only be used to reorganize partitions not to change their numbers" },
{ "ER_REORG_NO_PARAM_ERROR", 1511, "REORGANIZE PARTITION without parameters can only be used on auto-partitioned tables using HASH PARTITIONs" },
{ "ER_ONLY_ON_RANGE_LIST_PARTITION", 1512, "%-.64s PARTITION can only be used on RANGE/LIST partitions" },
{ "ER_ADD_PARTITION_SUBPART_ERROR", 1513, "Trying to Add partition(s) with wrong number of subpartitions" },
{ "ER_ADD_PARTITION_NO_NEW_PARTITION", 1514, "At least one partition must be added" },
{ "ER_COALESCE_PARTITION_NO_PARTITION", 1515, "At least one partition must be coalesced" },
{ "ER_REORG_PARTITION_NOT_EXIST", 1516, "More partitions to reorganize than there are partitions" },
{ "ER_SAME_NAME_PARTITION", 1517, "Duplicate partition name %-.192s" },
{ "ER_NO_BINLOG_ERROR", 1518, "It is not allowed to shut off binlog on this command" },
{ "ER_CONSECUTIVE_REORG_PARTITIONS", 1519, "When reorganizing a set of partitions they must be in consecutive order" },
{ "ER_REORG_OUTSIDE_RANGE", 1520, "Reorganize of range partitions cannot change total ranges except for last partition where it can extend the range" },
{ "ER_PARTITION_FUNCTION_FAILURE", 1521, "Partition function not supported in this version for this handler" },
{ "ER_PART_STATE_ERROR", 1522, "Partition state cannot be defined from CREATE/ALTER TABLE" },
{ "ER_LIMITED_PART_RANGE", 1523, "The %-.64s handler only supports 32 bit integers in VALUES" },
{ "ER_PLUGIN_IS_NOT_LOADED", 1524, "Plugin \'%-.192s\' is not loaded" },
{ "ER_WRONG_VALUE", 1525, "Incorrect %-.32s value: \'%-.128T\'" },
{ "ER_NO_PARTITION_FOR_GIVEN_VALUE", 1526, "Table has no partition for value %-.64s" },
{ "ER_FILEGROUP_OPTION_ONLY_ONCE", 1527, "It is not allowed to specify %s more than once" },
{ "ER_CREATE_FILEGROUP_FAILED", 1528, "Failed to create %s" },
{ "ER_DROP_FILEGROUP_FAILED", 1529, "Failed to drop %s" },
{ "ER_TABLESPACE_AUTO_EXTEND_ERROR", 1530, "The handler doesn\'t support autoextend of tablespaces" },
{ "ER_WRONG_SIZE_NUMBER", 1531, "A size parameter was incorrectly specified, either number or on the form 10M" },
{ "ER_SIZE_OVERFLOW_ERROR", 1532, "The size number was correct but we don\'t allow the digit part to be more than 2 billion" },
{ "ER_ALTER_FILEGROUP_FAILED", 1533, "Failed to alter: %s" },
{ "ER_BINLOG_ROW_LOGGING_FAILED", 1534, "Writing one row to the row-based binary log failed" },
{ "ER_BINLOG_ROW_WRONG_TABLE_DEF", 1535, "Table definition on master and slave does not match: %s" },
{ "ER_BINLOG_ROW_RBR_TO_SBR", 1536, "Slave running with --log-slave-updates must use row-based binary logging to be able to replicate row-based binary log events" },
{ "ER_EVENT_ALREADY_EXISTS", 1537, "Event \'%-.192s\' already exists" },
{ "ER_EVENT_STORE_FAILED", 1538, "Failed to store event %s. Error code %M from storage engine" },
{ "ER_EVENT_DOES_NOT_EXIST", 1539, "Unknown event \'%-.192s\'" },
{ "ER_EVENT_CANT_ALTER", 1540, "Failed to alter event \'%-.192s\'" },
{ "ER_EVENT_DROP_FAILED", 1541, "Failed to drop %s" },
{ "ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG", 1542, "INTERVAL is either not positive or too big" },
{ "ER_EVENT_ENDS_BEFORE_STARTS", 1543, "ENDS is either invalid or before STARTS" },
{ "ER_EVENT_EXEC_TIME_IN_THE_PAST", 1544, "Event execution time is in the past. Event has been disabled" },
{ "ER_EVENT_OPEN_TABLE_FAILED", 1545, "Failed to open mysql.event" },
{ "ER_EVENT_NEITHER_M_EXPR_NOR_M_AT", 1546, "No datetime expression provided" },
{ "ER_UNUSED_2", 1547, "You should never see it" },
{ "ER_UNUSED_3", 1548, "You should never see it" },
{ "ER_EVENT_CANNOT_DELETE", 1549, "Failed to delete the event from mysql.event" },
{ "ER_EVENT_COMPILE_ERROR", 1550, "Error during compilation of event\'s body" },
{ "ER_EVENT_SAME_NAME", 1551, "Same old and new event name" },
{ "ER_EVENT_DATA_TOO_LONG", 1552, "Data for column \'%s\' too long" },
{ "ER_DROP_INDEX_FK", 1553, "Cannot drop index \'%-.192s\': needed in a foreign key constraint" },
{ "ER_WARN_DEPRECATED_SYNTAX_WITH_VER", 1554, "The syntax \'%s\' is deprecated and will be removed in MariaDB %s. Please use %s instead" },
{ "ER_CANT_WRITE_LOCK_LOG_TABLE", 1555, "You can\'t write-lock a log table. Only read access is possible" },
{ "ER_CANT_LOCK_LOG_TABLE", 1556, "You can\'t use locks with log tables" },
{ "ER_UNUSED_4", 1557, "You should never see it" },
{ "ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE", 1558, "Column count of mysql.%s is wrong. Expected %d, found %d. Created with MariaDB %d, now running %d. Please use mariadb-upgrade to fix this error" },
{ "ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR", 1559, "Cannot switch out of the row-based binary log format when the session has open temporary tables" },
{ "ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT", 1560, "Cannot change the binary logging format inside a stored function or trigger" },
{ "ER_UNUSED_13", 1561, "You should never see it" },
{ "ER_PARTITION_NO_TEMPORARY", 1562, "Cannot create temporary table with partitions" },
{ "ER_PARTITION_CONST_DOMAIN_ERROR", 1563, "Partition constant is out of partition function domain" },
{ "ER_PARTITION_FUNCTION_IS_NOT_ALLOWED", 1564, "This partition function is not allowed" },
{ "ER_DDL_LOG_ERROR", 1565, "Error in DDL log" },
{ "ER_NULL_IN_VALUES_LESS_THAN", 1566, "Not allowed to use NULL value in VALUES LESS THAN" },
{ "ER_WRONG_PARTITION_NAME", 1567, "Incorrect partition name" },
{ "ER_CANT_CHANGE_TX_CHARACTERISTICS", 1568, "Transaction characteristics can\'t be changed while a transaction is in progress" },
{ "ER_DUP_ENTRY_AUTOINCREMENT_CASE", 1569, "ALTER TABLE causes auto_increment resequencing, resulting in duplicate entry \'%-.192T\' for key \'%-.192s\'" },
{ "ER_EVENT_MODIFY_QUEUE_ERROR", 1570, "Internal scheduler error %d" },
{ "ER_EVENT_SET_VAR_ERROR", 1571, "Error during starting/stopping of the scheduler. Error code %M" },
{ "ER_PARTITION_MERGE_ERROR", 1572, "Engine cannot be used in partitioned tables" },
{ "ER_CANT_ACTIVATE_LOG", 1573, "Cannot activate \'%-.64s\' log" },
{ "ER_RBR_NOT_AVAILABLE", 1574, "The server was not built with row-based replication" },
{ "ER_BASE64_DECODE_ERROR", 1575, "Decoding of base64 string failed" },
{ "ER_EVENT_RECURSION_FORBIDDEN", 1576, "Recursion of EVENT DDL statements is forbidden when body is present" },
{ "ER_EVENTS_DB_ERROR", 1577, "Cannot proceed, because event scheduler is disabled" },
{ "ER_ONLY_INTEGERS_ALLOWED", 1578, "Only integers allowed as number here" },
{ "ER_UNSUPORTED_LOG_ENGINE", 1579, "Storage engine %s cannot be used for log tables" },
{ "ER_BAD_LOG_STATEMENT", 1580, "You cannot \'%s\' a log table if logging is enabled" },
{ "ER_CANT_RENAME_LOG_TABLE", 1581, "Cannot rename \'%s\'. When logging enabled, rename to/from log table must rename two tables: the log table to an archive table and another table back to \'%s\'" },
{ "ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT", 1582, "Incorrect parameter count in the call to native function \'%-.192s\'" },
{ "ER_WRONG_PARAMETERS_TO_NATIVE_FCT", 1583, "Incorrect parameters in the call to native function \'%-.192s\'" },
{ "ER_WRONG_PARAMETERS_TO_STORED_FCT", 1584, "Incorrect parameters in the call to stored function \'%-.192s\'" },
{ "ER_NATIVE_FCT_NAME_COLLISION", 1585, "This function \'%-.192s\' has the same name as a native function" },
{ "ER_DUP_ENTRY_WITH_KEY_NAME", 1586, "Duplicate entry \'%-.64T\' for key \'%-.192s\'" },
{ "ER_BINLOG_PURGE_EMFILE", 1587, "Too many files opened, please execute the command again" },
{ "ER_EVENT_CANNOT_CREATE_IN_THE_PAST", 1588, "Event execution time is in the past and ON COMPLETION NOT PRESERVE is set. The event was dropped immediately after creation" },
{ "ER_EVENT_CANNOT_ALTER_IN_THE_PAST", 1589, "Event execution time is in the past and ON COMPLETION NOT PRESERVE is set. The event was not changed. Specify a time in the future" },
{ "ER_SLAVE_INCIDENT", 1590, "The incident %s occurred on the master. Message: %-.64s" },
{ "ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT", 1591, "Table has no partition for some existing values" },
{ "ER_BINLOG_UNSAFE_STATEMENT", 1592, "Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. %s" },
{ "ER_SLAVE_FATAL_ERROR", 1593, "Fatal error: %s" },
{ "ER_SLAVE_RELAY_LOG_READ_FAILURE", 1594, "Relay log read failure: %s" },
{ "ER_SLAVE_RELAY_LOG_WRITE_FAILURE", 1595, "Relay log write failure: %s" },
{ "ER_SLAVE_CREATE_EVENT_FAILURE", 1596, "Failed to create %s" },
{ "ER_SLAVE_MASTER_COM_FAILURE", 1597, "Master command %s failed: %s" },
{ "ER_BINLOG_LOGGING_IMPOSSIBLE", 1598, "Binary logging not possible. Message: %s" },
{ "ER_VIEW_NO_CREATION_CTX", 1599, "View %`s.%`s has no creation context" },
{ "ER_VIEW_INVALID_CREATION_CTX", 1600, "Creation context of view %`s.%`s is invalid" },
{ "ER_SR_INVALID_CREATION_CTX", 1601, "Creation context of stored routine %`s.%`s is invalid" },
{ "ER_TRG_CORRUPTED_FILE", 1602, "Corrupted TRG file for table %`s.%`s" },
{ "ER_TRG_NO_CREATION_CTX", 1603, "Triggers for table %`s.%`s have no creation context" },
{ "ER_TRG_INVALID_CREATION_CTX", 1604, "Trigger creation context of table %`s.%`s is invalid" },
{ "ER_EVENT_INVALID_CREATION_CTX", 1605, "Creation context of event %`s.%`s is invalid" },
{ "ER_TRG_CANT_OPEN_TABLE", 1606, "Cannot open table for trigger %`s.%`s" },
{ "ER_CANT_CREATE_SROUTINE", 1607, "Cannot create stored routine %`s. Check warnings" },
{ "ER_UNUSED_11", 1608, "You should never see it" },
{ "ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT", 1609, "The BINLOG statement of type %s was not preceded by a format description BINLOG statement" },
{ "ER_SLAVE_CORRUPT_EVENT", 1610, "Corrupted replication event was detected" },
{ "ER_LOAD_DATA_INVALID_COLUMN", 1611, "Invalid column reference (%-.64s) in LOAD DATA" },
{ "ER_LOG_PURGE_NO_FILE", 1612, "Being purged log %s was not found" },
{ "ER_XA_RBTIMEOUT", 1613, "XA_RBTIMEOUT: Transaction branch was rolled back: took too long" },
{ "ER_XA_RBDEADLOCK", 1614, "XA_RBDEADLOCK: Transaction branch was rolled back: deadlock was detected" },
{ "ER_NEED_REPREPARE", 1615, "Prepared statement needs to be re-prepared" },
{ "ER_DELAYED_NOT_SUPPORTED", 1616, "DELAYED option not supported for table \'%-.192s\'" },
{ "WARN_NO_MASTER_INFO", 1617, "There is no master connection \'%.*s\'" },
{ "WARN_OPTION_IGNORED", 1618, "<%-.64s> option ignored" },
{ "ER_PLUGIN_DELETE_BUILTIN", 1619, "Built-in plugins cannot be deleted" },
{ "WARN_PLUGIN_BUSY", 1620, "Plugin is busy and will be uninstalled on shutdown" },
{ "ER_VARIABLE_IS_READONLY", 1621, "%s variable \'%s\' is read-only. Use SET %s to assign the value" },
{ "ER_WARN_ENGINE_TRANSACTION_ROLLBACK", 1622, "Storage engine %s does not support rollback for this statement. Transaction rolled back and must be restarted" },
{ "ER_SLAVE_HEARTBEAT_FAILURE", 1623, "Unexpected master\'s heartbeat data: %s" },
{ "ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE", 1624, "The requested value for the heartbeat period is either negative or exceeds the maximum allowed (%u seconds)" },
{ "ER_UNUSED_14", 1625, "You should never see it" },
{ "ER_CONFLICT_FN_PARSE_ERROR", 1626, "Error in parsing conflict function. Message: %-.64s" },
{ "ER_EXCEPTIONS_WRITE_ERROR", 1627, "Write to exceptions table failed. Message: %-.128s\"" },
{ "ER_TOO_LONG_TABLE_COMMENT", 1628, "Comment for table \'%-.64s\' is too long (max = %u)" },
{ "ER_TOO_LONG_FIELD_COMMENT", 1629, "Comment for field \'%-.64s\' is too long (max = %u)" },
{ "ER_FUNC_INEXISTENT_NAME_COLLISION", 1630, "FUNCTION %s does not exist. Check the \'Function Name Parsing and Resolution\' section in the Reference Manual" },
{ "ER_DATABASE_NAME", 1631, "Database" },
{ "ER_TABLE_NAME", 1632, "Table" },
{ "ER_PARTITION_NAME", 1633, "Partition" },
{ "ER_SUBPARTITION_NAME", 1634, "Subpartition" },
{ "ER_TEMPORARY_NAME", 1635, "Temporary" },
{ "ER_RENAMED_NAME", 1636, "Renamed" },
{ "ER_TOO_MANY_CONCURRENT_TRXS", 1637, "Too many active concurrent transactions" },
{ "WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED", 1638, "Non-ASCII separator arguments are not fully supported" },
{ "ER_DEBUG_SYNC_TIMEOUT", 1639, "debug sync point wait timed out" },
{ "ER_DEBUG_SYNC_HIT_LIMIT", 1640, "debug sync point hit limit reached" },
{ "ER_DUP_SIGNAL_SET", 1641, "Duplicate condition information item \'%s\'" },
{ "ER_SIGNAL_WARN", 1642, "Unhandled user-defined warning condition" },
{ "ER_SIGNAL_NOT_FOUND", 1643, "Unhandled user-defined not found condition" },
{ "ER_SIGNAL_EXCEPTION", 1644, "Unhandled user-defined exception condition" },
{ "ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER", 1645, "RESIGNAL when handler not active" },
{ "ER_SIGNAL_BAD_CONDITION_TYPE", 1646, "SIGNAL/RESIGNAL can only use a CONDITION defined with SQLSTATE" },
{ "WARN_COND_ITEM_TRUNCATED", 1647, "Data truncated for condition item \'%s\'" },
{ "ER_COND_ITEM_TOO_LONG", 1648, "Data too long for condition item \'%s\'" },
{ "ER_UNKNOWN_LOCALE", 1649, "Unknown locale: \'%-.64s\'" },
{ "ER_SLAVE_IGNORE_SERVER_IDS", 1650, "The requested server id %d clashes with the slave startup option --replicate-same-server-id" },
{ "ER_QUERY_CACHE_DISABLED", 1651, "Query cache is disabled; set query_cache_type to ON or DEMAND to enable it" },
{ "ER_SAME_NAME_PARTITION_FIELD", 1652, "Duplicate partition field name \'%-.192s\'" },
{ "ER_PARTITION_COLUMN_LIST_ERROR", 1653, "Inconsistency in usage of column lists for partitioning" },
{ "ER_WRONG_TYPE_COLUMN_VALUE_ERROR", 1654, "Partition column values of incorrect type" },
{ "ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR", 1655, "Too many fields in \'%-.192s\'" },
{ "ER_MAXVALUE_IN_VALUES_IN", 1656, "Cannot use MAXVALUE as value in VALUES IN" },
{ "ER_TOO_MANY_VALUES_ERROR", 1657, "Cannot have more than one value for this type of %-.64s partitioning" },
{ "ER_ROW_SINGLE_PARTITION_FIELD_ERROR", 1658, "Row expressions in VALUES IN only allowed for multi-field column partitioning" },
{ "ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD", 1659, "Field \'%-.192s\' is of a not allowed type for this type of partitioning" },
{ "ER_PARTITION_FIELDS_TOO_LONG", 1660, "The total length of the partitioning fields is too large" },
{ "ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE", 1661, "Cannot execute statement: impossible to write to binary log since both row-incapable engines and statement-incapable engines are involved" },
{ "ER_BINLOG_ROW_MODE_AND_STMT_ENGINE", 1662, "Cannot execute statement: impossible to write to binary log since BINLOG_FORMAT = ROW and at least one table uses a storage engine limited to statement-based logging" },
{ "ER_BINLOG_UNSAFE_AND_STMT_ENGINE", 1663, "Cannot execute statement: impossible to write to binary log since statement is unsafe, storage engine is limited to statement-based logging, and BINLOG_FORMAT = MIXED. %s" },
{ "ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE", 1664, "Cannot execute statement: impossible to write to binary log since statement is in row format and at least one table uses a storage engine limited to statement-based logging" },
{ "ER_BINLOG_STMT_MODE_AND_ROW_ENGINE", 1665, "Cannot execute statement: impossible to write to binary log since BINLOG_FORMAT = STATEMENT and at least one table uses a storage engine limited to row-based logging.%s" },
{ "ER_BINLOG_ROW_INJECTION_AND_STMT_MODE", 1666, "Cannot execute statement: impossible to write to binary log since statement is in row format and BINLOG_FORMAT = STATEMENT" },
{ "ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE", 1667, "Cannot execute statement: impossible to write to binary log since more than one engine is involved and at least one engine is self-logging" },
{ "ER_BINLOG_UNSAFE_LIMIT", 1668, "The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted" },
{ "ER_BINLOG_UNSAFE_INSERT_DELAYED", 1669, "The statement is unsafe because it uses INSERT DELAYED. This is unsafe because the times when rows are inserted cannot be predicted" },
{ "ER_BINLOG_UNSAFE_SYSTEM_TABLE", 1670, "The statement is unsafe because it uses the general log, slow query log, or performance_schema table(s). This is unsafe because system tables may differ on slaves" },
{ "ER_BINLOG_UNSAFE_AUTOINC_COLUMNS", 1671, "Statement is unsafe because it invokes a trigger or a stored function that inserts into an AUTO_INCREMENT column. Inserted values cannot be logged correctly" },
{ "ER_BINLOG_UNSAFE_UDF", 1672, "Statement is unsafe because it uses a UDF which may not return the same value on the slave" },
{ "ER_BINLOG_UNSAFE_SYSTEM_VARIABLE", 1673, "Statement is unsafe because it uses a system variable that may have a different value on the slave" },
{ "ER_BINLOG_UNSAFE_SYSTEM_FUNCTION", 1674, "Statement is unsafe because it uses a system function that may return a different value on the slave" },
{ "ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS", 1675, "Statement is unsafe because it accesses a non-transactional table after accessing a transactional table within the same transaction" },
{ "ER_MESSAGE_AND_STATEMENT", 1676, "%s. Statement: %s" },
{ "ER_SLAVE_CONVERSION_FAILED", 1677, "Column %d of table \'%-.192s.%-.192s\' cannot be converted from type \'%-.50s\' to type \'%-.50s\'" },
{ "ER_SLAVE_CANT_CREATE_CONVERSION", 1678, "Can\'t create conversion table for table \'%-.192s.%-.192s\'" },
{ "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT", 1679, "Cannot modify @@session.binlog_format inside a transaction" },
{ "ER_PATH_LENGTH", 1680, "The path specified for %.64T is too long" },
{ "ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT", 1681, "\'%s\' is deprecated and will be removed in a future release" },
{ "ER_WRONG_NATIVE_TABLE_STRUCTURE", 1682, "Native table \'%-.64s\'.\'%-.64s\' has the wrong structure" },
{ "ER_WRONG_PERFSCHEMA_USAGE", 1683, "Invalid performance_schema usage" },
{ "ER_WARN_I_S_SKIPPED_TABLE", 1684, "Table \'%s\'.\'%s\' was skipped since its definition is being modified by concurrent DDL statement" },
{ "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT", 1685, "Cannot modify @@session.binlog_direct_non_transactional_updates inside a transaction" },
{ "ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT", 1686, "Cannot change the binlog direct flag inside a stored function or trigger" },
{ "ER_SPATIAL_MUST_HAVE_GEOM_COL", 1687, "A SPATIAL index may only contain a geometrical type column" },
{ "ER_TOO_LONG_INDEX_COMMENT", 1688, "Comment for index \'%-.64s\' is too long (max = %lu)" },
{ "ER_LOCK_ABORTED", 1689, "Wait on a lock was aborted due to a pending exclusive lock" },
{ "ER_DATA_OUT_OF_RANGE", 1690, "%s value is out of range in \'%s\'" },
{ "ER_WRONG_SPVAR_TYPE_IN_LIMIT", 1691, "A variable of a non-integer based type in LIMIT clause" },
{ "ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE", 1692, "Mixing self-logging and non-self-logging engines in a statement is unsafe" },
{ "ER_BINLOG_UNSAFE_MIXED_STATEMENT", 1693, "Statement accesses nontransactional table as well as transactional or temporary table, and writes to any of them" },
{ "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN", 1694, "Cannot modify @@session.sql_log_bin inside a transaction" },
{ "ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN", 1695, "Cannot change the sql_log_bin inside a stored function or trigger" },
{ "ER_FAILED_READ_FROM_PAR_FILE", 1696, "Failed to read from the .par file" },
{ "ER_VALUES_IS_NOT_INT_TYPE_ERROR", 1697, "VALUES value for partition \'%-.64s\' must have type INT" },
{ "ER_ACCESS_DENIED_NO_PASSWORD_ERROR", 1698, "Access denied for user \'%s\'@\'%s\'" },
{ "ER_SET_PASSWORD_AUTH_PLUGIN", 1699, "SET PASSWORD is not applicable for users authenticating via %s plugin" },
{ "ER_GRANT_PLUGIN_USER_EXISTS", 1700, "GRANT with IDENTIFIED WITH is illegal because the user %-.*s already exists" },
{ "ER_TRUNCATE_ILLEGAL_FK", 1701, "Cannot truncate a table referenced in a foreign key constraint (%.192s)" },
{ "ER_PLUGIN_IS_PERMANENT", 1702, "Plugin \'%s\' is force_plus_permanent and can not be unloaded" },
{ "ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN", 1703, "The requested value for the heartbeat period is less than 1 millisecond. The value is reset to 0, meaning that heartbeating will effectively be disabled" },
{ "ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX", 1704, "The requested value for the heartbeat period exceeds the value of `slave_net_timeout\' seconds. A sensible value for the period should be less than the timeout" },
{ "ER_STMT_CACHE_FULL", 1705, "Multi-row statements required more than \'max_binlog_stmt_cache_size\' bytes of storage." },
{ "ER_MULTI_UPDATE_KEY_CONFLICT", 1706, "Primary key/partition key update is not allowed since the table is updated both as \'%-.192s\' and \'%-.192s\'" },
{ "ER_TABLE_NEEDS_REBUILD", 1707, "Table rebuild required. Please do \"ALTER TABLE %`s FORCE\" or dump/reload to fix it!" },
{ "WARN_OPTION_BELOW_LIMIT", 1708, "The value of \'%s\' should be no less than the value of \'%s\'" },
{ "ER_INDEX_COLUMN_TOO_LONG", 1709, "Index column size too large. The maximum column size is %lu bytes" },
{ "ER_ERROR_IN_TRIGGER_BODY", 1710, "Trigger \'%-.64s\' has an error in its body: \'%-.256s\'" },
{ "ER_ERROR_IN_UNKNOWN_TRIGGER_BODY", 1711, "Unknown trigger has an error in its body: \'%-.256s\'" },
{ "ER_INDEX_CORRUPT", 1712, "Index %s is corrupted" },
{ "ER_UNDO_RECORD_TOO_BIG", 1713, "Undo log record is too big" },
{ "ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT", 1714, "INSERT IGNORE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are ignored. This order cannot be predicted and may differ on master and the slave" },
{ "ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE", 1715, "INSERT... SELECT... ON DUPLICATE KEY UPDATE is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are updated. This order cannot be predicted and may differ on master and the slave" },
{ "ER_BINLOG_UNSAFE_REPLACE_SELECT", 1716, "REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave" },
{ "ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT", 1717, "CREATE... IGNORE SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are ignored. This order cannot be predicted and may differ on master and the slave" },
{ "ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT", 1718, "CREATE... REPLACE SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave" },
{ "ER_BINLOG_UNSAFE_UPDATE_IGNORE", 1719, "UPDATE IGNORE is unsafe because the order in which rows are updated determines which (if any) rows are ignored. This order cannot be predicted and may differ on master and the slave" },
{ "ER_UNUSED_15", 1720, "You should never see it" },
{ "ER_UNUSED_16", 1721, "You should never see it" },
{ "ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT", 1722, "Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on master and the slave" },
{ "ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC", 1723, "CREATE TABLE... SELECT... on a table with an auto-increment column is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are inserted. This order cannot be predicted and may differ on master and the slave" },
{ "ER_BINLOG_UNSAFE_INSERT_TWO_KEYS", 1724, "INSERT... ON DUPLICATE KEY UPDATE on a table with more than one UNIQUE KEY is unsafe" },
{ "ER_UNUSED_28", 1725, "You should never see it" },
{ "ER_VERS_NOT_ALLOWED", 1726, "Not allowed for system-versioned table %`s.%`s" },
{ "ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST", 1727, "INSERT into autoincrement field which is not the first part in the composed primary key is unsafe" },
{ "ER_CANNOT_LOAD_FROM_TABLE_V2", 1728, "Cannot load from %s.%s. The table is probably corrupted" },
{ "ER_MASTER_DELAY_VALUE_OUT_OF_RANGE", 1729, "The requested value %lu for the master delay exceeds the maximum %lu" },
{ "ER_ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT", 1730, "Only Format_description_log_event and row events are allowed in BINLOG statements (but %s was provided)" },
{ "ER_PARTITION_EXCHANGE_DIFFERENT_OPTION", 1731, "Non matching attribute \'%-.64s\' between partition and table" },
{ "ER_PARTITION_EXCHANGE_PART_TABLE", 1732, "Table to exchange with partition is partitioned: \'%-.64s\'" },
{ "ER_PARTITION_EXCHANGE_TEMP_TABLE", 1733, "Table to exchange with partition is temporary: \'%-.64s\'" },
{ "ER_PARTITION_INSTEAD_OF_SUBPARTITION", 1734, "Subpartitioned table, use subpartition instead of partition" },
{ "ER_UNKNOWN_PARTITION", 1735, "Unknown partition \'%-.64s\' in table \'%-.64s\'" },
{ "ER_TABLES_DIFFERENT_METADATA", 1736, "Tables have different definitions" },
{ "ER_ROW_DOES_NOT_MATCH_PARTITION", 1737, "Found a row that does not match the partition" },
{ "ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX", 1738, "Option binlog_cache_size (%lu) is greater than max_binlog_cache_size (%lu); setting binlog_cache_size equal to max_binlog_cache_size" },
{ "ER_WARN_INDEX_NOT_APPLICABLE", 1739, "Cannot use %-.64s access on index \'%-.64s\' due to type or collation conversion on field \'%-.64s\'" },
{ "ER_PARTITION_EXCHANGE_FOREIGN_KEY", 1740, "Table to exchange with partition has foreign key references: \'%-.64s\'" },
{ "ER_NO_SUCH_KEY_VALUE", 1741, "Key value \'%-.192s\' was not found in table \'%-.192s.%-.192s\'" },
{ "ER_VALUE_TOO_LONG", 1742, "Too long value for \'%s\'" },
{ "ER_NETWORK_READ_EVENT_CHECKSUM_FAILURE", 1743, "Replication event checksum verification failed while reading from network" },
{ "ER_BINLOG_READ_EVENT_CHECKSUM_FAILURE", 1744, "Replication event checksum verification failed while reading from a log file" },
{ "ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX", 1745, "Option binlog_stmt_cache_size (%lu) is greater than max_binlog_stmt_cache_size (%lu); setting binlog_stmt_cache_size equal to max_binlog_stmt_cache_size" },
{ "ER_CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT", 1746, "Can\'t update table \'%-.192s\' while \'%-.192s\' is being created" },
{ "ER_PARTITION_CLAUSE_ON_NONPARTITIONED", 1747, "PARTITION () clause on non partitioned table" },
{ "ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET", 1748, "Found a row not matching the given partition set" },
{ "ER_UNUSED_5", 1749, "You should never see it" },
{ "ER_CHANGE_RPL_INFO_REPOSITORY_FAILURE", 1750, "Failure while changing the type of replication repository: %s" },
{ "ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE", 1751, "The creation of some temporary tables could not be rolled back" },
{ "ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE", 1752, "Some temporary tables were dropped, but these operations could not be rolled back" },
{ "ER_MTS_FEATURE_IS_NOT_SUPPORTED", 1753, "%s is not supported in multi-threaded slave mode. %s" },
{ "ER_MTS_UPDATED_DBS_GREATER_MAX", 1754, "The number of modified databases exceeds the maximum %d; the database names will not be included in the replication event metadata" },
{ "ER_MTS_CANT_PARALLEL", 1755, "Cannot execute the current event group in the parallel mode. Encountered event %s, relay-log name %s, position %s which prevents execution of this event group in parallel mode. Reason: %s" },
{ "ER_MTS_INCONSISTENT_DATA", 1756, "%s" },
{ "ER_FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING", 1757, "FULLTEXT index is not supported for partitioned tables" },
{ "ER_DA_INVALID_CONDITION_NUMBER", 1758, "Invalid condition number" },
{ "ER_INSECURE_PLAIN_TEXT", 1759, "Sending passwords in plain text without SSL/TLS is extremely insecure" },
{ "ER_INSECURE_CHANGE_MASTER", 1760, "Storing MariaDB user name or password information in the master.info repository is not secure and is therefore not recommended. Please see the MariaDB Manual for more about this issue and possible alternatives" },
{ "ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO", 1761, "Foreign key constraint for table \'%.192s\', record \'%-.192s\' would lead to a duplicate entry in table \'%.192s\', key \'%.192s\'" },
{ "ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO", 1762, "Foreign key constraint for table \'%.192s\', record \'%-.192s\' would lead to a duplicate entry in a child table" },
{ "ER_SQLTHREAD_WITH_SECURE_SLAVE", 1763, "Setting authentication options is not possible when only the Slave SQL Thread is being started" },
{ "ER_TABLE_HAS_NO_FT", 1764, "The table does not have FULLTEXT index to support this query" },
{ "ER_VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER", 1765, "The system variable %.200s cannot be set in stored functions or triggers" },
{ "ER_VARIABLE_NOT_SETTABLE_IN_TRANSACTION", 1766, "The system variable %.200s cannot be set when there is an ongoing transaction" },
{ "ER_GTID_NEXT_IS_NOT_IN_GTID_NEXT_LIST", 1767, "The system variable @@SESSION.GTID_NEXT has the value %.200s, which is not listed in @@SESSION.GTID_NEXT_LIST" },
{ "ER_CANT_CHANGE_GTID_NEXT_IN_TRANSACTION_WHEN_GTID_NEXT_LIST_IS_NULL", 1768, "When @@SESSION.GTID_NEXT_LIST == NULL, the system variable @@SESSION.GTID_NEXT cannot change inside a transaction" },
{ "ER_SET_STATEMENT_CANNOT_INVOKE_FUNCTION", 1769, "The statement \'SET %.200s\' cannot invoke a stored function" },
{ "ER_GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL", 1770, "The system variable @@SESSION.GTID_NEXT cannot be \'AUTOMATIC\' when @@SESSION.GTID_NEXT_LIST is non-NULL" },
{ "ER_SKIPPING_LOGGED_TRANSACTION", 1771, "Skipping transaction %.200s because it has already been executed and logged" },
{ "ER_MALFORMED_GTID_SET_SPECIFICATION", 1772, "Malformed GTID set specification \'%.200s\'" },
{ "ER_MALFORMED_GTID_SET_ENCODING", 1773, "Malformed GTID set encoding" },
{ "ER_MALFORMED_GTID_SPECIFICATION", 1774, "Malformed GTID specification \'%.200s\'" },
{ "ER_GNO_EXHAUSTED", 1775, "Impossible to generate Global Transaction Identifier: the integer component reached the maximal value. Restart the server with a new server_uuid" },
{ "ER_BAD_SLAVE_AUTO_POSITION", 1776, "Parameters MASTER_LOG_FILE, MASTER_LOG_POS, RELAY_LOG_FILE and RELAY_LOG_POS cannot be set when MASTER_AUTO_POSITION is active" },
{ "ER_AUTO_POSITION_REQUIRES_GTID_MODE_ON", 1777, "CHANGE MASTER TO MASTER_AUTO_POSITION = 1 can only be executed when GTID_MODE = ON" },
{ "ER_CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET", 1778, "Cannot execute statements with implicit commit inside a transaction when GTID_NEXT != AUTOMATIC or GTID_NEXT_LIST != NULL" },
{ "ER_GTID_MODE_2_OR_3_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON", 1779, "GTID_MODE = ON or GTID_MODE = UPGRADE_STEP_2 requires ENFORCE_GTID_CONSISTENCY = 1" },
{ "ER_GTID_MODE_REQUIRES_BINLOG", 1780, "GTID_MODE = ON or UPGRADE_STEP_1 or UPGRADE_STEP_2 requires --log-bin and --log-slave-updates" },
{ "ER_CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF", 1781, "GTID_NEXT cannot be set to UUID:NUMBER when GTID_MODE = OFF" },
{ "ER_CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON", 1782, "GTID_NEXT cannot be set to ANONYMOUS when GTID_MODE = ON" },
{ "ER_CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF", 1783, "GTID_NEXT_LIST cannot be set to a non-NULL value when GTID_MODE = OFF" },
{ "ER_FOUND_GTID_EVENT_WHEN_GTID_MODE_IS_OFF", 1784, "Found a Gtid_log_event or Previous_gtids_log_event when GTID_MODE = OFF" },
{ "ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE", 1785, "When ENFORCE_GTID_CONSISTENCY = 1, updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables" },
{ "ER_GTID_UNSAFE_CREATE_SELECT", 1786, "CREATE TABLE ... SELECT is forbidden when ENFORCE_GTID_CONSISTENCY = 1" },
{ "ER_GTID_UNSAFE_CREATE_DROP_TEMPORARY_TABLE_IN_TRANSACTION", 1787, "When ENFORCE_GTID_CONSISTENCY = 1, the statements CREATE TEMPORARY TABLE and DROP TEMPORARY TABLE can be executed in a non-transactional context only, and require that AUTOCOMMIT = 1" },
{ "ER_GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME", 1788, "The value of GTID_MODE can only change one step at a time: OFF <-> UPGRADE_STEP_1 <-> UPGRADE_STEP_2 <-> ON. Also note that this value must be stepped up or down simultaneously on all servers; see the Manual for instructions." },
{ "ER_MASTER_HAS_PURGED_REQUIRED_GTIDS", 1789, "The slave is connecting using CHANGE MASTER TO MASTER_AUTO_POSITION = 1, but the master has purged binary logs containing GTIDs that the slave requires" },
{ "ER_CANT_SET_GTID_NEXT_WHEN_OWNING_GTID", 1790, "GTID_NEXT cannot be changed by a client that owns a GTID. The client owns %s. Ownership is released on COMMIT or ROLLBACK" },
{ "ER_UNKNOWN_EXPLAIN_FORMAT", 1791, "Unknown %s format name: \'%s\'" },
{ "ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION", 1792, "Cannot execute statement in a READ ONLY transaction" },
{ "ER_TOO_LONG_TABLE_PARTITION_COMMENT", 1793, "Comment for table partition \'%-.64s\' is too long (max = %lu)" },
{ "ER_SLAVE_CONFIGURATION", 1794, "Slave is not configured or failed to initialize properly. You must at least set --server-id to enable either a master or a slave. Additional error messages can be found in the MariaDB error log" },
{ "ER_INNODB_FT_LIMIT", 1795, "InnoDB presently supports one FULLTEXT index creation at a time" },
{ "ER_INNODB_NO_FT_TEMP_TABLE", 1796, "Cannot create FULLTEXT index on temporary InnoDB table" },
{ "ER_INNODB_FT_WRONG_DOCID_COLUMN", 1797, "Column \'%-.192s\' is of wrong type for an InnoDB FULLTEXT index" },
{ "ER_INNODB_FT_WRONG_DOCID_INDEX", 1798, "Index \'%-.192s\' is of wrong type for an InnoDB FULLTEXT index" },
{ "ER_INNODB_ONLINE_LOG_TOO_BIG", 1799, "Creating index \'%-.192s\' required more than \'innodb_online_alter_log_max_size\' bytes of modification log. Please try again" },
{ "ER_UNKNOWN_ALTER_ALGORITHM", 1800, "Unknown ALGORITHM \'%s\'" },
{ "ER_UNKNOWN_ALTER_LOCK", 1801, "Unknown LOCK type \'%s\'" },
{ "ER_MTS_CHANGE_MASTER_CANT_RUN_WITH_GAPS", 1802, "CHANGE MASTER cannot be executed when the slave was stopped with an error or killed in MTS mode. Consider using RESET SLAVE or START SLAVE UNTIL" },
{ "ER_MTS_RECOVERY_FAILURE", 1803, "Cannot recover after SLAVE errored out in parallel execution mode. Additional error messages can be found in the MariaDB error log" },
{ "ER_MTS_RESET_WORKERS", 1804, "Cannot clean up worker info tables. Additional error messages can be found in the MariaDB error log" },
{ "ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2", 1805, "Column count of %s.%s is wrong. Expected %d, found %d. The table is probably corrupted" },
{ "ER_SLAVE_SILENT_RETRY_TRANSACTION", 1806, "Slave must silently retry current transaction" },
{ "ER_UNUSED_22", 1807, "You should never see it" },
{ "ER_TABLE_SCHEMA_MISMATCH", 1808, "Schema mismatch (%s)" },
{ "ER_TABLE_IN_SYSTEM_TABLESPACE", 1809, "Table %-.192s in system tablespace" },
{ "ER_IO_READ_ERROR", 1810, "IO Read error: (%lu, %s) %s" },
{ "ER_IO_WRITE_ERROR", 1811, "IO Write error: (%lu, %s) %s" },
{ "ER_TABLESPACE_MISSING", 1812, "Tablespace is missing for table \'%-.192s\'" },
{ "ER_TABLESPACE_EXISTS", 1813, "Tablespace for table \'%-.192s\' exists. Please DISCARD the tablespace before IMPORT" },
{ "ER_TABLESPACE_DISCARDED", 1814, "Tablespace has been discarded for table %`s" },
{ "ER_INTERNAL_ERROR", 1815, "Internal error: %-.192s" },
{ "ER_INNODB_IMPORT_ERROR", 1816, "ALTER TABLE \'%-.192s\' IMPORT TABLESPACE failed with error %lu : \'%s\'" },
{ "ER_INNODB_INDEX_CORRUPT", 1817, "Index corrupt: %s" },
{ "ER_INVALID_YEAR_COLUMN_LENGTH", 1818, "YEAR(%lu) column type is deprecated. Creating YEAR(4) column instead" },
{ "ER_NOT_VALID_PASSWORD", 1819, "Your password does not satisfy the current policy requirements (%s)" },
{ "ER_MUST_CHANGE_PASSWORD", 1820, "You must SET PASSWORD before executing this statement" },
{ "ER_FK_NO_INDEX_CHILD", 1821, "Failed to add the foreign key constraint. Missing index for constraint \'%s\' in the foreign table \'%s\'" },
{ "ER_FK_NO_INDEX_PARENT", 1822, "Failed to add the foreign key constraint. Missing index for constraint \'%s\' in the referenced table \'%s\'" },
{ "ER_FK_FAIL_ADD_SYSTEM", 1823, "Failed to add the foreign key constraint \'%s\' to system tables" },
{ "ER_FK_CANNOT_OPEN_PARENT", 1824, "Failed to open the referenced table \'%s\'" },
{ "ER_FK_INCORRECT_OPTION", 1825, "Failed to add the foreign key constraint on table \'%s\'. Incorrect options in FOREIGN KEY constraint \'%s\'" },
{ "ER_DUP_CONSTRAINT_NAME", 1826, "Duplicate %s constraint name \'%s\'" },
{ "ER_PASSWORD_FORMAT", 1827, "The password hash doesn\'t have the expected format. Check if the correct password algorithm is being used with the PASSWORD() function" },
{ "ER_FK_COLUMN_CANNOT_DROP", 1828, "Cannot drop column \'%-.192s\': needed in a foreign key constraint \'%-.192s\'" },
{ "ER_FK_COLUMN_CANNOT_DROP_CHILD", 1829, "Cannot drop column \'%-.192s\': needed in a foreign key constraint \'%-.192s\' of table %-.192s" },
{ "ER_FK_COLUMN_NOT_NULL", 1830, "Column \'%-.192s\' cannot be NOT NULL: needed in a foreign key constraint \'%-.192s\' SET NULL" },
{ "ER_DUP_INDEX", 1831, "Duplicate index %`s. This is deprecated and will be disallowed in a future release" },
{ "ER_FK_COLUMN_CANNOT_CHANGE", 1832, "Cannot change column \'%-.192s\': used in a foreign key constraint \'%-.192s\'" },
{ "ER_FK_COLUMN_CANNOT_CHANGE_CHILD", 1833, "Cannot change column \'%-.192s\': used in a foreign key constraint \'%-.192s\' of table \'%-.192s\'" },
{ "ER_FK_CANNOT_DELETE_PARENT", 1834, "Cannot delete rows from table which is parent in a foreign key constraint \'%-.192s\' of table \'%-.192s\'" },
{ "ER_MALFORMED_PACKET", 1835, "Malformed communication packet" },
{ "ER_READ_ONLY_MODE", 1836, "Running in read-only mode" },
{ "ER_GTID_NEXT_TYPE_UNDEFINED_GROUP", 1837, "When GTID_NEXT is set to a GTID, you must explicitly set it again after a COMMIT or ROLLBACK. If you see this error message in the slave SQL thread, it means that a table in the current transaction is transactional on the master and non-transactional on the slave. In a client connection, it means that you executed SET GTID_NEXT before a transaction and forgot to set GTID_NEXT to a different identifier or to \'AUTOMATIC\' after COMMIT or ROLLBACK. Current GTID_NEXT is \'%s\'" },
{ "ER_VARIABLE_NOT_SETTABLE_IN_SP", 1838, "The system variable %.200s cannot be set in stored procedures" },
{ "ER_CANT_SET_GTID_PURGED_WHEN_GTID_MODE_IS_OFF", 1839, "GTID_PURGED can only be set when GTID_MODE = ON" },
{ "ER_CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY", 1840, "GTID_PURGED can only be set when GTID_EXECUTED is empty" },
{ "ER_CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY", 1841, "GTID_PURGED can only be set when there are no ongoing transactions (not even in other clients)" },
{ "ER_GTID_PURGED_WAS_CHANGED", 1842, "GTID_PURGED was changed from \'%s\' to \'%s\'" },
{ "ER_GTID_EXECUTED_WAS_CHANGED", 1843, "GTID_EXECUTED was changed from \'%s\' to \'%s\'" },
{ "ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES", 1844, "Cannot execute statement: impossible to write to binary log since BINLOG_FORMAT = STATEMENT, and both replicated and non replicated tables are written to" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED", 1845, "%s is not supported for this operation. Try %s" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON", 1846, "%s is not supported. Reason: %s. Try %s" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY", 1847, "COPY algorithm requires a lock" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION", 1848, "Partition specific operations do not yet support LOCK/ALGORITHM" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME", 1849, "Columns participating in a foreign key are renamed" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE", 1850, "Cannot change column type" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK", 1851, "Adding foreign keys needs foreign_key_checks=OFF" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_IGNORE", 1852, "Creating unique indexes with IGNORE requires COPY algorithm to remove duplicate rows" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK", 1853, "Dropping a primary key is not allowed without also adding a new primary key" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC", 1854, "Adding an auto-increment column requires a lock" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS", 1855, "Cannot replace hidden FTS_DOC_ID with a user-visible one" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS", 1856, "Cannot drop or rename FTS_DOC_ID" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS", 1857, "Fulltext index creation requires a lock" },
{ "ER_SQL_SLAVE_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE", 1858, "sql_slave_skip_counter can not be set when the server is running with GTID_MODE = ON. Instead, for each transaction that you want to skip, generate an empty transaction with the same GTID as the transaction" },
{ "ER_DUP_UNKNOWN_IN_INDEX", 1859, "Duplicate entry for key \'%-.192s\'" },
{ "ER_IDENT_CAUSES_TOO_LONG_PATH", 1860, "Long database name and identifier for object resulted in path length exceeding %d characters. Path: \'%s\'" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL", 1861, "cannot convert NULL to non-constant DEFAULT" },
{ "ER_MUST_CHANGE_PASSWORD_LOGIN", 1862, "Your password has expired. To log in you must change it using a client that supports expired passwords" },
{ "ER_ROW_IN_WRONG_PARTITION", 1863, "Found a row in wrong partition %s" },
{ "ER_MTS_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX", 1864, "Cannot schedule event %s, relay-log name %s, position %s to Worker thread because its size %lu exceeds %lu of slave_pending_jobs_size_max" },
{ "ER_INNODB_NO_FT_USES_PARSER", 1865, "Cannot CREATE FULLTEXT INDEX WITH PARSER on InnoDB table" },
{ "ER_BINLOG_LOGICAL_CORRUPTION", 1866, "The binary log file \'%s\' is logically corrupted: %s" },
{ "ER_WARN_PURGE_LOG_IN_USE", 1867, "file %s was not purged because it was being read by %d thread(s), purged only %d out of %d files" },
{ "ER_WARN_PURGE_LOG_IS_ACTIVE", 1868, "file %s was not purged because it is the active log file" },
{ "ER_AUTO_INCREMENT_CONFLICT", 1869, "Auto-increment value in UPDATE conflicts with internally generated values" },
{ "WARN_ON_BLOCKHOLE_IN_RBR", 1870, "Row events are not logged for %s statements that modify BLACKHOLE tables in row format. Table(s): \'%-.192s\'" },
{ "ER_SLAVE_MI_INIT_REPOSITORY", 1871, "Slave failed to initialize master info structure from the repository" },
{ "ER_SLAVE_RLI_INIT_REPOSITORY", 1872, "Slave failed to initialize relay log info structure from the repository" },
{ "ER_ACCESS_DENIED_CHANGE_USER_ERROR", 1873, "Access denied trying to change to user \'%-.48s\'@\'%-.64s\' (using password: %s). Disconnecting" },
{ "ER_INNODB_READ_ONLY", 1874, "InnoDB is in read only mode" },
{ "ER_STOP_SLAVE_SQL_THREAD_TIMEOUT", 1875, "STOP SLAVE command execution is incomplete: Slave SQL thread got the stop signal, thread is busy, SQL thread will stop once the current task is complete" },
{ "ER_STOP_SLAVE_IO_THREAD_TIMEOUT", 1876, "STOP SLAVE command execution is incomplete: Slave IO thread got the stop signal, thread is busy, IO thread will stop once the current task is complete" },
{ "ER_TABLE_CORRUPT", 1877, "Operation cannot be performed. The table \'%-.64s.%-.64s\' is missing, corrupt or contains bad data" },
{ "ER_TEMP_FILE_WRITE_FAILURE", 1878, "Temporary file write failure" },
{ "ER_INNODB_FT_AUX_NOT_HEX_ID", 1879, "Upgrade index name failed, please use create index(alter table) algorithm copy to rebuild index" },
{ "ER_LAST_MYSQL_ERROR_MESSAGE", 1880, "\"" },
{ "ER_UNUSED_18", 1900, "You should never see it" },
{ "ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED", 1901, "Function or expression \'%s\' cannot be used in the %s clause of %`s" },
{ "ER_UNUSED_19", 1902, "You should never see it" },
{ "ER_PRIMARY_KEY_BASED_ON_GENERATED_COLUMN", 1903, "Primary key cannot be defined upon a generated column" },
{ "ER_KEY_BASED_ON_GENERATED_VIRTUAL_COLUMN", 1904, "Key/Index cannot be defined on a virtual generated column" },
{ "ER_WRONG_FK_OPTION_FOR_GENERATED_COLUMN", 1905, "Cannot define foreign key with %s clause on a generated column" },
{ "ER_WARNING_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN", 1906, "The value specified for generated column \'%s\' in table \'%s\' has been ignored" },
{ "ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN", 1907, "This is not yet supported for generated columns" },
{ "ER_UNUSED_20", 1908, "You should never see it" },
{ "ER_UNUSED_21", 1909, "You should never see it" },
{ "ER_UNSUPPORTED_ENGINE_FOR_GENERATED_COLUMNS", 1910, "%s storage engine does not support generated columns" },
{ "ER_UNKNOWN_OPTION", 1911, "Unknown option \'%-.64s\'" },
{ "ER_BAD_OPTION_VALUE", 1912, "Incorrect value \'%-.64T\' for option \'%-.64s\'" },
{ "ER_UNUSED_6", 1913, "You should never see it" },
{ "ER_UNUSED_7", 1914, "You should never see it" },
{ "ER_UNUSED_8", 1915, "You should never see it" },
{ "ER_DATA_OVERFLOW", 1916, "Got overflow when converting \'%-.128s\' to %-.32s. Value truncated" },
{ "ER_DATA_TRUNCATED", 1917, "Truncated value \'%-.128s\' when converting to %-.32s" },
{ "ER_BAD_DATA", 1918, "Encountered illegal value \'%-.128s\' when converting to %-.32s" },
{ "ER_DYN_COL_WRONG_FORMAT", 1919, "Encountered illegal format of dynamic column string" },
{ "ER_DYN_COL_IMPLEMENTATION_LIMIT", 1920, "Dynamic column implementation limit reached" },
{ "ER_DYN_COL_DATA", 1921, "Illegal value used as argument of dynamic column function" },
{ "ER_DYN_COL_WRONG_CHARSET", 1922, "Dynamic column contains unknown character set" },
{ "ER_ILLEGAL_SUBQUERY_OPTIMIZER_SWITCHES", 1923, "At least one of the \'in_to_exists\' or \'materialization\' optimizer_switch flags must be \'on\'" },
{ "ER_QUERY_CACHE_IS_DISABLED", 1924, "Query cache is disabled (resize or similar command in progress); repeat this command later" },
{ "ER_QUERY_CACHE_IS_GLOBALY_DISABLED", 1925, "Query cache is globally disabled and you can\'t enable it only for this session" },
{ "ER_VIEW_ORDERBY_IGNORED", 1926, "View \'%-.192s\'.\'%-.192s\' ORDER BY clause ignored because there is other ORDER BY clause already" },
{ "ER_CONNECTION_KILLED", 1927, "Connection was killed" },
{ "ER_UNUSED_12", 1928, "You should never see it" },
{ "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SKIP_REPLICATION", 1929, "Cannot modify @@session.skip_replication inside a transaction" },
{ "ER_STORED_FUNCTION_PREVENTS_SWITCH_SKIP_REPLICATION", 1930, "Cannot modify @@session.skip_replication inside a stored function or trigger" },
{ "ER_QUERY_RESULT_INCOMPLETE", 1931, "Query execution was interrupted. The query exceeded %s %llu. The query result may be incomplete" },
{ "ER_NO_SUCH_TABLE_IN_ENGINE", 1932, "Table \'%-.192s.%-.192s\' doesn\'t exist in engine" },
{ "ER_TARGET_NOT_EXPLAINABLE", 1933, "Target is not executing an operation with a query plan" },
{ "ER_CONNECTION_ALREADY_EXISTS", 1934, "Connection \'%.*s\' conflicts with existing connection \'%.*s\'" },
{ "ER_MASTER_LOG_PREFIX", 1935, "Master \'%.*s\': " },
{ "ER_CANT_START_STOP_SLAVE", 1936, "Can\'t %s SLAVE \'%.*s\'" },
{ "ER_SLAVE_STARTED", 1937, "SLAVE \'%.*s\' started" },
{ "ER_SLAVE_STOPPED", 1938, "SLAVE \'%.*s\' stopped" },
{ "ER_SQL_DISCOVER_ERROR", 1939, "Engine %s failed to discover table %`-.192s.%`-.192s with \'%s\'" },
{ "ER_FAILED_GTID_STATE_INIT", 1940, "Failed initializing replication GTID state" },
{ "ER_INCORRECT_GTID_STATE", 1941, "Could not parse GTID list" },
{ "ER_CANNOT_UPDATE_GTID_STATE", 1942, "Could not update replication slave gtid state" },
{ "ER_DUPLICATE_GTID_DOMAIN", 1943, "GTID %u-%u-%llu and %u-%u-%llu conflict (duplicate domain id %u)" },
{ "ER_GTID_OPEN_TABLE_FAILED", 1944, "Failed to open %s.%s" },
{ "ER_GTID_POSITION_NOT_FOUND_IN_BINLOG", 1945, "Connecting slave requested to start from GTID %u-%u-%llu, which is not in the master\'s binlog" },
{ "ER_CANNOT_LOAD_SLAVE_GTID_STATE", 1946, "Failed to load replication slave GTID position from table %s.%s" },
{ "ER_MASTER_GTID_POS_CONFLICTS_WITH_BINLOG", 1947, "Specified GTID %u-%u-%llu conflicts with the binary log which contains a more recent GTID %u-%u-%llu. If MASTER_GTID_POS=CURRENT_POS is used, the binlog position will override the new value of @@gtid_slave_pos" },
{ "ER_MASTER_GTID_POS_MISSING_DOMAIN", 1948, "Specified value for @@gtid_slave_pos contains no value for replication domain %u. This conflicts with the binary log which contains GTID %u-%u-%llu. If MASTER_GTID_POS=CURRENT_POS is used, the binlog position will override the new value of @@gtid_slave_pos" },
{ "ER_UNTIL_REQUIRES_USING_GTID", 1949, "START SLAVE UNTIL master_gtid_pos requires that slave is using GTID" },
{ "ER_GTID_STRICT_OUT_OF_ORDER", 1950, "An attempt was made to binlog GTID %u-%u-%llu which would create an out-of-order sequence number with existing GTID %u-%u-%llu, and gtid strict mode is enabled" },
{ "ER_GTID_START_FROM_BINLOG_HOLE", 1951, "The binlog on the master is missing the GTID %u-%u-%llu requested by the slave (even though a subsequent sequence number does exist), and GTID strict mode is enabled" },
{ "ER_SLAVE_UNEXPECTED_MASTER_SWITCH", 1952, "Unexpected GTID received from master after reconnect. This normally indicates that the master server was replaced without restarting the slave threads. %s" },
{ "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_GTID_DOMAIN_ID_SEQ_NO", 1953, "Cannot modify @@session.gtid_domain_id or @@session.gtid_seq_no inside a transaction" },
{ "ER_STORED_FUNCTION_PREVENTS_SWITCH_GTID_DOMAIN_ID_SEQ_NO", 1954, "Cannot modify @@session.gtid_domain_id or @@session.gtid_seq_no inside a stored function or trigger" },
{ "ER_GTID_POSITION_NOT_FOUND_IN_BINLOG2", 1955, "Connecting slave requested to start from GTID %u-%u-%llu, which is not in the master\'s binlog. Since the master\'s binlog contains GTIDs with higher sequence numbers, it probably means that the slave has diverged due to executing extra erroneous transactions" },
{ "ER_BINLOG_MUST_BE_EMPTY", 1956, "This operation is not allowed if any GTID has been logged to the binary log. Run RESET MASTER first to erase the log" },
{ "ER_NO_SUCH_QUERY", 1957, "Unknown query id: %lld" },
{ "ER_BAD_BASE64_DATA", 1958, "Bad base64 data as position %u" },
{ "ER_INVALID_ROLE", 1959, "Invalid role specification %`s" },
{ "ER_INVALID_CURRENT_USER", 1960, "The current user is invalid" },
{ "ER_CANNOT_GRANT_ROLE", 1961, "Cannot grant role \'%s\' to: %s" },
{ "ER_CANNOT_REVOKE_ROLE", 1962, "Cannot revoke role \'%s\' from: %s" },
{ "ER_CHANGE_SLAVE_PARALLEL_THREADS_ACTIVE", 1963, "Cannot change @@slave_parallel_threads while another change is in progress" },
{ "ER_PRIOR_COMMIT_FAILED", 1964, "Commit failed due to failure of an earlier commit on which this one depends" },
{ "ER_IT_IS_A_VIEW", 1965, "\'%-.192s\' is a view" },
{ "ER_SLAVE_SKIP_NOT_IN_GTID", 1966, "When using parallel replication and GTID with multiple replication domains, @@sql_slave_skip_counter can not be used. Instead, setting @@gtid_slave_pos explicitly can be used to skip to after a given GTID position" },
{ "ER_TABLE_DEFINITION_TOO_BIG", 1967, "The definition for table %`s is too big" },
{ "ER_PLUGIN_INSTALLED", 1968, "Plugin \'%-.192s\' already installed" },
{ "ER_STATEMENT_TIMEOUT", 1969, "Query execution was interrupted (max_statement_time exceeded)" },
{ "ER_SUBQUERIES_NOT_SUPPORTED", 1970, "%s does not support subqueries or stored functions" },
{ "ER_SET_STATEMENT_NOT_SUPPORTED", 1971, "The system variable %.200s cannot be set in SET STATEMENT." },
{ "ER_UNUSED_9", 1972, "You should never see it" },
{ "ER_USER_CREATE_EXISTS", 1973, "Can\'t create user \'%-.64s\'@\'%-.64s\'; it already exists" },
{ "ER_USER_DROP_EXISTS", 1974, "Can\'t drop user \'%-.64s\'@\'%-.64s\'; it doesn\'t exist" },
{ "ER_ROLE_CREATE_EXISTS", 1975, "Can\'t create role \'%-.64s\'; it already exists" },
{ "ER_ROLE_DROP_EXISTS", 1976, "Can\'t drop role \'%-.64s\'; it doesn\'t exist" },
{ "ER_CANNOT_CONVERT_CHARACTER", 1977, "Cannot convert \'%s\' character 0x%-.64s to \'%s\'" },
{ "ER_INVALID_DEFAULT_VALUE_FOR_FIELD", 1978, "Incorrect default value \'%-.128T\' for column \'%.192s\'" },
{ "ER_KILL_QUERY_DENIED_ERROR", 1979, "You are not owner of query %lld" },
{ "ER_NO_EIS_FOR_FIELD", 1980, "Engine-independent statistics are not collected for column \'%s\'" },
{ "ER_WARN_AGGFUNC_DEPENDENCE", 1981, "Aggregate function \'%-.192s)\' of SELECT #%d belongs to SELECT #%d" },
{ "WARN_INNODB_PARTITION_OPTION_IGNORED", 1982, "<%-.64s> option ignored for InnoDB partition" },
{ "ER_FILE_CORRUPT", 3000, "File %s is corrupted" },
{ "ER_ERROR_ON_MASTER", 3001, "Query partially completed on the master (error on master: %d) and was aborted. There is a chance that your master is inconsistent at this point. If you are sure that your master is ok, run this query manually on the slave and then restart the slave with SET GLOBAL SQL_SLAVE_SKIP_COUNTER=1; START SLAVE;. Query:\'%s\'" },
{ "ER_INCONSISTENT_ERROR", 3002, "Query caused different errors on master and slave. Error on master: message (format)=\'%s\' error code=%d; Error on slave:actual message=\'%s\', error code=%d. Default database:\'%s\'. Query:\'%s\'" },
{ "ER_STORAGE_ENGINE_NOT_LOADED", 3003, "Storage engine for table \'%s\'.\'%s\' is not loaded." },
{ "ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER", 3004, "GET STACKED DIAGNOSTICS when handler not active" },
{ "ER_WARN_LEGACY_SYNTAX_CONVERTED", 3005, "%s is no longer supported. The statement was converted to %s." },
{ "ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN", 3006, "Statement is unsafe because it uses a fulltext parser plugin which may not return the same value on the slave." },
{ "ER_CANNOT_DISCARD_TEMPORARY_TABLE", 3007, "Cannot DISCARD/IMPORT tablespace associated with temporary table" },
{ "ER_FK_DEPTH_EXCEEDED", 3008, "Foreign key cascade delete/update exceeds max depth of %d." },
{ "ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE_V2", 3009, "Column count of %s.%s is wrong. Expected %d, found %d. Created with MariaDB %d, now running %d. Please use mariadb-upgrade to fix this error." },
{ "ER_WARN_TRIGGER_DOESNT_HAVE_CREATED", 3010, "Trigger %s.%s.%s does not have CREATED attribute." },
{ "ER_REFERENCED_TRG_DOES_NOT_EXIST_MYSQL", 3011, "Referenced trigger \'%s\' for the given action time and event type does not exist." },
{ "ER_EXPLAIN_NOT_SUPPORTED", 3012, "EXPLAIN FOR CONNECTION command is supported only for SELECT/UPDATE/INSERT/DELETE/REPLACE" },
{ "ER_INVALID_FIELD_SIZE", 3013, "Invalid size for column \'%-.192s\'." },
{ "ER_MISSING_HA_CREATE_OPTION", 3014, "Table storage engine \'%-.64s\' found required create option missing" },
{ "ER_ENGINE_OUT_OF_MEMORY", 3015, "Out of memory in storage engine \'%-.64s\'." },
{ "ER_PASSWORD_EXPIRE_ANONYMOUS_USER", 3016, "The password for anonymous user cannot be expired." },
{ "ER_SLAVE_SQL_THREAD_MUST_STOP", 3017, "This operation cannot be performed with a running slave sql thread; run STOP SLAVE SQL_THREAD first" },
{ "ER_NO_FT_MATERIALIZED_SUBQUERY", 3018, "Cannot create FULLTEXT index on materialized subquery" },
{ "ER_INNODB_UNDO_LOG_FULL", 3019, "Undo Log error: %s" },
{ "ER_INVALID_ARGUMENT_FOR_LOGARITHM", 3020, "Invalid argument for logarithm" },
{ "ER_SLAVE_CHANNEL_IO_THREAD_MUST_STOP", 3021, "This operation cannot be performed with a running slave io thread; run STOP SLAVE IO_THREAD FOR CHANNEL \'%s\' first." },
{ "ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO", 3022, "This operation may not be safe when the slave has temporary tables. The tables will be kept open until the server restarts or until the tables are deleted by any replicated DROP statement. Suggest to wait until slave_open_temp_tables = 0." },
{ "ER_WARN_ONLY_MASTER_LOG_FILE_NO_POS", 3023, "CHANGE MASTER TO with a MASTER_LOG_FILE clause but no MASTER_LOG_POS clause may not be safe. The old position value may not be valid for the new binary log file." },
{ "ER_UNUSED_1", 3024, "You should never see it" },
{ "ER_NON_RO_SELECT_DISABLE_TIMER", 3025, "Select is not a read only statement, disabling timer" },
{ "ER_DUP_LIST_ENTRY", 3026, "Duplicate entry \'%-.192s\'." },
{ "ER_SQL_MODE_NO_EFFECT", 3027, "\'%s\' mode no longer has any effect. Use STRICT_ALL_TABLES or STRICT_TRANS_TABLES instead." },
{ "ER_AGGREGATE_ORDER_FOR_UNION", 3028, "Expression #%u of ORDER BY contains aggregate function and applies to a UNION" },
{ "ER_AGGREGATE_ORDER_NON_AGG_QUERY", 3029, "Expression #%u of ORDER BY contains aggregate function and applies to the result of a non-aggregated query" },
{ "ER_SLAVE_WORKER_STOPPED_PREVIOUS_THD_ERROR", 3030, "Slave worker has stopped after at least one previous worker encountered an error when slave-preserve-commit-order was enabled. To preserve commit order, the last transaction executed by this thread has not been committed. When restarting the slave after fixing any failed threads, you should fix this worker as well." },
{ "ER_DONT_SUPPORT_SLAVE_PRESERVE_COMMIT_ORDER", 3031, "slave_preserve_commit_order is not supported %s." },
{ "ER_SERVER_OFFLINE_MODE", 3032, "The server is currently in offline mode" },
{ "ER_GIS_DIFFERENT_SRIDS", 3033, "Binary geometry function %s given two geometries of different srids: %u and %u, which should have been identical." },
{ "ER_GIS_UNSUPPORTED_ARGUMENT", 3034, "Calling geometry function %s with unsupported types of arguments." },
{ "ER_GIS_UNKNOWN_ERROR", 3035, "Unknown GIS error occurred in function %s." },
{ "ER_GIS_UNKNOWN_EXCEPTION", 3036, "Unknown exception caught in GIS function %s." },
{ "ER_GIS_INVALID_DATA", 3037, "Invalid GIS data provided to function %s." },
{ "ER_BOOST_GEOMETRY_EMPTY_INPUT_EXCEPTION", 3038, "The geometry has no data in function %s." },
{ "ER_BOOST_GEOMETRY_CENTROID_EXCEPTION", 3039, "Unable to calculate centroid because geometry is empty in function %s." },
{ "ER_BOOST_GEOMETRY_OVERLAY_INVALID_INPUT_EXCEPTION", 3040, "Geometry overlay calculation error: geometry data is invalid in function %s." },
{ "ER_BOOST_GEOMETRY_TURN_INFO_EXCEPTION", 3041, "Geometry turn info calculation error: geometry data is invalid in function %s." },
{ "ER_BOOST_GEOMETRY_SELF_INTERSECTION_POINT_EXCEPTION", 3042, "Analysis procedures of intersection points interrupted unexpectedly in function %s." },
{ "ER_BOOST_GEOMETRY_UNKNOWN_EXCEPTION", 3043, "Unknown exception thrown in function %s." },
{ "ER_STD_BAD_ALLOC_ERROR", 3044, "Memory allocation error: %-.256s in function %s." },
{ "ER_STD_DOMAIN_ERROR", 3045, "Domain error: %-.256s in function %s." },
{ "ER_STD_LENGTH_ERROR", 3046, "Length error: %-.256s in function %s." },
{ "ER_STD_INVALID_ARGUMENT", 3047, "Invalid argument error: %-.256s in function %s." },
{ "ER_STD_OUT_OF_RANGE_ERROR", 3048, "Out of range error: %-.256s in function %s." },
{ "ER_STD_OVERFLOW_ERROR", 3049, "Overflow error: %-.256s in function %s." },
{ "ER_STD_RANGE_ERROR", 3050, "Range error: %-.256s in function %s." },
{ "ER_STD_UNDERFLOW_ERROR", 3051, "Underflow error: %-.256s in function %s." },
{ "ER_STD_LOGIC_ERROR", 3052, "Logic error: %-.256s in function %s." },
{ "ER_STD_RUNTIME_ERROR", 3053, "Runtime error: %-.256s in function %s." },
{ "ER_STD_UNKNOWN_EXCEPTION", 3054, "Unknown exception: %-.384s in function %s." },
{ "ER_GIS_DATA_WRONG_ENDIANESS", 3055, "Geometry byte string must be little endian." },
{ "ER_CHANGE_MASTER_PASSWORD_LENGTH", 3056, "The password provided for the replication user exceeds the maximum length of 32 characters" },
{ "ER_USER_LOCK_WRONG_NAME", 3057, "Incorrect user-level lock name \'%-.192s\'." },
{ "ER_USER_LOCK_DEADLOCK", 3058, "Deadlock found when trying to get user-level lock; try rolling back transaction/releasing locks and restarting lock acquisition." },
{ "ER_REPLACE_INACCESSIBLE_ROWS", 3059, "REPLACE cannot be executed as it requires deleting rows that are not in the view" },
{ "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_GIS", 3060, "Do not support online operation on table with GIS index" },
{ "ER_MYSQL_3061", 3061, "\"" },
{ "ER_MYSQL_3062", 3062, "\"" },
{ "ER_MYSQL_3063", 3063, "\"" },
{ "ER_MYSQL_3064", 3064, "\"" },
{ "ER_MYSQL_3065", 3065, "\"" },
{ "ER_MYSQL_3066", 3066, "\"" },
{ "ER_MYSQL_3067", 3067, "\"" },
{ "ER_MYSQL_3068", 3068, "\"" },
{ "ER_MYSQL_3069", 3069, "\"" },
{ "ER_MYSQL_3070", 3070, "\"" },
{ "ER_MYSQL_3071", 3071, "\"" },
{ "ER_MYSQL_3072", 3072, "\"" },
{ "ER_MYSQL_3073", 3073, "\"" },
{ "ER_MYSQL_3074", 3074, "\"" },
{ "ER_MYSQL_3075", 3075, "\"" },
{ "ER_MYSQL_3076", 3076, "\"" },
{ "ER_MYSQL_3077", 3077, "\"" },
{ "ER_MYSQL_3078", 3078, "\"" },
{ "ER_MYSQL_3079", 3079, "\"" },
{ "ER_MYSQL_3080", 3080, "\"" },
{ "ER_MYSQL_3081", 3081, "\"" },
{ "ER_MYSQL_3082", 3082, "\"" },
{ "ER_MYSQL_3083", 3083, "\"" },
{ "ER_MYSQL_3084", 3084, "\"" },
{ "ER_MYSQL_3085", 3085, "\"" },
{ "ER_MYSQL_3086", 3086, "\"" },
{ "ER_MYSQL_3087", 3087, "\"" },
{ "ER_MYSQL_3088", 3088, "\"" },
{ "ER_MYSQL_3089", 3089, "\"" },
{ "ER_MYSQL_3090", 3090, "\"" },
{ "ER_MYSQL_3091", 3091, "\"" },
{ "ER_MYSQL_3092", 3092, "\"" },
{ "ER_MYSQL_3093", 3093, "\"" },
{ "ER_MYSQL_3094", 3094, "\"" },
{ "ER_MYSQL_3095", 3095, "\"" },
{ "ER_MYSQL_3096", 3096, "\"" },
{ "ER_MYSQL_3097", 3097, "\"" },
{ "ER_MYSQL_3098", 3098, "\"" },
{ "ER_MYSQL_3099", 3099, "\"" },
{ "ER_MYSQL_3100", 3100, "\"" },
{ "ER_MYSQL_3101", 3101, "\"" },
{ "ER_MYSQL_3102", 3102, "\"" },
{ "ER_MYSQL_3103", 3103, "\"" },
{ "ER_MYSQL_3104", 3104, "\"" },
{ "ER_MYSQL_3105", 3105, "\"" },
{ "ER_MYSQL_3106", 3106, "\"" },
{ "ER_MYSQL_3107", 3107, "\"" },
{ "ER_MYSQL_3108", 3108, "\"" },
{ "ER_MYSQL_3109", 3109, "\"" },
{ "ER_MYSQL_3110", 3110, "\"" },
{ "ER_MYSQL_3111", 3111, "\"" },
{ "ER_MYSQL_3112", 3112, "\"" },
{ "ER_MYSQL_3113", 3113, "\"" },
{ "ER_MYSQL_3114", 3114, "\"" },
{ "ER_MYSQL_3115", 3115, "\"" },
{ "ER_MYSQL_3116", 3116, "\"" },
{ "ER_MYSQL_3117", 3117, "\"" },
{ "ER_MYSQL_3118", 3118, "\"" },
{ "ER_MYSQL_3119", 3119, "\"" },
{ "ER_MYSQL_3120", 3120, "\"" },
{ "ER_MYSQL_3121", 3121, "\"" },
{ "ER_MYSQL_3122", 3122, "\"" },
{ "ER_MYSQL_3123", 3123, "\"" },
{ "ER_MYSQL_3124", 3124, "\"" },
{ "ER_MYSQL_3125", 3125, "\"" },
{ "ER_MYSQL_3126", 3126, "\"" },
{ "ER_MYSQL_3127", 3127, "\"" },
{ "ER_MYSQL_3128", 3128, "\"" },
{ "ER_MYSQL_3129", 3129, "\"" },
{ "ER_MYSQL_3130", 3130, "\"" },
{ "ER_MYSQL_3131", 3131, "\"" },
{ "ER_MYSQL_3132", 3132, "\"" },
{ "ER_MYSQL_3133", 3133, "\"" },
{ "ER_MYSQL_3134", 3134, "\"" },
{ "ER_MYSQL_3135", 3135, "\"" },
{ "ER_MYSQL_3136", 3136, "\"" },
{ "ER_MYSQL_3137", 3137, "\"" },
{ "ER_MYSQL_3138", 3138, "\"" },
{ "ER_MYSQL_3139", 3139, "\"" },
{ "ER_MYSQL_3140", 3140, "\"" },
{ "ER_MYSQL_3141", 3141, "\"" },
{ "ER_MYSQL_3142", 3142, "\"" },
{ "ER_MYSQL_3143", 3143, "\"" },
{ "ER_MYSQL_3144", 3144, "\"" },
{ "ER_MYSQL_3145", 3145, "\"" },
{ "ER_MYSQL_3146", 3146, "\"" },
{ "ER_MYSQL_3147", 3147, "\"" },
{ "ER_MYSQL_3148", 3148, "\"" },
{ "ER_MYSQL_3149", 3149, "\"" },
{ "ER_MYSQL_3150", 3150, "\"" },
{ "ER_MYSQL_3151", 3151, "\"" },
{ "ER_MYSQL_3152", 3152, "\"" },
{ "ER_MYSQL_3153", 3153, "\"" },
{ "ER_MYSQL_3154", 3154, "\"" },
{ "ER_MYSQL_3155", 3155, "\"" },
{ "ER_MYSQL_3156", 3156, "\"" },
{ "ER_MYSQL_3157", 3157, "\"" },
{ "ER_MYSQL_3158", 3158, "\"" },
{ "ER_SECURE_TRANSPORT_REQUIRED", 3159, "Connections using insecure transport are prohibited while --require_secure_transport=ON." },
{ "ER_UNUSED_26", 4000, "This error never happens" },
{ "ER_UNUSED_27", 4001, "This error never happens" },
{ "ER_WITH_COL_WRONG_LIST", 4002, "WITH column list and SELECT field list have different column counts" },
{ "ER_TOO_MANY_DEFINITIONS_IN_WITH_CLAUSE", 4003, "Too many WITH elements in WITH clause" },
{ "ER_DUP_QUERY_NAME", 4004, "Duplicate query name %`-.64s in WITH clause" },
{ "ER_RECURSIVE_WITHOUT_ANCHORS", 4005, "No anchors for recursive WITH element \'%s\'" },
{ "ER_UNACCEPTABLE_MUTUAL_RECURSION", 4006, "Unacceptable mutual recursion with anchored table \'%s\'" },
{ "ER_REF_TO_RECURSIVE_WITH_TABLE_IN_DERIVED", 4007, "Reference to recursive WITH table \'%s\' in materialized derived" },
{ "ER_NOT_STANDARD_COMPLIANT_RECURSIVE", 4008, "Restrictions imposed on recursive definitions are violated for table \'%s\'" },
{ "ER_WRONG_WINDOW_SPEC_NAME", 4009, "Window specification with name \'%s\' is not defined" },
{ "ER_DUP_WINDOW_NAME", 4010, "Multiple window specifications with the same name \'%s\'" },
{ "ER_PARTITION_LIST_IN_REFERENCING_WINDOW_SPEC", 4011, "Window specification referencing another one \'%s\' cannot contain partition list" },
{ "ER_ORDER_LIST_IN_REFERENCING_WINDOW_SPEC", 4012, "Referenced window specification \'%s\' already contains order list" },
{ "ER_WINDOW_FRAME_IN_REFERENCED_WINDOW_SPEC", 4013, "Referenced window specification \'%s\' cannot contain window frame" },
{ "ER_BAD_COMBINATION_OF_WINDOW_FRAME_BOUND_SPECS", 4014, "Unacceptable combination of window frame bound specifications" },
{ "ER_WRONG_PLACEMENT_OF_WINDOW_FUNCTION", 4015, "Window function is allowed only in SELECT list and ORDER BY clause" },
{ "ER_WINDOW_FUNCTION_IN_WINDOW_SPEC", 4016, "Window function is not allowed in window specification" },
{ "ER_NOT_ALLOWED_WINDOW_FRAME", 4017, "Window frame is not allowed with \'%s\'" },
{ "ER_NO_ORDER_LIST_IN_WINDOW_SPEC", 4018, "No order list in window specification for \'%s\'" },
{ "ER_RANGE_FRAME_NEEDS_SIMPLE_ORDERBY", 4019, "RANGE-type frame requires ORDER BY clause with single sort key" },
{ "ER_WRONG_TYPE_FOR_ROWS_FRAME", 4020, "Integer is required for ROWS-type frame" },
{ "ER_WRONG_TYPE_FOR_RANGE_FRAME", 4021, "Numeric datatype is required for RANGE-type frame" },
{ "ER_FRAME_EXCLUSION_NOT_SUPPORTED", 4022, "Frame exclusion is not supported yet" },
{ "ER_WINDOW_FUNCTION_DONT_HAVE_FRAME", 4023, "This window function may not have a window frame" },
{ "ER_INVALID_NTILE_ARGUMENT", 4024, "Argument of NTILE must be greater than 0" },
{ "ER_CONSTRAINT_FAILED", 4025, "CONSTRAINT %`s failed for %`-.192s.%`-.192s" },
{ "ER_EXPRESSION_IS_TOO_BIG", 4026, "Expression in the %s clause is too big" },
{ "ER_ERROR_EVALUATING_EXPRESSION", 4027, "Got an error evaluating stored expression %s" },
{ "ER_CALCULATING_DEFAULT_VALUE", 4028, "Got an error when calculating default value for %`s" },
{ "ER_EXPRESSION_REFERS_TO_UNINIT_FIELD", 4029, "Expression for field %`-.64s is referring to uninitialized field %`s" },
{ "ER_PARTITION_DEFAULT_ERROR", 4030, "Only one DEFAULT partition allowed" },
{ "ER_REFERENCED_TRG_DOES_NOT_EXIST", 4031, "Referenced trigger \'%s\' for the given action time and event type does not exist" },
{ "ER_INVALID_DEFAULT_PARAM", 4032, "Default/ignore value is not supported for such parameter usage" },
{ "ER_BINLOG_NON_SUPPORTED_BULK", 4033, "Only row based replication supported for bulk operations" },
{ "ER_BINLOG_UNCOMPRESS_ERROR", 4034, "Uncompress the compressed binlog failed" },
{ "ER_JSON_BAD_CHR", 4035, "Broken JSON string in argument %d to function \'%s\' at position %d" },
{ "ER_JSON_NOT_JSON_CHR", 4036, "Character disallowed in JSON in argument %d to function \'%s\' at position %d" },
{ "ER_JSON_EOS", 4037, "Unexpected end of JSON text in argument %d to function \'%s\'" },
{ "ER_JSON_SYNTAX", 4038, "Syntax error in JSON text in argument %d to function \'%s\' at position %d" },
{ "ER_JSON_ESCAPING", 4039, "Incorrect escaping in JSON text in argument %d to function \'%s\' at position %d" },
{ "ER_JSON_DEPTH", 4040, "Limit of %d on JSON nested structures depth is reached in argument %d to function \'%s\' at position %d" },
{ "ER_JSON_PATH_EOS", 4041, "Unexpected end of JSON path in argument %d to function \'%s\'" },
{ "ER_JSON_PATH_SYNTAX", 4042, "Syntax error in JSON path in argument %d to function \'%s\' at position %d" },
{ "ER_JSON_PATH_DEPTH", 4043, "Limit of %d on JSON path depth is reached in argument %d to function \'%s\' at position %d" },
{ "ER_JSON_PATH_NO_WILDCARD", 4044, "Wildcards or range in JSON path not allowed in argument %d to function \'%s\'" },
{ "ER_JSON_PATH_ARRAY", 4045, "JSON path should end with an array identifier in argument %d to function \'%s\'" },
{ "ER_JSON_ONE_OR_ALL", 4046, "Argument 2 to function \'%s\' must be \"one\" or \"all\"." },
{ "ER_UNSUPPORTED_COMPRESSED_TABLE", 4047, "InnoDB refuses to write tables with ROW_FORMAT=COMPRESSED or KEY_BLOCK_SIZE." },
{ "ER_GEOJSON_INCORRECT", 4048, "Incorrect GeoJSON format specified for st_geomfromgeojson function." },
{ "ER_GEOJSON_TOO_FEW_POINTS", 4049, "Incorrect GeoJSON format - too few points for linestring specified." },
{ "ER_GEOJSON_NOT_CLOSED", 4050, "Incorrect GeoJSON format - polygon not closed." },
{ "ER_JSON_PATH_EMPTY", 4051, "Path expression \'$\' is not allowed in argument %d to function \'%s\'." },
{ "ER_SLAVE_SAME_ID", 4052, "A slave with the same server_uuid/server_id as this slave has connected to the master" },
{ "ER_FLASHBACK_NOT_SUPPORTED", 4053, "Flashback does not support %s %s" },
{ "ER_KEYS_OUT_OF_ORDER", 4054, "Keys are out order during bulk load" },
{ "ER_OVERLAPPING_KEYS", 4055, "Bulk load rows overlap existing rows" },
{ "ER_REQUIRE_ROW_BINLOG_FORMAT", 4056, "Can\'t execute updates on master with binlog_format != ROW." },
{ "ER_ISOLATION_MODE_NOT_SUPPORTED", 4057, "MyRocks supports only READ COMMITTED and REPEATABLE READ isolation levels. Please change from current isolation level %s" },
{ "ER_ON_DUPLICATE_DISABLED", 4058, "When unique checking is disabled in MyRocks, INSERT,UPDATE,LOAD statements with clauses that update or replace the key (i.e. INSERT ON DUPLICATE KEY UPDATE, REPLACE) are not allowed. Query: %s" },
{ "ER_UPDATES_WITH_CONSISTENT_SNAPSHOT", 4059, "Can\'t execute updates when you started a transaction with START TRANSACTION WITH CONSISTENT [ROCKSDB] SNAPSHOT." },
{ "ER_ROLLBACK_ONLY", 4060, "This transaction was rolled back and cannot be committed. Only supported operation is to roll it back, so all pending changes will be discarded. Please restart another transaction." },
{ "ER_ROLLBACK_TO_SAVEPOINT", 4061, "MyRocks currently does not support ROLLBACK TO SAVEPOINT if modifying rows." },
{ "ER_ISOLATION_LEVEL_WITH_CONSISTENT_SNAPSHOT", 4062, "Only REPEATABLE READ isolation level is supported for START TRANSACTION WITH CONSISTENT SNAPSHOT in RocksDB Storage Engine." },
{ "ER_UNSUPPORTED_COLLATION", 4063, "Unsupported collation on string indexed column %s.%s Use binary collation (%s)." },
{ "ER_METADATA_INCONSISTENCY", 4064, "Table \'%s\' does not exist, but metadata information exists inside MyRocks. This is a sign of data inconsistency. Please check if \'%s.frm\' exists, and try to restore it if it does not exist." },
{ "ER_CF_DIFFERENT", 4065, "Column family (\'%s\') flag (%d) is different from an existing flag (%d). Assign a new CF flag, or do not change existing CF flag." },
{ "ER_RDB_TTL_DURATION_FORMAT", 4066, "TTL duration (%s) in MyRocks must be an unsigned non-null 64-bit integer." },
{ "ER_RDB_STATUS_GENERAL", 4067, "Status error %d received from RocksDB: %s" },
{ "ER_RDB_STATUS_MSG", 4068, "%s, Status error %d received from RocksDB: %s" },
{ "ER_RDB_TTL_UNSUPPORTED", 4069, "TTL support is currently disabled when table has a hidden PK." },
{ "ER_RDB_TTL_COL_FORMAT", 4070, "TTL column (%s) in MyRocks must be an unsigned non-null 64-bit integer, exist inside the table, and have an accompanying ttl duration." },
{ "ER_PER_INDEX_CF_DEPRECATED", 4071, "The per-index column family option has been deprecated" },
{ "ER_KEY_CREATE_DURING_ALTER", 4072, "MyRocks failed creating new key definitions during alter." },
{ "ER_SK_POPULATE_DURING_ALTER", 4073, "MyRocks failed populating secondary key during alter." },
{ "ER_SUM_FUNC_WITH_WINDOW_FUNC_AS_ARG", 4074, "Window functions can not be used as arguments to group functions." },
{ "ER_NET_OK_PACKET_TOO_LARGE", 4075, "OK packet too large" },
{ "ER_GEOJSON_EMPTY_COORDINATES", 4076, "Incorrect GeoJSON format - empty \'coordinates\' array." },
{ "ER_MYROCKS_CANT_NOPAD_COLLATION", 4077, "MyRocks doesn\'t currently support collations with \"No pad\" attribute." },
{ "ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION", 4078, "Illegal parameter data types %s and %s for operation \'%s\'" },
{ "ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION", 4079, "Illegal parameter data type %s for operation \'%s\'" },
{ "ER_WRONG_PARAMCOUNT_TO_CURSOR", 4080, "Incorrect parameter count to cursor \'%-.192s\'" },
{ "ER_UNKNOWN_STRUCTURED_VARIABLE", 4081, "Unknown structured system variable or ROW routine variable \'%-.*s\'" },
{ "ER_ROW_VARIABLE_DOES_NOT_HAVE_FIELD", 4082, "Row variable \'%-.192s\' does not have a field \'%-.192s\'" },
{ "ER_END_IDENTIFIER_DOES_NOT_MATCH", 4083, "END identifier \'%-.192s\' does not match \'%-.192s\'" },
{ "ER_SEQUENCE_RUN_OUT", 4084, "Sequence \'%-.64s.%-.64s\' has run out" },
{ "ER_SEQUENCE_INVALID_DATA", 4085, "Sequence \'%-.64s.%-.64s\' has out of range value for options" },
{ "ER_SEQUENCE_INVALID_TABLE_STRUCTURE", 4086, "Sequence \'%-.64s.%-.64s\' table structure is invalid (%s)" },
{ "ER_SEQUENCE_ACCESS_ERROR", 4087, "Sequence \'%-.64s.%-.64s\' access error" },
{ "ER_SEQUENCE_BINLOG_FORMAT", 4088, "Sequences requires binlog_format mixed or row" },
{ "ER_NOT_SEQUENCE", 4089, "\'%-.64s.%-.64s\' is not a SEQUENCE" },
{ "ER_NOT_SEQUENCE2", 4090, "\'%-.192s\' is not a SEQUENCE" },
{ "ER_UNKNOWN_SEQUENCES", 4091, "Unknown SEQUENCE: \'%-.300s\'" },
{ "ER_UNKNOWN_VIEW", 4092, "Unknown VIEW: \'%-.300s\'" },
{ "ER_WRONG_INSERT_INTO_SEQUENCE", 4093, "Wrong INSERT into a SEQUENCE. One can only do single table INSERT into a sequence object (like with mariadb-dump). If you want to change the SEQUENCE, use ALTER SEQUENCE instead." },
{ "ER_SP_STACK_TRACE", 4094, "At line %u in %s" },
{ "ER_PACKAGE_ROUTINE_IN_SPEC_NOT_DEFINED_IN_BODY", 4095, "%s %`s is declared in the package specification but is not defined in the package body" },
{ "ER_PACKAGE_ROUTINE_FORWARD_DECLARATION_NOT_DEFINED", 4096, "%s %`s has a forward declaration but is not defined" },
{ "ER_COMPRESSED_COLUMN_USED_AS_KEY", 4097, "Compressed column \'%-.192s\' can\'t be used in key specification" },
{ "ER_UNKNOWN_COMPRESSION_METHOD", 4098, "Unknown compression method: %s" },
{ "ER_WRONG_NUMBER_OF_VALUES_IN_TVC", 4099, "The used table value constructor has a different number of values" },
{ "ER_FIELD_REFERENCE_IN_TVC", 4100, "Field reference \'%-.192s\' can\'t be used in table value constructor" },
{ "ER_WRONG_TYPE_FOR_PERCENTILE_FUNC", 4101, "Numeric datatype is required for %s function" },
{ "ER_ARGUMENT_NOT_CONSTANT", 4102, "Argument to the %s function is not a constant for a partition" },
{ "ER_ARGUMENT_OUT_OF_RANGE", 4103, "Argument to the %s function does not belong to the range [0,1]" },
{ "ER_WRONG_TYPE_OF_ARGUMENT", 4104, "%s function only accepts arguments that can be converted to numerical types" },
{ "ER_NOT_AGGREGATE_FUNCTION", 4105, "Aggregate specific instruction (FETCH GROUP NEXT ROW) used in a wrong context" },
{ "ER_INVALID_AGGREGATE_FUNCTION", 4106, "Aggregate specific instruction(FETCH GROUP NEXT ROW) missing from the aggregate function" },
{ "ER_INVALID_VALUE_TO_LIMIT", 4107, "Limit only accepts integer values" },
{ "ER_INVISIBLE_NOT_NULL_WITHOUT_DEFAULT", 4108, "Invisible column %`s must have a default value" },
{ "ER_UPDATE_INFO_WITH_SYSTEM_VERSIONING", 4109, "Rows matched: %ld Changed: %ld Inserted: %ld Warnings: %ld" },
{ "ER_VERS_FIELD_WRONG_TYPE", 4110, "%`s must be of type %s for system-versioned table %`s" },
{ "ER_VERS_ENGINE_UNSUPPORTED", 4111, "Transaction-precise system versioning for %`s is not supported" },
{ "ER_WRONG_VERSIONING_RANGE", 4112, "Incorrect system-version range \'%-.32s\' value: \'%-.128T\' and \'%-.32s\' value: \'%-.128T\'" },
{ "ER_PARTITION_WRONG_TYPE", 4113, "Wrong partition type %`s for partitioning by %`s" },
{ "WARN_VERS_PART_FULL", 4114, "Versioned table %`s.%`s: last HISTORY partition (%`s) is out of %s, need more HISTORY partitions" },
{ "WARN_VERS_PARAMETERS", 4115, "Maybe missing parameters: %s" },
{ "ER_VERS_DROP_PARTITION_INTERVAL", 4116, "Can only drop oldest partitions when rotating by INTERVAL" },
{ "ER_UNUSED_25", 4117, "You should never see it" },
{ "WARN_VERS_PART_NON_HISTORICAL", 4118, "Partition %`s contains non-historical data" },
{ "ER_VERS_ALTER_NOT_ALLOWED", 4119, "Not allowed for system-versioned %`s.%`s. Change @@system_versioning_alter_history to proceed with ALTER." },
{ "ER_VERS_ALTER_ENGINE_PROHIBITED", 4120, "Not allowed for system-versioned %`s.%`s. Change to/from native system versioning engine is not supported." },
{ "ER_VERS_RANGE_PROHIBITED", 4121, "SYSTEM_TIME range selector is not allowed" },
{ "ER_CONFLICTING_FOR_SYSTEM_TIME", 4122, "Conflicting FOR SYSTEM_TIME clauses in WITH RECURSIVE" },
{ "ER_VERS_TABLE_MUST_HAVE_COLUMNS", 4123, "Table %`s must have at least one versioned column" },
{ "ER_VERS_NOT_VERSIONED", 4124, "Table %`s is not system-versioned" },
{ "ER_MISSING", 4125, "Wrong parameters for %`s: missing \'%s\'" },
{ "ER_VERS_PERIOD_COLUMNS", 4126, "PERIOD FOR SYSTEM_TIME must use columns %`s and %`s" },
{ "ER_PART_WRONG_VALUE", 4127, "Wrong parameters for partitioned %`s: wrong value for \'%s\'" },
{ "ER_VERS_WRONG_PARTS", 4128, "Wrong partitions for %`s: must have at least one HISTORY and exactly one last CURRENT" },
{ "ER_VERS_NO_TRX_ID", 4129, "TRX_ID %llu not found in `mysql.transaction_registry`" },
{ "ER_VERS_ALTER_SYSTEM_FIELD", 4130, "Can not change system versioning field %`s" },
{ "ER_DROP_VERSIONING_SYSTEM_TIME_PARTITION", 4131, "Can not DROP SYSTEM VERSIONING for table %`s partitioned BY SYSTEM_TIME" },
{ "ER_VERS_DB_NOT_SUPPORTED", 4132, "System-versioned tables in the %`s database are not supported" },
{ "ER_VERS_TRT_IS_DISABLED", 4133, "Transaction registry is disabled" },
{ "ER_VERS_DUPLICATE_ROW_START_END", 4134, "Duplicate ROW %s column %`s" },
{ "ER_VERS_ALREADY_VERSIONED", 4135, "Table %`s is already system-versioned" },
{ "ER_UNUSED_24", 4136, "You should never see it" },
{ "ER_VERS_NOT_SUPPORTED", 4137, "System-versioned tables do not support %s" },
{ "ER_VERS_TRX_PART_HISTORIC_ROW_NOT_SUPPORTED", 4138, "Transaction-precise system-versioned tables do not support partitioning by ROW START or ROW END" },
{ "ER_INDEX_FILE_FULL", 4139, "The index file for table \'%-.192s\' is full" },
{ "ER_UPDATED_COLUMN_ONLY_ONCE", 4140, "The column %`s.%`s cannot be changed more than once in a single UPDATE statement" },
{ "ER_EMPTY_ROW_IN_TVC", 4141, "Row with no elements is not allowed in table value constructor in this context" },
{ "ER_VERS_QUERY_IN_PARTITION", 4142, "SYSTEM_TIME partitions in table %`s does not support historical query" },
{ "ER_KEY_DOESNT_SUPPORT", 4143, "%s index %`s does not support this operation" },
{ "ER_ALTER_OPERATION_TABLE_OPTIONS_NEED_REBUILD", 4144, "Changing table options requires the table to be rebuilt" },
{ "ER_BACKUP_LOCK_IS_ACTIVE", 4145, "Can\'t execute the command as you have a BACKUP STAGE active" },
{ "ER_BACKUP_NOT_RUNNING", 4146, "You must start backup with \"BACKUP STAGE START\"" },
{ "ER_BACKUP_WRONG_STAGE", 4147, "Backup stage \'%s\' is same or before current backup stage \'%s\'" },
{ "ER_BACKUP_STAGE_FAILED", 4148, "Backup stage \'%s\' failed" },
{ "ER_BACKUP_UNKNOWN_STAGE", 4149, "Unknown backup stage: \'%s\'. Stage should be one of START, FLUSH, BLOCK_DDL, BLOCK_COMMIT or END" },
{ "ER_USER_IS_BLOCKED", 4150, "User is blocked because of too many credential errors; unblock with \'ALTER USER / FLUSH PRIVILEGES\'" },
{ "ER_ACCOUNT_HAS_BEEN_LOCKED", 4151, "Access denied, this account is locked" },
{ "ER_PERIOD_TEMPORARY_NOT_ALLOWED", 4152, "Application-time period table cannot be temporary" },
{ "ER_PERIOD_TYPES_MISMATCH", 4153, "Fields of PERIOD FOR %`s have different types" },
{ "ER_MORE_THAN_ONE_PERIOD", 4154, "Cannot specify more than one application-time period" },
{ "ER_PERIOD_FIELD_WRONG_ATTRIBUTES", 4155, "Period field %`s cannot be %s" },
{ "ER_PERIOD_NOT_FOUND", 4156, "Period %`s is not found in table" },
{ "ER_PERIOD_COLUMNS_UPDATED", 4157, "Column %`s used in period %`s specified in update SET list" },
{ "ER_PERIOD_CONSTRAINT_DROP", 4158, "Can\'t DROP CONSTRAINT `%s`. Use DROP PERIOD `%s` for this" },
{ "ER_TOO_LONG_KEYPART", 4159, "Specified key part was too long; max key part length is %u bytes" },
{ "ER_TOO_LONG_DATABASE_COMMENT", 4160, "Comment for database \'%-.64s\' is too long (max = %u)" },
{ "ER_UNKNOWN_DATA_TYPE", 4161, "Unknown data type: \'%-.64s\'" },
{ "ER_UNKNOWN_OPERATOR", 4162, "Operator does not exist: \'%-.128s\'" },
{ "ER_UNUSED_29", 4163, "You should never see it" },
{ "ER_PART_STARTS_BEYOND_INTERVAL", 4164, "%`s: STARTS is later than query time, first history partition may exceed INTERVAL value" },
{ "ER_GALERA_REPLICATION_NOT_SUPPORTED", 4165, "Galera replication not supported" },
{ "ER_LOAD_INFILE_CAPABILITY_DISABLED", 4166, "The used command is not allowed because the MariaDB server or client has disabled the local infile capability" },
{ "ER_NO_SECURE_TRANSPORTS_CONFIGURED", 4167, "No secure transports are configured, unable to set --require_secure_transport=ON" },
{ "ER_SLAVE_IGNORED_SHARED_TABLE", 4168, "Slave SQL thread ignored the \'%s\' because table is shared" },
{ "ER_NO_AUTOINCREMENT_WITH_UNIQUE", 4169, "AUTO_INCREMENT column %`s cannot be used in the UNIQUE index %`s" },
{ "ER_KEY_CONTAINS_PERIOD_FIELDS", 4170, "Key %`s cannot explicitly include column %`s" },
{ "ER_KEY_CANT_HAVE_WITHOUT_OVERLAPS", 4171, "Key %`s cannot have WITHOUT OVERLAPS" },
{ "ER_NOT_ALLOWED_IN_THIS_CONTEXT", 4172, "\'%-.128s\' is not allowed in this context" },
{ "ER_DATA_WAS_COMMITED_UNDER_ROLLBACK", 4173, "Engine %s does not support rollback. Changes were committed during rollback call" },
{ "ER_PK_INDEX_CANT_BE_IGNORED", 4174, "A primary key cannot be marked as IGNORE" },
{ "ER_BINLOG_UNSAFE_SKIP_LOCKED", 4175, "SKIP LOCKED makes this statement unsafe" },
{ "ER_JSON_TABLE_ERROR_ON_FIELD", 4176, "Field \'%s\' can\'t be set for JSON_TABLE \'%s\'." },
{ "ER_JSON_TABLE_ALIAS_REQUIRED", 4177, "Every table function must have an alias." },
{ "ER_JSON_TABLE_SCALAR_EXPECTED", 4178, "Can\'t store an array or an object in the scalar column \'%s\' of JSON_TABLE \'%s\'." },
{ "ER_JSON_TABLE_MULTIPLE_MATCHES", 4179, "Can\'t store multiple matches of the path in the column \'%s\' of JSON_TABLE \'%s\'." },
{ "ER_WITH_TIES_NEEDS_ORDER", 4180, "FETCH ... WITH TIES requires ORDER BY clause to be present" },
{ "ER_REMOVED_ORPHAN_TRIGGER", 4181, "Dropped orphan trigger \'%-.64s\', originally created for table: \'%-.192s\'" },
{ "ER_STORAGE_ENGINE_DISABLED", 4182, "Storage engine %s is disabled" },
{ "WARN_SFORMAT_ERROR", 4183, "SFORMAT error: %s" },
{ "ER_PARTITION_CONVERT_SUBPARTITIONED", 4184, "Convert partition is not supported for subpartitioned table." },
{ "ER_PROVIDER_NOT_LOADED", 4185, "MariaDB tried to use the %s, but its provider plugin is not loaded" },
{ "ER_JSON_HISTOGRAM_PARSE_FAILED", 4186, "Failed to parse histogram for table %s.%s: %s at offset %d." },
{ "ER_SF_OUT_INOUT_ARG_NOT_ALLOWED", 4187, "OUT or INOUT argument %d for function %s is not allowed here" },
{ "ER_INCONSISTENT_SLAVE_TEMP_TABLE", 4188, "Replicated query \'%s\' table `%s.%s` can not be temporary" },
{ "ER_VERS_HIST_PART_FAILED", 4189, "Versioned table %`s.%`s: adding HISTORY partition(s) failed" },
{ "WARN_OPTION_CHANGING", 4190, "%s is implicitly changing the value of \'%s\' from \'%s\' to \'%s\'" },
{ "ER_CM_OPTION_MISSING_REQUIREMENT", 4191, "CHANGE MASTER TO option \'%s=%s\' is missing requirement %s" },
{ "ER_SLAVE_STATEMENT_TIMEOUT", 4192, "Slave log event execution was interrupted (slave_max_statement_time exceeded)" },
{ "ER_JSON_INVALID_VALUE_FOR_KEYWORD", 4193, "Invalid value for keyword %s" },
{ "ER_JSON_SCHEMA_KEYWORD_UNSUPPORTED", 4194, "%s keyword is not supported" },
{ "ER_JSON_NO_VARIABLE_SCHEMA", 4195, "Variable schema is not supported." },
{ "ER_SEQUENCE_TABLE_HAS_WRONG_NUMBER_OF_COLUMNS", 4196, "Wrong number of columns" },
{ "ER_SEQUENCE_TABLE_CANNOT_HAVE_ANY_KEYS", 4197, "Sequence tables cannot have any keys" },
{ "ER_SEQUENCE_TABLE_CANNOT_HAVE_ANY_CONSTRAINTS", 4198, "Sequence tables cannot have any constraints" },
{ "ER_SEQUENCE_TABLE_ORDER_BY", 4199, "ORDER BY" },
{ "ER_VARIABLE_IGNORED", 4200, "The setting \'%s\' is ignored. It only exists for compatibility with old installations and will be removed in a future release" },
{ "ER_INCORRECT_COLUMN_NAME_COUNT", 4201, "Incorrect column name count for derived table" },
{ "WARN_SORTING_ON_TRUNCATED_LENGTH", 4202, "%llu values were longer than max_sort_length. Sorting used only the first %lu bytes" },
{ "ER_VECTOR_BINARY_FORMAT_INVALID", 4203, "Invalid binary vector format. Must use IEEE standard float representation in little-endian format. Use VEC_FromText() to generate it." },
{ "ER_VECTOR_FORMAT_INVALID", 4204, "Invalid vector format at offset: %d for \'%-.100s\'. Must be a valid JSON array of numbers." },
{ "ER_PSEUDO_THREAD_ID_OVERWRITE", 4205, "Pseudo thread id should not be modified by the client as it will be overwritten" },
PK ! Y흿 my_byteorder.hnu [ #ifndef MY_BYTEORDER_INCLUDED
#define MY_BYTEORDER_INCLUDED
/* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#include /* memcpy */
/*
Byte-swap helpers.
*/
#ifdef _MSC_VER
# include /* _byteswap_* */
# define MY_BSWAP16(x) _byteswap_ushort(x)
# define MY_BSWAP32(x) _byteswap_ulong(x)
# define MY_BSWAP64(x) _byteswap_uint64(x)
#elif defined __GNUC__
# define MY_BSWAP16(x) __builtin_bswap16(x)
# define MY_BSWAP32(x) __builtin_bswap32(x)
# define MY_BSWAP64(x) __builtin_bswap64(x)
#else
# error provide byteswap intrinsics
#endif
/*
Some inline functions to convert between little-endian and host byte order
in the spirit of htons/htonl et al.
*/
static inline uint16 my_letoh16(uint16 x)
{
#ifdef WORDS_BIGENDIAN
return MY_BSWAP16(x);
#else
return x;
#endif
}
static inline uint16 my_betoh16(uint16 x)
{
#ifdef WORDS_BIGENDIAN
return x;
#else
return MY_BSWAP16(x);
#endif
}
static inline uint32 my_letoh32(uint32 x)
{
#ifdef WORDS_BIGENDIAN
return MY_BSWAP32(x);
#else
return x;
#endif
}
static inline uint32 my_betoh32(uint32 x)
{
#ifdef WORDS_BIGENDIAN
return x;
#else
return MY_BSWAP32(x);
#endif
}
static inline uint64 my_letoh64(uint64 x)
{
#ifdef WORDS_BIGENDIAN
return MY_BSWAP64(x);
#else
return x;
#endif
}
static inline uint64 my_betoh64(uint64 x)
{
#ifdef WORDS_BIGENDIAN
return x;
#else
return MY_BSWAP64(x);
#endif
}
#define my_htole16(x) my_letoh16(x)
#define my_htobe16(x) my_betoh16(x)
#define my_htole32(x) my_letoh32(x)
#define my_htobe32(x) my_betoh32(x)
#define my_htole64(x) my_letoh64(x)
#define my_htobe64(x) my_betoh64(x)
/*
Inline functions for reading/storing little endian integers from/to
potentially unaligned memory.
memcpy() is used to avoid unaligned access. On most platforms the compiler
will optimize memcpy to a single instruction.
*/
static inline uint16 uint2korr(const void *p)
{
uint16 ret;
memcpy(&ret, p, 2);
return my_letoh16(ret);
}
static inline uint32 uint4korr(const void *p)
{
uint32 ret;
memcpy(&ret, p, 4);
return my_letoh32(ret);
}
static inline uint64 uint8korr(const void *p)
{
uint64 ret;
memcpy(&ret, p, 8);
return my_letoh64(ret);
}
static inline int16 sint2korr(const void *p)
{
return (int16) uint2korr(p);
}
static inline int32 sint4korr(const void *p)
{
return (int32) uint4korr(p);
}
static inline longlong sint8korr(const void *p)
{
return (longlong) uint8korr(p);
}
static inline void int2store(void *t, ulonglong a)
{
uint16 v= my_htole16((uint16) a);
memcpy(t, &v, 2);
}
static inline void int4store(void *t, ulonglong a)
{
uint32 v= my_htole32((uint32) a);
memcpy(t, &v, 4);
}
static inline void int8store(void *t, ulonglong a)
{
uint64 v= my_htole64((uint64) a);
memcpy(t, &v, 8);
}
/*
Odd-width and sign-extending functions. These use only individual
byte accesses or delegate to the even-width functions above, so they
are correct on any host endianness without further #ifdefs.
*/
static inline uint32 uint3korr(const void *p)
{
return (uint32) uint2korr(p) | ((uint32) ((const uchar *) p)[2] << 16);
}
static inline int32 sint3korr(const void *p)
{
uint32 v = uint3korr(p);
/*
Shift left to move sign bit into MSB position, then arithmetic
right shift to sign-extend back.
*/
return ((int32)(v << 8)) >> 8;
}
static inline ulonglong uint5korr(const void *p)
{
return (ulonglong) uint4korr(p) | ((ulonglong) ((const uchar *) p)[4] << 32);
}
static inline ulonglong uint6korr(const void *p)
{
return (ulonglong) uint4korr(p) |
((ulonglong) uint2korr((const uchar *) p + 4) << 32);
}
static inline void int3store(void *t, ulonglong a)
{
uchar *p= (uchar *) t;
int2store(t, a);
p[2]= (uchar) (a >> 16);
}
static inline void int5store(void *t, ulonglong a)
{
uchar *p= (uchar *) t;
int4store(t, a);
p[4]= (uchar) (a >> 32);
}
static inline void int6store(void *t, ulonglong a)
{
uchar *p= (uchar *) t;
int4store(t, a);
int2store(p + 4, a >> 32);
}
/*
mi_uint*korr: read an N-byte unsigned integer stored in big-endian
order, as used by MyISAM.
Below are optimizations for little-endian architectures.
*/
#ifndef WORDS_BIGENDIAN
#define HAVE_mi_uint5korr
#define HAVE_mi_uint6korr
#define HAVE_mi_uint7korr
#define HAVE_mi_uint8korr
static inline ulonglong mi_uint5korr(const void *p)
{
uint32 lo;
memcpy(&lo, (const uchar *) p + 1, 4);
lo= MY_BSWAP32(lo);
return ((ulonglong) ((const uchar *)p)[0]) << 32 | lo;
}
static inline ulonglong mi_uint6korr(const void *p)
{
uint32 a;
uint16 b;
ulonglong v;
memcpy(&a, p, 4);
memcpy(&b, (const uchar *) p + 4, 2);
v= ((ulonglong) a | ((ulonglong) b << 32)) << 16;
return MY_BSWAP64(v);
}
static inline ulonglong mi_uint7korr(const void *p)
{
uint32 a;
uint16 b;
ulonglong v;
ulonglong c= ((const uchar *)p)[6];
memcpy(&a, p, 4);
memcpy(&b, (const uchar *) p + 4, 2);
v= ((ulonglong)a | ((ulonglong)b << 32) | (c << 48)) << 8;
return MY_BSWAP64(v);
}
static inline ulonglong mi_uint8korr(const void *p)
{
ulonglong ret;
memcpy(&ret, p, 8);
return MY_BSWAP64(ret);
}
#endif /* !WORDS_BIGENDIAN */
/*
Read a 32-bit integer from network byte order (big-endian)
from an unaligned memory location.
*/
static inline int32 int4net(const void *p)
{
int32 ret;
memcpy(&ret, p, 4);
return (int32)my_betoh32(ret);
}
/*
Some macros for reading doubles and floats (clean, do not assume alignment)
These are defined in big_endian.h and little_endian.h
*/
#ifdef WORDS_BIGENDIAN
#include "big_endian.h"
#else
#include "little_endian.h"
#endif
#endif /* MY_BYTEORDER_INCLUDED */
PK ! .d$t t mysql_time.hnu [ /* Copyright (c) 2004, 2006 MySQL AB
Use is subject to license terms
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _mysql_time_h_
#define _mysql_time_h_
/*
Portable time_t replacement.
Should be signed and hold seconds for 1902 -- 2038-01-19 range
i.e at least a 32bit variable
Using the system built in time_t is not an option as
we rely on the above requirements in the time functions
*/
typedef long my_time_t;
/*
Time declarations shared between the server and client API:
you should not add anything to this header unless it's used
(and hence should be visible) in mysql.h.
If you're looking for a place to add new time-related declaration,
it's most likely my_time.h. See also "C API Handling of Date
and Time Values" chapter in documentation.
*/
enum enum_mysql_timestamp_type
{
MYSQL_TIMESTAMP_NONE= -2, MYSQL_TIMESTAMP_ERROR= -1,
MYSQL_TIMESTAMP_DATE= 0, MYSQL_TIMESTAMP_DATETIME= 1, MYSQL_TIMESTAMP_TIME= 2
};
/*
Structure which is used to represent datetime values inside MySQL.
We assume that values in this structure are normalized, i.e. year <= 9999,
month <= 12, day <= 31, hour <= 23, hour <= 59, hour <= 59. Many functions
in server such as my_system_gmt_sec() or make_time() family of functions
rely on this (actually now usage of make_*() family relies on a bit weaker
restriction). Also functions that produce MYSQL_TIME as result ensure this.
There is one exception to this rule though if this structure holds time
value (time_type == MYSQL_TIMESTAMP_TIME) days and hour member can hold
bigger values.
*/
typedef struct st_mysql_time
{
unsigned int year, month, day, hour, minute, second;
unsigned long second_part;
my_bool neg;
enum enum_mysql_timestamp_type time_type;
} MYSQL_TIME;
#endif /* _mysql_time_h_ */
PK ! Q Q pack.hnu [ /* Copyright (c) 2016, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
#ifdef __cplusplus
extern "C" {
#endif
ulong net_field_length(uchar **packet);
my_ulonglong net_field_length_ll(uchar **packet);
my_ulonglong safe_net_field_length_ll(uchar **packet, size_t packet_len);
uchar *net_store_length(uchar *pkg, ulonglong length);
uchar *safe_net_store_length(uchar *pkg, size_t pkg_len, ulonglong length);
unsigned int net_length_size(ulonglong num);
#ifdef __cplusplus
}
#endif
PK ! +4{" {"
keycache.hnu [ /* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/* Key cache variable structures */
#ifndef _keycache_h
#define _keycache_h
#include "my_sys.h" /* flush_type */
C_MODE_START
/*
Currently the default key cache is created as non-partitioned at
the start of the server unless the server is started with the parameter
--key-cache-partitions that is greater than 0
*/
#define DEFAULT_KEY_CACHE_PARTITIONS 0
/*
MAX_KEY_CACHE_PARTITIONS cannot be greater than
sizeof(MYISAM_SHARE::dirty_part_map)
Currently sizeof(MYISAM_SHARE::dirty_part_map)=sizeof(ulonglong)
*/
#define MAX_KEY_CACHE_PARTITIONS 64
/* The structure to get statistical data about a key cache */
typedef struct st_key_cache_statistics
{
ulonglong mem_size; /* memory for cache buffers/auxiliary structures */
ulonglong block_size; /* size of the each buffers in the key cache */
ulonglong blocks_used; /* maximum number of used blocks/buffers */
ulonglong blocks_unused; /* number of currently unused blocks */
ulonglong blocks_changed; /* number of currently dirty blocks */
ulonglong blocks_warm; /* number of blocks in warm sub-chain */
ulonglong read_requests; /* number of read requests (read hits) */
ulonglong reads; /* number of actual reads from files into buffers */
ulonglong write_requests; /* number of write requests (write hits) */
ulonglong writes; /* number of actual writes from buffers into files */
} KEY_CACHE_STATISTICS;
#define NUM_LONG_KEY_CACHE_STAT_VARIABLES 3
/* The type of a key cache object */
typedef enum key_cache_type
{
SIMPLE_KEY_CACHE,
PARTITIONED_KEY_CACHE
} KEY_CACHE_TYPE;
typedef
int (*INIT_KEY_CACHE)
(void *, uint key_cache_block_size,
size_t use_mem, uint division_limit, uint age_threshold,
uint changed_blocks_hash_size);
typedef
int (*RESIZE_KEY_CACHE)
(void *, uint key_cache_block_size,
size_t use_mem, uint division_limit, uint age_threshold,
uint changed_blocks_hash_size);
typedef
void (*CHANGE_KEY_CACHE_PARAM)
(void *keycache_cb,
uint division_limit, uint age_threshold);
typedef
uchar* (*KEY_CACHE_READ)
(void *keycache_cb,
File file, my_off_t filepos, int level,
uchar *buff, uint length,
uint block_length, int return_buffer);
typedef
int (*KEY_CACHE_INSERT)
(void *keycache_cb,
File file, my_off_t filepos, int level,
uchar *buff, uint length);
typedef
int (*KEY_CACHE_WRITE)
(void *keycache_cb,
File file, void *file_extra,
my_off_t filepos, int level,
uchar *buff, uint length,
uint block_length, int force_write);
typedef
int (*FLUSH_KEY_BLOCKS)
(void *keycache_cb,
int file, void *file_extra,
enum flush_type type);
typedef
int (*RESET_KEY_CACHE_COUNTERS)
(const char *name, void *keycache_cb);
typedef
void (*END_KEY_CACHE)
(void *keycache_cb, my_bool cleanup);
typedef
void (*GET_KEY_CACHE_STATISTICS)
(void *keycache_cb, uint partition_no,
KEY_CACHE_STATISTICS *key_cache_stats);
/*
An object of the type KEY_CACHE_FUNCS contains pointers to all functions
from the key cache interface.
Currently a key cache can be of two types: simple and partitioned.
For each of them its own static structure of the type KEY_CACHE_FUNCS is
defined . The structures contain the pointers to the implementations of
the interface functions used by simple key caches and partitioned key
caches respectively. Pointers to these structures are assigned to key cache
objects at the time of their creation.
*/
typedef struct st_key_cache_funcs
{
INIT_KEY_CACHE init;
RESIZE_KEY_CACHE resize;
CHANGE_KEY_CACHE_PARAM change_param;
KEY_CACHE_READ read;
KEY_CACHE_INSERT insert;
KEY_CACHE_WRITE write;
FLUSH_KEY_BLOCKS flush;
RESET_KEY_CACHE_COUNTERS reset_counters;
END_KEY_CACHE end;
GET_KEY_CACHE_STATISTICS get_stats;
} KEY_CACHE_FUNCS;
typedef struct st_key_cache
{
KEY_CACHE_TYPE key_cache_type; /* type of the key cache used for debugging */
void *keycache_cb; /* control block of the used key cache */
KEY_CACHE_FUNCS *interface_funcs; /* interface functions of the key cache */
ulonglong param_buff_size; /* size the memory allocated for the cache */
ulonglong param_block_size; /* size of the blocks in the key cache */
ulonglong param_division_limit;/* min. percentage of warm blocks */
ulonglong param_age_threshold; /* determines when hot block is downgraded */
ulonglong param_partitions; /* number of the key cache partitions */
ulonglong changed_blocks_hash_size; /* number of hash buckets for changed files */
my_bool key_cache_inited; /* <=> key cache has been created */
my_bool can_be_used; /* usage of cache for read/write is allowed */
my_bool in_init; /* set to 1 in MySQL during init/resize */
uint partitions; /* actual number of partitions */
size_t key_cache_mem_size; /* specified size of the cache memory */
pthread_mutex_t op_lock; /* to serialize operations like 'resize' */
} KEY_CACHE;
/* The default key cache */
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
extern int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size,
uint partitions);
extern int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size);
extern void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
uint age_threshold);
extern uchar *key_cache_read(KEY_CACHE *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length,
uint block_length,int return_buffer);
extern int key_cache_insert(KEY_CACHE *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length);
extern int key_cache_write(KEY_CACHE *keycache,
File file, void *file_extra,
my_off_t filepos, int level,
uchar *buff, uint length,
uint block_length, int force_write);
extern int flush_key_blocks(KEY_CACHE *keycache,
int file, void *file_extra,
enum flush_type type);
extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
extern void get_key_cache_statistics(KEY_CACHE *keycache,
uint partition_no,
KEY_CACHE_STATISTICS *key_cache_stats);
/* Functions to handle multiple key caches */
extern my_bool multi_keycache_init(void);
extern void multi_keycache_free(void);
extern KEY_CACHE *multi_key_cache_search(uchar *key, uint length,
KEY_CACHE *def);
extern my_bool multi_key_cache_set(const uchar *key, uint length,
KEY_CACHE *key_cache);
extern void multi_key_cache_change(KEY_CACHE *old_data,
KEY_CACHE *new_data);
extern int reset_key_cache_counters(const char *name,
KEY_CACHE *key_cache, void *);
extern int repartition_key_cache(KEY_CACHE *keycache,
uint key_cache_block_size,
size_t use_mem,
uint division_limit,
uint age_threshold,
uint changed_blocks_hash_size,
uint partitions);
C_MODE_END
#endif /* _keycache_h */
PK ! tZ
Z
mariadb_capi_rename.hnu [ /* Copyright (c) 2022, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/* Renaming C API symbols inside server
* client.c defines a number of functions from the C API, that are used in replication, in number of storage engine plugins, mariadb-backup.
* That can cause a problem if a plugin loads libmariadb/libmysql or a library, that has dependency on them. The known case is ODBC driver.
* Thus the header re-names those functions for internal use.
*/
#ifndef MARIADB_CAPI_RENAME_INCLUDED
#define MARIADB_CAPI_RENAME_INCLUDED
#if !defined(EMBEDDED_LIBRARY) && !defined(MYSQL_DYNAMIC_PLUGIN)
#define MARIADB_ADD_PREFIX(_SYMBOL) server_##_SYMBOL
#define mysql_real_connect MARIADB_ADD_PREFIX(mysql_real_connect)
#define mysql_init MARIADB_ADD_PREFIX(mysql_init)
#define mysql_close MARIADB_ADD_PREFIX(mysql_close)
#define mysql_options MARIADB_ADD_PREFIX(mysql_options)
#define mysql_load_plugin MARIADB_ADD_PREFIX(mysql_load_plugin)
#define mysql_load_plugin_v MARIADB_ADD_PREFIX(mysql_load_plugin_v)
#define mysql_client_find_plugin MARIADB_ADD_PREFIX(mysql_client_find_plugin)
#define mysql_real_query MARIADB_ADD_PREFIX(mysql_real_query)
#define mysql_send_query MARIADB_ADD_PREFIX(mysql_send_query)
#define mysql_free_result MARIADB_ADD_PREFIX(mysql_free_result)
#define mysql_get_socket MARIADB_ADD_PREFIX(mysql_get_socket)
#define mysql_set_character_set MARIADB_ADD_PREFIX(mysql_set_character_set)
#define mysql_real_escape_string MARIADB_ADD_PREFIX(mysql_real_escape_string)
#define mysql_get_server_version MARIADB_ADD_PREFIX(mysql_get_server_version)
#define mysql_error MARIADB_ADD_PREFIX(mysql_error)
#define mysql_errno MARIADB_ADD_PREFIX(mysql_errno)
#define mysql_num_fields MARIADB_ADD_PREFIX(mysql_num_fields)
#define mysql_num_rows MARIADB_ADD_PREFIX(mysql_num_rows)
#define mysql_options4 MARIADB_ADD_PREFIX(mysql_options4)
#define mysql_fetch_fields MARIADB_ADD_PREFIX(mysql_fetch_fields)
#define mysql_fetch_lengths MARIADB_ADD_PREFIX(mysql_fetch_lengths)
#define mysql_fetch_row MARIADB_ADD_PREFIX(mysql_fetch_row)
#define mysql_affected_rows MARIADB_ADD_PREFIX(mysql_affected_rows)
#define mysql_store_result MARIADB_ADD_PREFIX(mysql_store_result)
#define mysql_use_result MARIADB_ADD_PREFIX(mysql_use_result)
#define mysql_select_db MARIADB_ADD_PREFIX(mysql_select_db)
#define mysql_get_ssl_cipher MARIADB_ADD_PREFIX(mysql_get_ssl_cipher)
#define mysql_ssl_set MARIADB_ADD_PREFIX(mysql_ssl_set)
#define mysql_client_register_plugin MARIADB_ADD_PREFIX(mysql_client_register_plugin)
#endif // !EMBEDDED_LIBRARY && !MYSQL_DYNAMIC_PLUGIN
#endif // !MARIADB_CAPI_RENAME_INCLUDED
PK ! &/ / my_dir.hnu [ /* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MY_DIR_H
#define MY_DIR_H
#include
#ifdef __cplusplus
extern "C" {
#endif
/* Defines for my_dir and my_stat */
#define MY_S_IFMT S_IFMT /* type of file */
#define MY_S_IFDIR S_IFDIR /* directory */
#define MY_S_IFCHR S_IFCHR /* character special */
#define MY_S_IFBLK S_IFBLK /* block special */
#define MY_S_IFREG S_IFREG /* regular */
#define MY_S_IFIFO S_IFIFO /* fifo */
#define MY_S_ISUID S_ISUID /* set user id on execution */
#define MY_S_ISGID S_ISGID /* set group id on execution */
#define MY_S_ISVTX S_ISVTX /* save swapped text even after use */
#ifndef S_IREAD
#define MY_S_IREAD S_IRUSR /* read permission, owner */
#define MY_S_IWRITE S_IWUSR /* write permission, owner */
#define MY_S_IEXEC S_IXUSR /* execute/search permission, owner */
#else
#define MY_S_IREAD S_IREAD /* read permission, owner */
#define MY_S_IWRITE S_IWRITE /* write permission, owner */
#define MY_S_IEXEC S_IEXEC /* execute/search permission, owner */
#endif
#define MY_S_ISDIR(m) (((m) & MY_S_IFMT) == MY_S_IFDIR)
#define MY_S_ISCHR(m) (((m) & MY_S_IFMT) == MY_S_IFCHR)
#define MY_S_ISBLK(m) (((m) & MY_S_IFMT) == MY_S_IFBLK)
#define MY_S_ISREG(m) (((m) & MY_S_IFMT) == MY_S_IFREG)
#define MY_S_ISFIFO(m) (((m) & MY_S_IFMT) == MY_S_IFIFO)
/* Ensure these doesn't clash with anything in my_sys.h */
#define MY_WANT_SORT 8192 /* my_lib; sort files */
#define MY_WANT_STAT 16384 /* my_lib; stat files */
#define MY_DONT_SORT 0
/* typedefs for my_dir & my_stat */
#ifdef USE_MY_STAT_STRUCT
typedef struct my_stat
{
dev_t st_dev; /* major & minor device numbers */
ino_t st_ino; /* inode number */
ushort st_mode; /* file permissions (& suid sgid .. bits) */
short st_nlink; /* number of links to file */
ushort st_uid; /* user id */
ushort st_gid; /* group id */
dev_t st_rdev; /* more major & minor device numbers (???) */
off_t st_size; /* size of file */
time_t st_atime; /* time for last read */
time_t st_mtime; /* time for last contents modify */
time_t st_ctime; /* time for last inode or contents modify */
} MY_STAT;
#else
#if defined(_MSC_VER)
#define MY_STAT struct _stati64 /* 64 bit file size */
#else
#define MY_STAT struct stat /* Original struct has what we need */
#endif
#endif /* USE_MY_STAT_STRUCT */
/* Struct describing one file returned from my_dir */
typedef struct fileinfo
{
char *name;
MY_STAT *mystat;
} FILEINFO;
typedef struct st_my_dir /* Struct returned from my_dir */
{
/*
These members are just copies of parts of DYNAMIC_ARRAY structure,
which is allocated right after the end of MY_DIR structure (MEM_ROOT
for storing names is also resides there). We've left them here because
we don't want to change code that uses my_dir.
*/
struct fileinfo *dir_entry;
size_t number_of_files;
} MY_DIR;
extern MY_DIR *my_dir(const char *path,myf MyFlags);
extern void my_dirend(MY_DIR *buffer);
extern MY_STAT *my_stat(const char *path, MY_STAT *stat_area, myf my_flags);
extern int my_fstat(int filenr, MY_STAT *stat_area, myf MyFlags);
#ifdef __cplusplus
}
#endif
#endif /* MY_DIR_H */
PK ! 7 7 my_config.hnu [ /* Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MY_CONFIG_H
#define MY_CONFIG_H
#define DOT_FRM_VERSION 6
/* Headers we may want to use. */
#define STDC_HEADERS 1
#define _GNU_SOURCE 1
#define HAVE_ALLOCA_H 1
#define HAVE_ARPA_INET_H 1
#define HAVE_ASM_TERMBITS_H 1
#define HAVE_CRYPT_H 1
#define HAVE_CURSES_H 1
/* #undef HAVE_BFD_H */
/* #undef HAVE_NDIR_H */
#define HAVE_DIRENT_H 1
#define HAVE_DLFCN_H 1
#define HAVE_EXECINFO_H 1
#define HAVE_FCNTL_H 1
#define HAVE_FENV_H 1
#define HAVE_FLOAT_H 1
#define HAVE_FNMATCH_H 1
#define HAVE_FPU_CONTROL_H 1
#define HAVE_GETMNTENT 1
/* #undef HAVE_GETMNTENT_IN_SYS_MNTAB */
/* #undef HAVE_GETMNTINFO */
/* #undef HAVE_GETMNTINFO64 */
/* #undef HAVE_GETMNTINFO_TAKES_statvfs */
#define HAVE_GRP_H 1
/* #undef HAVE_IA64INTRIN_H */
/* #undef HAVE_IEEEFP_H */
#define HAVE_INTTYPES_H 1
/* #undef HAVE_KQUEUE */
#define HAVE_LIMITS_H 1
#define HAVE_LINK_H 1
#define HAVE_LINUX_UNISTD_H 1
#define HAVE_LINUX_MMAN_H 1
#define HAVE_LOCALE_H 1
#define HAVE_MALLOC_H 1
#define HAVE_MEMORY_H 1
#define HAVE_NETINET_IN_H 1
#define HAVE_PATHS_H 1
#define HAVE_POLL_H 1
#define HAVE_PWD_H 1
#define HAVE_SCHED_H 1
/* #undef HAVE_SELECT_H */
/* #undef HAVE_SOLARIS_LARGE_PAGES */
#define HAVE_STDDEF_H 1
#define HAVE_STDLIB_H 1
#define HAVE_STDARG_H 1
#define HAVE_STRINGS_H 1
#define HAVE_STRING_H 1
#define HAVE_STDINT_H 1
/* #undef HAVE_SYNCH_H */
/* #undef HAVE_SYSENT_H */
#define HAVE_SYS_DIR_H 1
#define HAVE_SYS_FILE_H 1
/* #undef HAVE_SYS_FPU_H */
#define HAVE_SYS_IOCTL_H 1
/* #undef HAVE_SYS_MALLOC_H */
#define HAVE_SYS_MMAN_H 1
/* #undef HAVE_SYS_MNTENT_H */
/* #undef HAVE_SYS_NDIR_H */
/* #undef HAVE_SYS_PTE_H */
/* #undef HAVE_SYS_PTEM_H */
#define HAVE_SYS_PRCTL_H 1
#define HAVE_SYS_RESOURCE_H 1
#define HAVE_SYS_SELECT_H 1
#define HAVE_SYS_SOCKET_H 1
/* #undef HAVE_SYS_SOCKIO_H */
#define HAVE_SYS_UTSNAME_H 1
#define HAVE_SYS_STAT_H 1
/* #undef HAVE_SYS_STREAM_H */
#define HAVE_SYS_SYSCALL_H 1
#define HAVE_SYS_TIMEB_H 1
#define HAVE_SYS_TIMES_H 1
#define HAVE_SYS_TIME_H 1
#define HAVE_SYS_TYPES_H 1
#define HAVE_SYS_UN_H 1
/* #undef HAVE_SYS_VADVISE_H */
#define HAVE_SYS_STATVFS_H 1
#define HAVE_UCONTEXT_H 1
#define HAVE_TERM_H 1
/* #undef HAVE_TERMBITS_H */
#define HAVE_TERMIOS_H 1
#define HAVE_TERMIO_H 1
#define HAVE_TERMCAP_H 1
#define HAVE_TIME_H 1
#define HAVE_UNISTD_H 1
#define HAVE_UTIME_H 1
/* #undef HAVE_VARARGS_H */
/* #undef HAVE_SYS_UTIME_H */
#define HAVE_SYS_WAIT_H 1
#define HAVE_SYS_PARAM_H 1
/* Libraries */
/* #undef HAVE_LIBWRAP */
#define HAVE_SYSTEMD 1
#define HAVE_SYSTEMD_SD_LISTEN_FDS_WITH_NAMES 1
/* Does "struct timespec" have a "sec" and "nsec" field? */
/* #undef HAVE_TIMESPEC_TS_SEC */
/* Readline */
/* #undef HAVE_HIST_ENTRY */
/* #undef USE_LIBEDIT_INTERFACE */
#define USE_NEW_READLINE_INTERFACE 1
#define FIONREAD_IN_SYS_IOCTL 1
#define GWINSZ_IN_SYS_IOCTL 1
/* #undef TIOCSTAT_IN_SYS_IOCTL */
/* #undef FIONREAD_IN_SYS_FILIO */
/* Functions we may want to use. */
#define HAVE_ACCEPT4 1
#define HAVE_ACCESS 1
#define HAVE_ALLOCA 1
/* #undef HAVE_BFILL */
#define HAVE_INDEX 1
#define HAVE_CLOCK_GETTIME 1
#define HAVE_CRYPT 1
#define HAVE_CUSERID 1
#define HAVE_DLADDR 1
#define HAVE_DLERROR 1
#define HAVE_DLOPEN 1
#define HAVE_FCHMOD 1
#define HAVE_FCNTL 1
#define HAVE_FDATASYNC 1
#define HAVE_DECL_FDATASYNC 1
#define HAVE_FEDISABLEEXCEPT 1
#define HAVE_FESETROUND 1
/* #undef HAVE_FP_EXCEPT */
#define HAVE_FSEEKO 1
#define HAVE_FSYNC 1
#define HAVE_FTIME 1
#define HAVE_GETIFADDRS 1
#define HAVE_GETCWD 1
#define HAVE_GETHOSTBYADDR_R 1
/* #undef HAVE_GETHRTIME */
/* #undef HAVE_GETPAGESIZES */
#define HAVE_GETPASS 1
/* #undef HAVE_GETPASSPHRASE */
#define HAVE_GETPWNAM 1
#define HAVE_GETPWUID 1
#define HAVE_GETRLIMIT 1
#define HAVE_GETRUSAGE 1
#define HAVE_GETTIMEOFDAY 1
#define HAVE_GETWD 1
#define HAVE_GMTIME_R 1
/* #undef gmtime_r */
#define HAVE_IN_ADDR_T 1
#define HAVE_INITGROUPS 1
#define HAVE_LDIV 1
#define HAVE_LRAND48 1
#define HAVE_LOCALTIME_R 1
#define HAVE_LSTAT 1
/* #define HAVE_MLOCK 1 see Bug#54662 */
#define HAVE_NL_LANGINFO 1
#define HAVE_MADVISE 1
#define HAVE_DECL_MADVISE 1
/* #undef HAVE_DECL_MHA_MAPSIZE_VA */
#define HAVE_MALLINFO 1
/* #undef HAVE_MALLINFO2 */
/* #undef HAVE_MALLOC_ZONE */
#define HAVE_MEMCPY 1
#define HAVE_MEMMOVE 1
#define HAVE_MKSTEMP 1
#define HAVE_MKOSTEMP 1
#define HAVE_MLOCKALL 1
#define HAVE_MMAP 1
#define HAVE_MMAP64 1
#define HAVE_MPROTECT 1
#define HAVE_PERROR 1
#define HAVE_POLL 1
#define HAVE_POSIX_FALLOCATE 1
#define HAVE_FALLOC_PUNCH_HOLE_AND_KEEP_SIZE 1
#define HAVE_PREAD 1
/* #undef HAVE_READ_REAL_TIME */
/* #undef HAVE_PTHREAD_ATTR_CREATE */
#define HAVE_PTHREAD_ATTR_GETGUARDSIZE 1
#define HAVE_PTHREAD_ATTR_GETSTACKSIZE 1
#define HAVE_PTHREAD_ATTR_SETSCOPE 1
#define HAVE_PTHREAD_ATTR_SETSTACKSIZE 1
#define HAVE_PTHREAD_GETATTR_NP 1
/* #undef HAVE_PTHREAD_CONDATTR_CREATE */
#define HAVE_PTHREAD_GETAFFINITY_NP 1
#define HAVE_PTHREAD_KEY_DELETE 1
/* #undef HAVE_PTHREAD_KILL */
#define HAVE_PTHREAD_RWLOCK_RDLOCK 1
#define HAVE_PTHREAD_SIGMASK 1
/* #undef HAVE_PTHREAD_YIELD_NP */
#define HAVE_PTHREAD_YIELD_ZERO_ARG 1
#define PTHREAD_ONCE_INITIALIZER PTHREAD_ONCE_INIT
#define HAVE_PUTENV 1
/* #undef HAVE_READDIR_R */
#define HAVE_READLINK 1
#define HAVE_REALPATH 1
#define HAVE_RENAME 1
/* #undef HAVE_RWLOCK_INIT */
#define HAVE_SCHED_YIELD 1
#define HAVE_SELECT 1
#define HAVE_SETENV 1
#define HAVE_SETLOCALE 1
#define HAVE_SETMNTENT 1
#define HAVE_SETUPTERM 1
#define HAVE_SIGSET 1
#define HAVE_SIGACTION 1
/* #undef HAVE_SIGTHREADMASK */
#define HAVE_SIGWAIT 1
#define HAVE_SIGWAITINFO 1
#define HAVE_SLEEP 1
#define HAVE_STPCPY 1
#define HAVE_STRERROR 1
#define HAVE_STRCOLL 1
#define HAVE_STRNLEN 1
#define HAVE_STRPBRK 1
#define HAVE_STRTOK_R 1
#define HAVE_STRTOLL 1
#define HAVE_STRTOUL 1
#define HAVE_STRTOULL 1
/* #undef HAVE_TELL */
/* #undef HAVE_THR_YIELD */
#define HAVE_TIME 1
#define HAVE_TIMES 1
#define HAVE_VIDATTR 1
#define HAVE_VIO_READ_BUFF 1
#define HAVE_VASPRINTF 1
#define HAVE_VSNPRINTF 1
#define HAVE_FTRUNCATE 1
#define HAVE_TZNAME 1
/* Symbols we may use */
/* #undef HAVE_SYS_ERRLIST */
/* used by stacktrace functions */
#define HAVE_BACKTRACE 1
#define HAVE_BACKTRACE_SYMBOLS 1
#define HAVE_BACKTRACE_SYMBOLS_FD 1
/* #undef HAVE_PRINTSTACK */
#define HAVE_IPV6 1
/* #undef ss_family */
/* #undef HAVE_SOCKADDR_IN_SIN_LEN */
/* #undef HAVE_SOCKADDR_IN6_SIN6_LEN */
#define STRUCT_TIMESPEC_HAS_TV_SEC 1
#define STRUCT_TIMESPEC_HAS_TV_NSEC 1
#define STRUCT_TM_HAS_TM_GMTOFF 1
/* this means that valgrind headers and macros are available */
/* #undef HAVE_VALGRIND_MEMCHECK_H */
/* this means WITH_VALGRIND - we change some code paths for valgrind */
/* #undef HAVE_valgrind */
/* Types we may use */
#ifdef __APPLE__
/*
Special handling required for OSX to support universal binaries that
mix 32 and 64 bit architectures.
*/
#if(__LP64__)
#define SIZEOF_LONG 8
#else
#define SIZEOF_LONG 4
#endif
#define SIZEOF_VOIDP SIZEOF_LONG
#define SIZEOF_CHARP SIZEOF_LONG
#define SIZEOF_SIZE_T SIZEOF_LONG
#else
/* No indentation, to fetch the lines from verification scripts */
#define SIZEOF_LONG 8
#define SIZEOF_VOIDP 8
#define SIZEOF_CHARP 8
#define SIZEOF_SIZE_T 8
#endif
#define HAVE_LONG 1
#define HAVE_CHARP 1
#define SIZEOF_INT 4
#define HAVE_INT 1
#define SIZEOF_LONG_LONG 8
#define HAVE_LONG_LONG 1
#define SIZEOF_OFF_T 8
#define HAVE_OFF_T 1
/* #undef SIZEOF_UCHAR */
/* #undef HAVE_UCHAR */
#define SIZEOF_UINT 4
#define HAVE_UINT 1
#define SIZEOF_ULONG 8
#define HAVE_ULONG 1
/* #undef SIZEOF_INT8 */
/* #undef HAVE_INT8 */
/* #undef SIZEOF_UINT8 */
/* #undef HAVE_UINT8 */
/* #undef SIZEOF_INT16 */
/* #undef HAVE_INT16 */
/* #undef SIZEOF_UINT16 */
/* #undef HAVE_UINT16 */
/* #undef SIZEOF_INT32 */
/* #undef HAVE_INT32 */
/* #undef SIZEOF_UINT32 */
/* #undef HAVE_UINT32 */
/* #undef SIZEOF_INT64 */
/* #undef HAVE_INT64 */
/* #undef SIZEOF_UINT64 */
/* #undef HAVE_UINT64 */
#define SOCKET_SIZE_TYPE socklen_t
#define HAVE_MBSTATE_T 1
#define MAX_INDEXES 64
#define QSORT_TYPE_IS_VOID 1
#define RETQSORTTYPE void
#define RETSIGTYPE void
#define VOID_SIGHANDLER 1
#define HAVE_SIGHANDLER_T 1
#define STRUCT_RLIMIT struct rlimit
#ifdef __APPLE__
#if __BIG_ENDIAN
#define WORDS_BIGENDIAN 1
#endif
#else
/* #undef WORDS_BIGENDIAN */
#endif
/* Define to `__inline__' or `__inline' if that's what the C compiler calls
it, or to nothing if 'inline' is not supported under any name. */
#define C_HAS_inline 1
#if !(C_HAS_inline)
#ifndef __cplusplus
# define inline
#endif
#endif
#define TARGET_OS_LINUX 1
#define HAVE_WCTYPE_H 1
#define HAVE_WCHAR_H 1
#define HAVE_LANGINFO_H 1
#define HAVE_MBRLEN 1
#define HAVE_MBSRTOWCS 1
#define HAVE_MBRTOWC 1
#define HAVE_WCWIDTH 1
#define HAVE_ISWLOWER 1
#define HAVE_ISWUPPER 1
#define HAVE_TOWLOWER 1
#define HAVE_TOWUPPER 1
#define HAVE_ISWCTYPE 1
#define HAVE_WCHAR_T 1
#define HAVE_STRCASECMP 1
#define HAVE_TCGETATTR 1
#define HAVE_WEAK_SYMBOL 1
#define HAVE_ABI_CXA_DEMANGLE 1
#define HAVE_ATTRIBUTE_CLEANUP 1
#define HAVE_POSIX_SIGNALS 1
/* #undef HAVE_BSD_SIGNALS */
/* #undef HAVE_SVR3_SIGNALS */
/* #undef HAVE_V7_SIGNALS */
#define HAVE_ERR_remove_thread_state 1
/* #undef HAVE_X509_check_host */
/* #undef HAVE_SOLARIS_STYLE_GETHOST */
#define HAVE_GCC_C11_ATOMICS 1
/* #undef HAVE_SOLARIS_ATOMIC */
/* #undef NO_FCNTL_NONBLOCK */
/* #undef _LARGE_FILES */
#define _LARGEFILE_SOURCE 1
/* #undef _LARGEFILE64_SOURCE */
#define TIME_WITH_SYS_TIME 1
#define STACK_DIRECTION -1
#define SYSTEM_TYPE "Linux"
#define MACHINE_TYPE "x86_64"
#define DEFAULT_MACHINE "x86_64"
#define HAVE_DTRACE 1
#define SIGNAL_WITH_VIO_CLOSE 1
/* Windows stuff, mostly functions, that have Posix analogs but named differently */
#ifdef _WIN32
#define S_IROTH _S_IREAD
#define S_IFIFO _S_IFIFO
#define SIGQUIT SIGTERM
#define SIGPIPE SIGINT
#define sigset_t int
#define mode_t int
#define popen _popen
#define pclose _pclose
#define ssize_t SSIZE_T
#define strcasecmp _stricmp
#define strncasecmp _strnicmp
#define strtok_r strtok_s
#define tzname _tzname
#define P_tmpdir "C:\\TEMP"
#define setenv(a,b,c) _putenv_s(a,b)
#define HAVE_SETENV
#define NOMINMAX 1
#define PSAPI_VERSION 2 /* for GetProcessMemoryInfo() */
#endif /* _WIN32 */
/*
MySQL features
*/
#define LOCAL_INFILE_MODE_OFF 0
#define LOCAL_INFILE_MODE_ON 1
#define LOCAL_INFILE_MODE_AUTO 2
#define ENABLED_LOCAL_INFILE LOCAL_INFILE_MODE_AUTO
#define ENABLED_PROFILING 1
/* #undef EXTRA_DEBUG */
/* #undef USE_SYMDIR */
/* Character sets and collations */
#define MYSQL_DEFAULT_CHARSET_NAME "latin1"
#define MYSQL_DEFAULT_COLLATION_NAME "latin1_swedish_ci"
#define USE_MB
#define USE_MB_IDENT
/* This should mean case insensitive file system */
/* #undef FN_NO_CASE_SENSE */
#define HAVE_CHARSET_armscii8 1
#define HAVE_CHARSET_ascii 1
#define HAVE_CHARSET_big5 1
#define HAVE_CHARSET_cp1250 1
#define HAVE_CHARSET_cp1251 1
#define HAVE_CHARSET_cp1256 1
#define HAVE_CHARSET_cp1257 1
#define HAVE_CHARSET_cp850 1
#define HAVE_CHARSET_cp852 1
#define HAVE_CHARSET_cp866 1
#define HAVE_CHARSET_cp932 1
#define HAVE_CHARSET_dec8 1
#define HAVE_CHARSET_eucjpms 1
#define HAVE_CHARSET_euckr 1
#define HAVE_CHARSET_gb2312 1
#define HAVE_CHARSET_gbk 1
#define HAVE_CHARSET_geostd8 1
#define HAVE_CHARSET_greek 1
#define HAVE_CHARSET_hebrew 1
#define HAVE_CHARSET_hp8 1
#define HAVE_CHARSET_keybcs2 1
#define HAVE_CHARSET_koi8r 1
#define HAVE_CHARSET_koi8u 1
#define HAVE_CHARSET_latin1 1
#define HAVE_CHARSET_latin2 1
#define HAVE_CHARSET_latin5 1
#define HAVE_CHARSET_latin7 1
#define HAVE_CHARSET_macce 1
#define HAVE_CHARSET_macroman 1
#define HAVE_CHARSET_sjis 1
#define HAVE_CHARSET_swe7 1
#define HAVE_CHARSET_tis620 1
#define HAVE_CHARSET_ucs2 1
#define HAVE_CHARSET_ujis 1
#define HAVE_CHARSET_utf8mb4 1
#define HAVE_CHARSET_utf8mb3 1
#define HAVE_CHARSET_utf16 1
#define HAVE_CHARSET_utf32 1
#define HAVE_UCA_COLLATIONS 1
#define HAVE_COMPRESS 1
#define HAVE_EncryptAes128Ctr 1
#define HAVE_EncryptAes128Gcm 1
#define HAVE_des 1
#define HAVE_hkdf 1
/*
Stuff that always need to be defined (compile breaks without it)
*/
#define HAVE_SPATIAL 1
#define HAVE_RTREE_KEYS 1
#define HAVE_QUERY_CACHE 1
#define BIG_TABLES 1
/*
Important storage engines (those that really need define
WITH__STORAGE_ENGINE for the whole server)
*/
#define WITH_INNOBASE_STORAGE_ENGINE 1
#define WITH_PARTITION_STORAGE_ENGINE 1
#define WITH_PERFSCHEMA_STORAGE_ENGINE 1
#define WITH_ARIA_STORAGE_ENGINE 1
#define USE_ARIA_FOR_TMP_TABLES 1
#define DEFAULT_MYSQL_HOME "/usr"
#define SHAREDIR "/usr/share/mariadb"
#define DEFAULT_BASEDIR "/usr"
#define MYSQL_DATADIR "/var/lib/mysql"
#define DEFAULT_CHARSET_HOME "/usr"
#define PLUGINDIR "/usr/lib64/mysql/plugin"
#define DEFAULT_SYSCONFDIR "/etc"
#define DEFAULT_TMPDIR P_tmpdir
/* #undef SO_EXT */
#define MYSQL_VERSION_MAJOR 11
#define MYSQL_VERSION_MINOR 4
#define MYSQL_VERSION_PATCH 12
#define MYSQL_VERSION_EXTRA ""
#define PACKAGE "mysql"
#define PACKAGE_BUGREPORT ""
#define PACKAGE_NAME "MySQL Server"
#define PACKAGE_STRING "MySQL Server 11.4.12"
#define PACKAGE_TARNAME "mysql"
#define PACKAGE_VERSION "11.4.12"
#define VERSION "11.4.12"
#define PROTOCOL_VERSION 10
#define PCRE2_CODE_UNIT_WIDTH 8
#define MALLOC_LIBRARY "system"
/* time_t related defines */
#define SIZEOF_TIME_T 8
/* #undef TIME_T_UNSIGNED */
#ifndef EMBEDDED_LIBRARY
/* #undef WSREP_INTERFACE_VERSION */
#define WITH_WSREP 1
#endif
#if !defined(__STDC_FORMAT_MACROS)
#define __STDC_FORMAT_MACROS
#endif // !defined(__STDC_FORMAT_MACROS)
#endif
#define HAVE_VFORK 1
PK ! w5v 5v mysql_com.hnu [ /* Copyright (c) 2000, 2011, Oracle and/or its affiliates.
Copyright (c) 2010, 2017, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/*
** Common definition between mysql server & client
*/
#ifndef _mysql_com_h
#define _mysql_com_h
#include "my_decimal_limits.h"
#define HOSTNAME_LENGTH 255
#define HOSTNAME_LENGTH_STR STRINGIFY_ARG(HOSTNAME_LENGTH)
#define SYSTEM_CHARSET_MBMAXLEN 3
#define NAME_CHAR_LEN 64 /* Field/table name length */
#define USERNAME_CHAR_LENGTH 128
#define USERNAME_CHAR_LENGTH_STR STRINGIFY_ARG(USERNAME_CHAR_LENGTH)
#define NAME_LEN (NAME_CHAR_LEN*SYSTEM_CHARSET_MBMAXLEN)
#define USERNAME_LENGTH (USERNAME_CHAR_LENGTH*SYSTEM_CHARSET_MBMAXLEN)
#define DEFINER_CHAR_LENGTH (USERNAME_CHAR_LENGTH + HOSTNAME_LENGTH + 1)
#define DEFINER_LENGTH (USERNAME_LENGTH + HOSTNAME_LENGTH + 1)
#define MYSQL_AUTODETECT_CHARSET_NAME "auto"
#define MYSQL50_TABLE_NAME_PREFIX "#mysql50#"
#define MYSQL50_TABLE_NAME_PREFIX_LENGTH (sizeof(MYSQL50_TABLE_NAME_PREFIX)-1)
#define SAFE_NAME_LEN (NAME_LEN + MYSQL50_TABLE_NAME_PREFIX_LENGTH)
#define SERVER_VERSION_LENGTH 60
#define SQLSTATE_LENGTH 5
#define LIST_PROCESS_HOST_LEN 64
/*
Maximum length of comments
*/
#define TABLE_COMMENT_INLINE_MAXLEN 180 /* pre 5.5: 60 characters */
#define TABLE_COMMENT_MAXLEN 2048
#define COLUMN_COMMENT_MAXLEN 1024
#define INDEX_COMMENT_MAXLEN 1024
#define TABLE_PARTITION_COMMENT_MAXLEN 1024
#define DATABASE_COMMENT_MAXLEN 1024
/*
Maximum length of protocol packet.
OK packet length limit also restricted to this value as any length greater
than this value will have first byte of OK packet to be 254 thus does not
provide a means to identify if this is OK or EOF packet.
*/
#define MAX_PACKET_LENGTH (256L*256L*256L-1)
/*
USER_HOST_BUFF_SIZE -- length of string buffer, that is enough to contain
username and hostname parts of the user identifier with trailing zero in
MySQL standard format:
user_name_part@host_name_part\0
*/
#define USER_HOST_BUFF_SIZE HOSTNAME_LENGTH + USERNAME_LENGTH + 2
#define LOCAL_HOST "localhost"
#define LOCAL_HOST_NAMEDPIPE "."
#if defined(_WIN32) && !defined( _CUSTOMCONFIG_)
#define MYSQL_NAMEDPIPE "MySQL"
#define MYSQL_SERVICENAME "MySQL"
#endif
/*
You should add new commands to the end of this list, otherwise old
servers won't be able to handle them as 'unsupported'.
*/
enum enum_server_command
{
COM_SLEEP, COM_QUIT, COM_INIT_DB, COM_QUERY, COM_FIELD_LIST,
COM_CREATE_DB, COM_DROP_DB, COM_REFRESH, COM_SHUTDOWN, COM_STATISTICS,
COM_PROCESS_INFO, COM_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING,
COM_TIME, COM_DELAYED_INSERT, COM_CHANGE_USER, COM_BINLOG_DUMP,
COM_TABLE_DUMP, COM_CONNECT_OUT, COM_REGISTER_SLAVE,
COM_STMT_PREPARE, COM_STMT_EXECUTE, COM_STMT_SEND_LONG_DATA, COM_STMT_CLOSE,
COM_STMT_RESET, COM_SET_OPTION, COM_STMT_FETCH, COM_DAEMON,
COM_UNIMPLEMENTED, /* COM_BINLOG_DUMP_GTID in MySQL */
COM_RESET_CONNECTION,
/* don't forget to update const char *command_name[] in sql_parse.cc */
COM_MDB_GAP_BEG,
COM_MDB_GAP_END=249,
COM_STMT_BULK_EXECUTE=250,
COM_SLAVE_WORKER=251,
COM_SLAVE_IO=252,
COM_SLAVE_SQL=253,
COM_RESERVED_1=254, /* Old COM_MULTI, now removed */
/* Must be last */
COM_END=255
};
/*
Bulk PS protocol indicator value:
*/
enum enum_indicator_type
{
STMT_INDICATOR_NONE= 0,
STMT_INDICATOR_NULL,
STMT_INDICATOR_DEFAULT,
STMT_INDICATOR_IGNORE
};
/*
bulk PS flags
*/
#define STMT_BULK_FLAG_CLIENT_SEND_TYPES 128
#define STMT_BULK_FLAG_INSERT_ID_REQUEST 64
/* sql type stored in .frm files for virtual fields */
#define MYSQL_TYPE_VIRTUAL 245
/*
Length of random string sent by server on handshake; this is also length of
obfuscated password, received from client
*/
#define SCRAMBLE_LENGTH 20
#define SCRAMBLE_LENGTH_323 8
/* length of password stored in the db: new passwords are preceded with '*' */
#define SCRAMBLED_PASSWORD_CHAR_LENGTH (SCRAMBLE_LENGTH*2+1)
#define SCRAMBLED_PASSWORD_CHAR_LENGTH_323 (SCRAMBLE_LENGTH_323*2)
#define NOT_NULL_FLAG 1U /* Field can't be NULL */
#define PRI_KEY_FLAG 2U /* Field is part of a primary key */
#define UNIQUE_KEY_FLAG 4U /* Field is part of a unique key */
#define MULTIPLE_KEY_FLAG 8U /* Field is part of a key */
#define BLOB_FLAG 16U /* Field is a blob */
#define UNSIGNED_FLAG 32U /* Field is unsigned */
#define ZEROFILL_FLAG 64U /* Field is zerofill */
#define BINARY_FLAG 128U /* Field is binary */
/* The following are only sent to new clients */
#define ENUM_FLAG 256U /* field is an enum */
#define AUTO_INCREMENT_FLAG 512U /* field is a autoincrement field */
#define TIMESTAMP_FLAG 1024U /* Field is a timestamp */
#define SET_FLAG 2048U /* field is a set */
#define NO_DEFAULT_VALUE_FLAG 4096U /* Field doesn't have default value */
#define ON_UPDATE_NOW_FLAG 8192U /* Field is set to NOW on UPDATE */
#define NUM_FLAG 32768U /* Field is num (for clients) */
#define PART_KEY_FLAG 16384U /* Intern; Part of some key */
#define GROUP_FLAG 32768U /* Intern: Group field */
#define CONTEXT_COLLATION_FLAG 131072U /* Intern: Used by sql_yacc */
#define GET_FIXED_FIELDS_FLAG (1U << 18) /* Used to get fields in item tree */
#define FIELD_IN_PART_FUNC_FLAG (1U << 19)/* Field part of partition func */
#define PART_INDIRECT_KEY_FLAG (1U << 20)
/**
Intern: Field in TABLE object for new version of altered table,
which participates in a newly added index.
*/
#define FIELD_IN_ADD_INDEX (1U << 20)
#define FIELD_IS_RENAMED (1U << 21) /* Intern: Field is being renamed */
#define FIELD_FLAGS_STORAGE_MEDIA 22 /* Field storage media, bit 22-23 */
#define FIELD_FLAGS_STORAGE_MEDIA_MASK (3U << FIELD_FLAGS_STORAGE_MEDIA)
#define FIELD_FLAGS_COLUMN_FORMAT 24 /* Field column format, bit 24-25 */
#define FIELD_FLAGS_COLUMN_FORMAT_MASK (3U << FIELD_FLAGS_COLUMN_FORMAT)
#define FIELD_IS_DROPPED (1U << 26) /* Intern: Field is being dropped */
#define VERS_ROW_START (1 << 27) /* autogenerated column declared with
`generated always as row start`
(see II.a SQL Standard) */
#define VERS_ROW_END (1 << 28) /* autogenerated column declared with
`generated always as row end`
(see II.a SQL Standard).*/
#define VERS_SYSTEM_FIELD (VERS_ROW_START | VERS_ROW_END)
#define VERS_UPDATE_UNVERSIONED_FLAG (1 << 29) /* column that doesn't support
system versioning when table
itself supports it*/
#define LONG_UNIQUE_HASH_FIELD (1<< 30) /* This field will store hash for unique
column */
#define FIELD_PART_OF_TMP_UNIQUE (1<< 31) /* part of an unique constrain
for a tmporary table*/
#define REFRESH_GRANT (1ULL << 0) /* Refresh grant tables */
#define REFRESH_LOG (1ULL << 1) /* Start on new log file */
#define REFRESH_TABLES (1ULL << 2) /* close all tables */
#define REFRESH_HOSTS (1ULL << 3) /* Flush host cache */
#define REFRESH_STATUS (1ULL << 4) /* Flush status variables */
#define REFRESH_THREADS (1ULL << 5) /* Flush thread cache */
#define REFRESH_SLAVE (1ULL << 6) /* Reset master info and restart slave
thread */
#define REFRESH_MASTER (1ULL << 7) /* Remove all bin logs in the index
and truncate the index */
/* The following can't be set with mysql_refresh() */
#define REFRESH_ERROR_LOG (1ULL << 8) /* Rotate only the error log */
#define REFRESH_ENGINE_LOG (1ULL << 9) /* Flush all storage engine logs */
#define REFRESH_BINARY_LOG (1ULL << 10) /* Flush the binary log */
#define REFRESH_RELAY_LOG (1ULL << 11) /* Flush the relay log */
#define REFRESH_GENERAL_LOG (1ULL << 12) /* Flush the general log */
#define REFRESH_SLOW_LOG (1ULL << 13) /* Flush the slow query log */
#define REFRESH_READ_LOCK (1ULL << 14) /* Lock tables for read */
#define REFRESH_CHECKPOINT (1ULL << 15) /* With REFRESH_READ_LOCK: block checkpoints too */
#define REFRESH_QUERY_CACHE (1ULL << 16) /* clear the query cache */
#define REFRESH_QUERY_CACHE_FREE (1ULL << 17) /* pack query cache */
#define REFRESH_DES_KEY_FILE (1ULL << 18)
#define REFRESH_USER_RESOURCES (1ULL << 19)
#define REFRESH_FOR_EXPORT (1ULL << 20) /* FLUSH TABLES ... FOR EXPORT */
#define REFRESH_SSL (1ULL << 21)
#define REFRESH_GENERIC (1ULL << 30)
#define REFRESH_FAST (1ULL << 31) /* Intern flag */
#define CLIENT_LONG_PASSWORD 0 /* obsolete flag */
#define CLIENT_MYSQL 1ULL /* mysql/old mariadb server/client */
#define CLIENT_FOUND_ROWS 2ULL /* Found instead of affected rows */
#define CLIENT_LONG_FLAG 4ULL /* Get all column flags */
#define CLIENT_CONNECT_WITH_DB 8ULL /* One can specify db on connect */
#define CLIENT_NO_SCHEMA 16ULL /* Don't allow database.table.column */
#define CLIENT_COMPRESS 32ULL /* Can use compression protocol */
#define CLIENT_ODBC 64ULL /* Odbc client */
#define CLIENT_LOCAL_FILES 128ULL /* Can use LOAD DATA LOCAL */
#define CLIENT_IGNORE_SPACE 256ULL /* Ignore spaces before '(' */
#define CLIENT_PROTOCOL_41 512ULL /* New 4.1 protocol */
#define CLIENT_INTERACTIVE 1024ULL /* This is an interactive client */
#define CLIENT_SSL 2048ULL /* Switch to SSL after handshake */
#define CLIENT_IGNORE_SIGPIPE 4096ULL /* IGNORE sigpipes */
#define CLIENT_TRANSACTIONS 8192ULL /* Client knows about transactions */
#define CLIENT_RESERVED 16384ULL /* Old flag for 4.1 protocol */
#define CLIENT_SECURE_CONNECTION 32768ULL /* New 4.1 authentication */
#define CLIENT_MULTI_STATEMENTS (1ULL << 16) /* Enable/disable multi-stmt support */
#define CLIENT_MULTI_RESULTS (1ULL << 17) /* Enable/disable multi-results */
#define CLIENT_PS_MULTI_RESULTS (1ULL << 18) /* Multi-results in PS-protocol */
#define CLIENT_PLUGIN_AUTH (1ULL << 19) /* Client supports plugin authentication */
#define CLIENT_CONNECT_ATTRS (1ULL << 20) /* Client supports connection attributes */
/* Enable authentication response packet to be larger than 255 bytes. */
#define CLIENT_PLUGIN_AUTH_LENENC_CLIENT_DATA (1ULL << 21)
/* Don't close the connection for a connection with expired password. */
#define CLIENT_CAN_HANDLE_EXPIRED_PASSWORDS (1ULL << 22)
/**
Capable of handling server state change information. Its a hint to the
server to include the state change information in Ok packet.
*/
#define CLIENT_SESSION_TRACK (1ULL << 23)
/* Client no longer needs EOF packet */
#define CLIENT_DEPRECATE_EOF (1ULL << 24)
#define CLIENT_PROGRESS_OBSOLETE (1ULL << 29)
#define CLIENT_SSL_VERIFY_SERVER_CERT_OBSOLETE (1ULL << 30)
/*
It used to be that if mysql_real_connect() failed, it would delete any
options set by the client, unless the CLIENT_REMEMBER_OPTIONS flag was
given.
That behaviour does not appear very useful, and it seems unlikely that
any applications would actually depend on this. So from MariaDB 5.5 we
always preserve any options set in case of failed connect, and this
option is effectively always set.
*/
#define CLIENT_REMEMBER_OPTIONS (1ULL << 31)
/* MariaDB extended capability flags */
#define MARIADB_CLIENT_FLAGS_MASK 0xffffffff00000000ULL
/* Client support progress indicator */
#define MARIADB_CLIENT_PROGRESS (1ULL << 32)
/* Old COM_MULTI experiment (functionality removed).*/
#define MARIADB_CLIENT_RESERVED_1 (1ULL << 33)
/* support of array binding */
#define MARIADB_CLIENT_STMT_BULK_OPERATIONS (1ULL << 34)
/* support of extended metadata (e.g. type/format information) */
#define MARIADB_CLIENT_EXTENDED_METADATA (1ULL << 35)
/* Do not resend metadata for prepared statements, since 10.6*/
#define MARIADB_CLIENT_CACHE_METADATA (1ULL << 36)
#ifdef HAVE_COMPRESS
#define CAN_CLIENT_COMPRESS CLIENT_COMPRESS
#else
#define CAN_CLIENT_COMPRESS 0
#endif
/*
Gather all possible capabilities (flags) supported by the server
MARIADB_* flags supported only by MariaDB connector(s).
*/
#define CLIENT_ALL_FLAGS (\
CLIENT_FOUND_ROWS | \
CLIENT_LONG_FLAG | \
CLIENT_CONNECT_WITH_DB | \
CLIENT_NO_SCHEMA | \
CLIENT_COMPRESS | \
CLIENT_ODBC | \
CLIENT_LOCAL_FILES | \
CLIENT_IGNORE_SPACE | \
CLIENT_PROTOCOL_41 | \
CLIENT_INTERACTIVE | \
CLIENT_SSL | \
CLIENT_IGNORE_SIGPIPE | \
CLIENT_TRANSACTIONS | \
CLIENT_RESERVED | \
CLIENT_SECURE_CONNECTION | \
CLIENT_MULTI_STATEMENTS | \
CLIENT_MULTI_RESULTS | \
CLIENT_PS_MULTI_RESULTS | \
CLIENT_REMEMBER_OPTIONS | \
MARIADB_CLIENT_PROGRESS | \
CLIENT_PLUGIN_AUTH | \
CLIENT_PLUGIN_AUTH_LENENC_CLIENT_DATA | \
CLIENT_SESSION_TRACK |\
CLIENT_DEPRECATE_EOF |\
CLIENT_CONNECT_ATTRS |\
MARIADB_CLIENT_STMT_BULK_OPERATIONS |\
MARIADB_CLIENT_EXTENDED_METADATA|\
MARIADB_CLIENT_CACHE_METADATA |\
CLIENT_CAN_HANDLE_EXPIRED_PASSWORDS)
/*
Switch off the flags that are optional and depending on build flags
If any of the optional flags is supported by the build it will be switched
on before sending to the client during the connection handshake.
*/
#define CLIENT_BASIC_FLAGS ((CLIENT_ALL_FLAGS & ~CLIENT_SSL) \
& ~CLIENT_COMPRESS)
enum mariadb_field_attr_t
{
MARIADB_FIELD_ATTR_DATA_TYPE_NAME= 0,
MARIADB_FIELD_ATTR_FORMAT_NAME= 1
};
#define MARIADB_FIELD_ATTR_LAST MARIADB_FIELD_ATTR_FORMAT_NAME
/**
Is raised when a multi-statement transaction
has been started, either explicitly, by means
of BEGIN or COMMIT AND CHAIN, or
implicitly, by the first transactional
statement, when autocommit=off.
*/
#define SERVER_STATUS_IN_TRANS 1U
#define SERVER_STATUS_AUTOCOMMIT 2U /* Server in auto_commit mode */
#define SERVER_MORE_RESULTS_EXISTS 8U /* Multi query - next query exists */
#define SERVER_QUERY_NO_GOOD_INDEX_USED 16U
#define SERVER_QUERY_NO_INDEX_USED 32U
/**
The server was able to fulfill the clients request and opened a
read-only non-scrollable cursor for a query. This flag comes
in reply to COM_STMT_EXECUTE and COM_STMT_FETCH commands.
*/
#define SERVER_STATUS_CURSOR_EXISTS 64U
/**
This flag is sent when a read-only cursor is exhausted, in reply to
COM_STMT_FETCH command.
*/
#define SERVER_STATUS_LAST_ROW_SENT 128U
#define SERVER_STATUS_DB_DROPPED 256U /* A database was dropped */
#define SERVER_STATUS_NO_BACKSLASH_ESCAPES 512U
/**
Sent to the client if after a prepared statement reprepare
we discovered that the new statement returns a different
number of result set columns.
*/
#define SERVER_STATUS_METADATA_CHANGED 1024U
#define SERVER_QUERY_WAS_SLOW 2048U
/**
To mark ResultSet containing output parameter values.
*/
#define SERVER_PS_OUT_PARAMS 4096U
/**
Set at the same time as SERVER_STATUS_IN_TRANS if the started
multi-statement transaction is a read-only transaction. Cleared
when the transaction commits or aborts. Since this flag is sent
to clients in OK and EOF packets, the flag indicates the
transaction status at the end of command execution.
*/
#define SERVER_STATUS_IN_TRANS_READONLY 8192U
/**
This status flag, when on, implies that one of the state information has
changed on the server because of the execution of the last statement.
*/
#define SERVER_SESSION_STATE_CHANGED 16384U
#define SERVER_STATUS_ANSI_QUOTES 32768U
/*
Set for stored procedures if the select query returned a row
To check for an empty query, one must also check thd::get_sent_row_count()
*/
#define SERVER_STATUS_RETURNED_ROW (1U << 16)
/**
Server status flags that must be cleared when starting
execution of a new SQL statement.
Flags from this set are only added to the
current server status by the execution engine, but
never removed -- the execution engine expects them
to disappear automagically by the next command.
*/
#define SERVER_STATUS_CLEAR_SET (SERVER_QUERY_NO_GOOD_INDEX_USED| \
SERVER_QUERY_NO_INDEX_USED|\
SERVER_MORE_RESULTS_EXISTS|\
SERVER_STATUS_METADATA_CHANGED |\
SERVER_QUERY_WAS_SLOW |\
SERVER_STATUS_DB_DROPPED |\
SERVER_STATUS_CURSOR_EXISTS|\
SERVER_STATUS_LAST_ROW_SENT|\
SERVER_SESSION_STATE_CHANGED|\
SERVER_STATUS_RETURNED_ROW)
#define MYSQL_ERRMSG_SIZE 512
#define NET_READ_TIMEOUT 30 /* Timeout on read */
#define NET_WRITE_TIMEOUT 60 /* Timeout on write */
#define NET_WAIT_TIMEOUT 8*60*60 /* Wait for new query */
struct st_vio; /* Only C */
typedef struct st_vio Vio;
#define MAX_TINYINT_WIDTH 3 /* Max width for a TINY w.o. sign */
#define MAX_SMALLINT_WIDTH 5 /* Max width for a SHORT w.o. sign */
#define MAX_MEDIUMINT_WIDTH 8 /* Max width for a INT24 w.o. sign */
#define MAX_INT_WIDTH 10 /* Max width for a LONG w.o. sign */
#define MAX_BIGINT_WIDTH 20 /* Max width for a LONGLONG */
#define MAX_CHAR_WIDTH 255 /* Max length for a CHAR column */
#define MYSQL_UDF_MAX_RESULT_LENGTH 255 /* Max length for a UDF result */
#define MAX_BLOB_WIDTH 16777216 /* Default width for blob */
typedef struct st_net {
#if !defined(CHECK_EMBEDDED_DIFFERENCES) || !defined(EMBEDDED_LIBRARY)
Vio *vio;
unsigned char *buff,*buff_end,*write_pos,*read_pos;
my_socket fd; /* For Perl DBI/dbd */
/*
The following variable is set if we are doing several queries in one
command ( as in LOAD TABLE ... FROM MASTER ),
and do not want to confuse the client with OK at the wrong time
*/
unsigned long remain_in_buf,length, buf_length, where_b;
unsigned long max_packet,max_packet_size;
unsigned int pkt_nr,compress_pkt_nr;
unsigned int write_timeout, read_timeout, retry_count;
int fcntl;
unsigned int *return_status;
unsigned char reading_or_writing;
char save_char;
char net_skip_rest_factor;
my_bool thread_specific_malloc;
unsigned char compress;
my_bool pkt_nr_can_be_reset;
my_bool using_proxy_protocol;
/*
Pointer to query object in query cache, do not equal NULL (0) for
queries in cache that have not stored its results yet
*/
#endif
void *thd; /* Used by MariaDB server to avoid calling current_thd */
unsigned int last_errno;
unsigned char error;
my_bool unused4; /* Please remove with the next incompatible ABI change. */
my_bool unused5; /* Please remove with the next incompatible ABI change. */
/** Client library error message buffer. Actually belongs to struct MYSQL. */
char last_error[MYSQL_ERRMSG_SIZE];
/** Client library sqlstate buffer. Set along with the error message. */
char sqlstate[SQLSTATE_LENGTH+1];
void *extension;
} NET;
#define packet_error ~0UL
enum enum_field_types { MYSQL_TYPE_DECIMAL, MYSQL_TYPE_TINY,
MYSQL_TYPE_SHORT, MYSQL_TYPE_LONG,
MYSQL_TYPE_FLOAT, MYSQL_TYPE_DOUBLE,
MYSQL_TYPE_NULL, MYSQL_TYPE_TIMESTAMP,
MYSQL_TYPE_LONGLONG,MYSQL_TYPE_INT24,
MYSQL_TYPE_DATE, MYSQL_TYPE_TIME,
MYSQL_TYPE_DATETIME, MYSQL_TYPE_YEAR,
MYSQL_TYPE_NEWDATE, MYSQL_TYPE_VARCHAR,
MYSQL_TYPE_BIT,
/*
mysql-5.6 compatibility temporal types.
They're only used internally for reading RBR
mysql-5.6 binary log events and mysql-5.6 frm files.
They're never sent to the client.
*/
MYSQL_TYPE_TIMESTAMP2,
MYSQL_TYPE_DATETIME2,
MYSQL_TYPE_TIME2,
/* Compressed types are only used internally for RBR. */
MYSQL_TYPE_BLOB_COMPRESSED= 140,
MYSQL_TYPE_VARCHAR_COMPRESSED= 141,
MYSQL_TYPE_NEWDECIMAL=246,
MYSQL_TYPE_ENUM=247,
MYSQL_TYPE_SET=248,
MYSQL_TYPE_TINY_BLOB=249,
MYSQL_TYPE_MEDIUM_BLOB=250,
MYSQL_TYPE_LONG_BLOB=251,
MYSQL_TYPE_BLOB=252,
MYSQL_TYPE_VAR_STRING=253,
MYSQL_TYPE_STRING=254,
MYSQL_TYPE_GEOMETRY=255
};
/* For backward compatibility */
#define CLIENT_MULTI_QUERIES CLIENT_MULTI_STATEMENTS
#define FIELD_TYPE_DECIMAL MYSQL_TYPE_DECIMAL
#define FIELD_TYPE_NEWDECIMAL MYSQL_TYPE_NEWDECIMAL
#define FIELD_TYPE_TINY MYSQL_TYPE_TINY
#define FIELD_TYPE_SHORT MYSQL_TYPE_SHORT
#define FIELD_TYPE_LONG MYSQL_TYPE_LONG
#define FIELD_TYPE_FLOAT MYSQL_TYPE_FLOAT
#define FIELD_TYPE_DOUBLE MYSQL_TYPE_DOUBLE
#define FIELD_TYPE_NULL MYSQL_TYPE_NULL
#define FIELD_TYPE_TIMESTAMP MYSQL_TYPE_TIMESTAMP
#define FIELD_TYPE_LONGLONG MYSQL_TYPE_LONGLONG
#define FIELD_TYPE_INT24 MYSQL_TYPE_INT24
#define FIELD_TYPE_DATE MYSQL_TYPE_DATE
#define FIELD_TYPE_TIME MYSQL_TYPE_TIME
#define FIELD_TYPE_DATETIME MYSQL_TYPE_DATETIME
#define FIELD_TYPE_YEAR MYSQL_TYPE_YEAR
#define FIELD_TYPE_NEWDATE MYSQL_TYPE_NEWDATE
#define FIELD_TYPE_ENUM MYSQL_TYPE_ENUM
#define FIELD_TYPE_SET MYSQL_TYPE_SET
#define FIELD_TYPE_TINY_BLOB MYSQL_TYPE_TINY_BLOB
#define FIELD_TYPE_MEDIUM_BLOB MYSQL_TYPE_MEDIUM_BLOB
#define FIELD_TYPE_LONG_BLOB MYSQL_TYPE_LONG_BLOB
#define FIELD_TYPE_BLOB MYSQL_TYPE_BLOB
#define FIELD_TYPE_VAR_STRING MYSQL_TYPE_VAR_STRING
#define FIELD_TYPE_STRING MYSQL_TYPE_STRING
#define FIELD_TYPE_CHAR MYSQL_TYPE_TINY
#define FIELD_TYPE_INTERVAL MYSQL_TYPE_ENUM
#define FIELD_TYPE_GEOMETRY MYSQL_TYPE_GEOMETRY
#define FIELD_TYPE_BIT MYSQL_TYPE_BIT
/* Shutdown/kill enums and constants */
/* Bits for THD::killable. */
#define MYSQL_SHUTDOWN_KILLABLE_CONNECT (unsigned char)(1 << 0)
#define MYSQL_SHUTDOWN_KILLABLE_TRANS (unsigned char)(1 << 1)
#define MYSQL_SHUTDOWN_KILLABLE_LOCK_TABLE (unsigned char)(1 << 2)
#define MYSQL_SHUTDOWN_KILLABLE_UPDATE (unsigned char)(1 << 3)
enum mysql_enum_shutdown_level {
/*
We want levels to be in growing order of hardness (because we use number
comparisons). Note that DEFAULT does not respect the growing property, but
it's ok.
*/
SHUTDOWN_DEFAULT = 0,
/* wait for existing connections to finish */
SHUTDOWN_WAIT_CONNECTIONS= MYSQL_SHUTDOWN_KILLABLE_CONNECT,
/* wait for existing trans to finish */
SHUTDOWN_WAIT_TRANSACTIONS= MYSQL_SHUTDOWN_KILLABLE_TRANS,
/* wait for existing updates to finish (=> no partial MyISAM update) */
SHUTDOWN_WAIT_UPDATES= MYSQL_SHUTDOWN_KILLABLE_UPDATE,
/* flush InnoDB buffers and other storage engines' buffers*/
SHUTDOWN_WAIT_ALL_BUFFERS= (MYSQL_SHUTDOWN_KILLABLE_UPDATE << 1),
/* don't flush InnoDB buffers, flush other storage engines' buffers*/
SHUTDOWN_WAIT_CRITICAL_BUFFERS= (MYSQL_SHUTDOWN_KILLABLE_UPDATE << 1) + 1
};
enum enum_cursor_type
{
CURSOR_TYPE_NO_CURSOR= 0,
CURSOR_TYPE_READ_ONLY= 1,
CURSOR_TYPE_FOR_UPDATE= 2,
CURSOR_TYPE_SCROLLABLE= 4
};
/* options for mysql_set_option */
enum enum_mysql_set_option
{
MYSQL_OPTION_MULTI_STATEMENTS_ON,
MYSQL_OPTION_MULTI_STATEMENTS_OFF
};
/*
Type of state change information that the server can include in the Ok
packet.
*/
enum enum_session_state_type
{
SESSION_TRACK_SYSTEM_VARIABLES, /* Session system variables */
SESSION_TRACK_SCHEMA, /* Current schema */
SESSION_TRACK_STATE_CHANGE, /* track session state changes */
SESSION_TRACK_GTIDS,
SESSION_TRACK_TRANSACTION_CHARACTERISTICS, /* Transaction chistics */
SESSION_TRACK_TRANSACTION_STATE, /* Transaction state */
#ifdef USER_VAR_TRACKING
SESSION_TRACK_MYSQL_RESERVED1,
SESSION_TRACK_MYSQL_RESERVED2,
SESSION_TRACK_MYSQL_RESERVED3,
SESSION_TRACK_MYSQL_RESERVED4,
SESSION_TRACK_MYSQL_RESERVED5,
SESSION_TRACK_MYSQL_RESERVED6,
SESSION_TRACK_USER_VARIABLES,
#endif // USER_VAR_TRACKING
SESSION_TRACK_always_at_the_end /* must be last */
};
#define SESSION_TRACK_BEGIN SESSION_TRACK_SYSTEM_VARIABLES
#define IS_SESSION_STATE_TYPE(T) \
(((int)(T) >= SESSION_TRACK_BEGIN) && ((T) < SESSION_TRACK_always_at_the_end))
#define net_new_transaction(net) ((net)->pkt_nr=0)
#ifdef __cplusplus
extern "C" {
#endif
my_bool my_net_init(NET *net, Vio* vio, void *thd, unsigned int my_flags);
void my_net_local_init(NET *net);
void net_end(NET *net);
void net_clear(NET *net, my_bool clear_buffer);
my_bool net_realloc(NET *net, size_t length);
my_bool net_flush(NET *net);
my_bool my_net_write(NET *net,const unsigned char *packet, size_t len);
my_bool net_write_command(NET *net,unsigned char command,
const unsigned char *header, size_t head_len,
const unsigned char *packet, size_t len);
int net_real_write(NET *net,const unsigned char *packet, size_t len);
unsigned long my_net_read_packet(NET *net, my_bool read_from_server);
unsigned long my_net_read_packet_reallen(NET *net, my_bool read_from_server,
unsigned long* reallen);
#define my_net_read(A) my_net_read_packet((A), 0)
#ifdef MY_GLOBAL_INCLUDED
void my_net_set_write_timeout(NET *net, uint timeout);
void my_net_set_read_timeout(NET *net, uint timeout);
#endif
struct sockaddr;
int my_connect(my_socket s, const struct sockaddr *name, unsigned int namelen,
unsigned int timeout);
struct my_rnd_struct;
#ifdef __cplusplus
}
#endif
/* The following is for user defined functions */
enum Item_result
{
STRING_RESULT=0, REAL_RESULT, INT_RESULT, ROW_RESULT, DECIMAL_RESULT,
TIME_RESULT
};
typedef struct st_udf_args
{
unsigned int arg_count; /* Number of arguments */
enum Item_result *arg_type; /* Pointer to item_results */
char **args; /* Pointer to argument */
unsigned long *lengths; /* Length of string arguments */
char *maybe_null; /* Set to 1 for all maybe_null args */
const char **attributes; /* Pointer to attribute name */
unsigned long *attribute_lengths; /* Length of attribute arguments */
void *extension;
} UDF_ARGS;
/* This holds information about the result */
typedef struct st_udf_init
{
my_bool maybe_null; /* 1 if function can return NULL */
unsigned int decimals; /* for real functions */
unsigned long max_length; /* For string functions */
char *ptr; /* free pointer for function data */
my_bool const_item; /* 1 if function always returns the same value */
void *extension;
} UDF_INIT;
/*
TODO: add a notion for determinism of the UDF.
See Item_udf_func::update_used_tables ()
*/
/* Constants when using compression */
#define NET_HEADER_SIZE 4 /* standard header size */
#define COMP_HEADER_SIZE 3 /* compression header extra size */
/* Prototypes to password functions */
#ifdef __cplusplus
extern "C" {
#endif
/*
These functions are used for authentication by client and server and
implemented in sql/password.c
*/
void create_random_string(char *to, unsigned int length,
struct my_rnd_struct *rand_st);
void hash_password(unsigned long *to, const char *password, unsigned int password_len);
void make_scrambled_password_323(char *to, const char *password);
void scramble_323(char *to, const char *message, const char *password);
my_bool check_scramble_323(const unsigned char *reply, const char *message,
unsigned long *salt);
void get_salt_from_password_323(unsigned long *res, const char *password);
void make_scrambled_password(char *to, const char *password);
void scramble(char *to, const char *message, const char *password);
my_bool check_scramble(const unsigned char *reply, const char *message,
const unsigned char *hash_stage2);
void get_salt_from_password(unsigned char *res, const char *password);
char *octet2hex(char *to, const unsigned char *str, size_t len);
/* end of password.c */
char *get_tty_password(const char *opt_message);
void get_tty_password_buff(const char *opt_message, char *to, size_t length);
const char *mysql_errno_to_sqlstate(unsigned int mysql_errno);
/* Some other useful functions */
my_bool my_thread_init(void);
void my_thread_end(void);
#ifdef MY_GLOBAL_INCLUDED
#include "pack.h"
#endif
#ifdef __cplusplus
}
#endif
#define NULL_LENGTH ~0UL /* For net_store_length */
#define MYSQL_STMT_HEADER 4U
#define MYSQL_LONG_DATA_HEADER 6U
/*
If a float or double field have more than this number of decimals,
it's regarded as floating point field without any specific number of
decimals
*/
#endif
PK ! -} handler_ername.hnu [ /* Copyright (c) 2013, 2021, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/* Names of all handler error numbers. Used by mysqltest */
{ "HA_ERR_KEY_NOT_FOUND", HA_ERR_KEY_NOT_FOUND, "" },
{ "HA_ERR_FOUND_DUPP_KEY", HA_ERR_FOUND_DUPP_KEY, "" },
{ "HA_ERR_INTERNAL_ERROR", HA_ERR_INTERNAL_ERROR, "" },
{ "HA_ERR_RECORD_CHANGED", HA_ERR_RECORD_CHANGED, "" },
{ "HA_ERR_WRONG_INDEX", HA_ERR_WRONG_INDEX, "" },
{ "HA_ERR_CRASHED", HA_ERR_CRASHED, "" },
{ "HA_ERR_WRONG_IN_RECORD", HA_ERR_WRONG_IN_RECORD, "" },
{ "HA_ERR_OUT_OF_MEM", HA_ERR_OUT_OF_MEM, "" },
{ "HA_ERR_NOT_A_TABLE", HA_ERR_NOT_A_TABLE, "" },
{ "HA_ERR_WRONG_COMMAND", HA_ERR_WRONG_COMMAND, "" },
{ "HA_ERR_OLD_FILE", HA_ERR_OLD_FILE, "" },
{ "HA_ERR_NO_ACTIVE_RECORD", HA_ERR_NO_ACTIVE_RECORD, "" },
{ "HA_ERR_RECORD_DELETED", HA_ERR_RECORD_DELETED, "" },
{ "HA_ERR_RECORD_FILE_FULL", HA_ERR_RECORD_FILE_FULL, "" },
{ "HA_ERR_INDEX_FILE_FULL", HA_ERR_INDEX_FILE_FULL, "" },
{ "HA_ERR_END_OF_FILE", HA_ERR_END_OF_FILE, "" },
{ "HA_ERR_UNSUPPORTED", HA_ERR_UNSUPPORTED, "" },
{ "HA_ERR_TO_BIG_ROW", HA_ERR_TO_BIG_ROW, "" },
{ "HA_WRONG_CREATE_OPTION", HA_WRONG_CREATE_OPTION, "" },
{ "HA_ERR_FOUND_DUPP_UNIQUE", HA_ERR_FOUND_DUPP_UNIQUE, "" },
{ "HA_ERR_UNKNOWN_CHARSET", HA_ERR_UNKNOWN_CHARSET, "" },
{ "HA_ERR_WRONG_MRG_TABLE_DEF", HA_ERR_WRONG_MRG_TABLE_DEF, "" },
{ "HA_ERR_CRASHED_ON_REPAIR", HA_ERR_CRASHED_ON_REPAIR, "" },
{ "HA_ERR_CRASHED_ON_USAGE", HA_ERR_CRASHED_ON_USAGE, "" },
{ "HA_ERR_LOCK_WAIT_TIMEOUT", HA_ERR_LOCK_WAIT_TIMEOUT, "" },
{ "HA_ERR_LOCK_TABLE_FULL", HA_ERR_LOCK_TABLE_FULL, "" },
{ "HA_ERR_READ_ONLY_TRANSACTION", HA_ERR_READ_ONLY_TRANSACTION, "" },
{ "HA_ERR_LOCK_DEADLOCK", HA_ERR_LOCK_DEADLOCK, "" },
{ "HA_ERR_CANNOT_ADD_FOREIGN", HA_ERR_CANNOT_ADD_FOREIGN, "" },
{ "HA_ERR_NO_REFERENCED_ROW", HA_ERR_NO_REFERENCED_ROW, "" },
{ "HA_ERR_ROW_IS_REFERENCED", HA_ERR_ROW_IS_REFERENCED, "" },
{ "HA_ERR_NO_SAVEPOINT", HA_ERR_NO_SAVEPOINT, "" },
{ "HA_ERR_NON_UNIQUE_BLOCK_SIZE", HA_ERR_NON_UNIQUE_BLOCK_SIZE, "" },
{ "HA_ERR_NO_SUCH_TABLE", HA_ERR_NO_SUCH_TABLE, "" },
{ "HA_ERR_TABLE_EXIST", HA_ERR_TABLE_EXIST, "" },
{ "HA_ERR_NO_CONNECTION", HA_ERR_NO_CONNECTION, "" },
{ "HA_ERR_NULL_IN_SPATIAL", HA_ERR_NULL_IN_SPATIAL, "" },
{ "HA_ERR_TABLE_DEF_CHANGED", HA_ERR_TABLE_DEF_CHANGED, "" },
{ "HA_ERR_NO_PARTITION_FOUND", HA_ERR_NO_PARTITION_FOUND, "" },
{ "HA_ERR_RBR_LOGGING_FAILED", HA_ERR_RBR_LOGGING_FAILED, "" },
{ "HA_ERR_DROP_INDEX_FK", HA_ERR_DROP_INDEX_FK, "" },
{ "HA_ERR_FOREIGN_DUPLICATE_KEY", HA_ERR_FOREIGN_DUPLICATE_KEY, "" },
{ "HA_ERR_TABLE_NEEDS_UPGRADE", HA_ERR_TABLE_NEEDS_UPGRADE, "" },
{ "HA_ERR_TABLE_READONLY", HA_ERR_TABLE_READONLY, "" },
{ "HA_ERR_AUTOINC_READ_FAILED", HA_ERR_AUTOINC_READ_FAILED, "" },
{ "HA_ERR_AUTOINC_ERANGE", HA_ERR_AUTOINC_ERANGE, "" },
{ "HA_ERR_GENERIC", HA_ERR_GENERIC, "" },
{ "HA_ERR_RECORD_IS_THE_SAME", HA_ERR_RECORD_IS_THE_SAME, "" },
{ "HA_ERR_LOGGING_IMPOSSIBLE", HA_ERR_LOGGING_IMPOSSIBLE, "" },
{ "HA_ERR_CORRUPT_EVENT", HA_ERR_CORRUPT_EVENT, "" },
{ "HA_ERR_NEW_FILE", HA_ERR_NEW_FILE, "" },
{ "HA_ERR_ROWS_EVENT_APPLY", HA_ERR_ROWS_EVENT_APPLY, "" },
{ "HA_ERR_INITIALIZATION", HA_ERR_INITIALIZATION, "" },
{ "HA_ERR_FILE_TOO_SHORT", HA_ERR_FILE_TOO_SHORT, "" },
{ "HA_ERR_WRONG_CRC", HA_ERR_WRONG_CRC, "" },
{ "HA_ERR_TOO_MANY_CONCURRENT_TRXS", HA_ERR_TOO_MANY_CONCURRENT_TRXS, "" },
{ "HA_ERR_INDEX_COL_TOO_LONG", HA_ERR_INDEX_COL_TOO_LONG, "" },
{ "HA_ERR_INDEX_CORRUPT", HA_ERR_INDEX_CORRUPT, "" },
{ "HA_ERR_UNDO_REC_TOO_BIG", HA_ERR_UNDO_REC_TOO_BIG, "" },
{ "HA_ERR_ROW_NOT_VISIBLE", HA_ERR_ROW_NOT_VISIBLE, "" },
{ "HA_ERR_ABORTED_BY_USER", HA_ERR_ABORTED_BY_USER, "" },
{ "HA_ERR_DISK_FULL", HA_ERR_DISK_FULL, "" },
{ "HA_ERR_INCOMPATIBLE_DEFINITION", HA_ERR_INCOMPATIBLE_DEFINITION, "" },
{ "HA_ERR_COMMIT_ERROR", HA_ERR_COMMIT_ERROR, "" },
{ "HA_ERR_PARTITION_LIST", HA_ERR_PARTITION_LIST, ""},
{ "HA_ERR_NO_ENCRYPTION", HA_ERR_NO_ENCRYPTION, ""},
{ "HA_ERR_ROLLBACK", HA_ERR_ROLLBACK, "" },
PK ! Thp big_endian.hnu [ /* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/*
Data in big-endian format.
*/
#define float4store(T,A) do { *(T)= ((uchar *) &A)[3];\
*((T)+1)=(char) ((uchar *) &A)[2];\
*((T)+2)=(char) ((uchar *) &A)[1];\
*((T)+3)=(char) ((uchar *) &A)[0]; } while(0)
#define float4get(V,M) do { float def_temp;\
((uchar*) &def_temp)[0]=(M)[3];\
((uchar*) &def_temp)[1]=(M)[2];\
((uchar*) &def_temp)[2]=(M)[1];\
((uchar*) &def_temp)[3]=(M)[0];\
(V)=def_temp; } while(0)
#define float8store(T,V) do { *(T)= ((uchar *) &V)[7];\
*((T)+1)=(char) ((uchar *) &V)[6];\
*((T)+2)=(char) ((uchar *) &V)[5];\
*((T)+3)=(char) ((uchar *) &V)[4];\
*((T)+4)=(char) ((uchar *) &V)[3];\
*((T)+5)=(char) ((uchar *) &V)[2];\
*((T)+6)=(char) ((uchar *) &V)[1];\
*((T)+7)=(char) ((uchar *) &V)[0]; } while(0)
#define float8get(V,M) do { double def_temp;\
((uchar*) &def_temp)[0]=(M)[7];\
((uchar*) &def_temp)[1]=(M)[6];\
((uchar*) &def_temp)[2]=(M)[5];\
((uchar*) &def_temp)[3]=(M)[4];\
((uchar*) &def_temp)[4]=(M)[3];\
((uchar*) &def_temp)[5]=(M)[2];\
((uchar*) &def_temp)[6]=(M)[1];\
((uchar*) &def_temp)[7]=(M)[0];\
(V) = def_temp; } while(0)
#define ushortget(V,M) do { V = (uint16) (((uint16) ((uchar) (M)[1]))+\
((uint16) ((uint16) (M)[0]) << 8)); } while(0)
#define shortget(V,M) do { V = (short) (((short) ((uchar) (M)[1]))+\
((short) ((short) (M)[0]) << 8)); } while(0)
#define longget(V,M) do { int32 def_temp;\
((uchar*) &def_temp)[0]=(M)[0];\
((uchar*) &def_temp)[1]=(M)[1];\
((uchar*) &def_temp)[2]=(M)[2];\
((uchar*) &def_temp)[3]=(M)[3];\
(V)=def_temp; } while(0)
#define ulongget(V,M) do { uint32 def_temp;\
((uchar*) &def_temp)[0]=(M)[0];\
((uchar*) &def_temp)[1]=(M)[1];\
((uchar*) &def_temp)[2]=(M)[2];\
((uchar*) &def_temp)[3]=(M)[3];\
(V)=def_temp; } while(0)
#define shortstore(T,A) do { uint def_temp=(uint) (A) ;\
*(((char*)T)+1)=(char)(def_temp); \
*(((char*)T)+0)=(char)(def_temp >> 8); } while(0)
#define longstore(T,A) do { *(((char*)T)+3)=((A));\
*(((char*)T)+2)=(((A) >> 8));\
*(((char*)T)+1)=(((A) >> 16));\
*(((char*)T)+0)=(((A) >> 24)); } while(0)
#define floatget(V,M) memcpy(&V, (M), sizeof(float))
/* Cast away type qualifiers (necessary as macro takes argument by value). */
#define floatstore(T,V) memcpy((T), (void*) (&V), sizeof(float))
#define doubleget(V,M) memcpy(&V, (M), sizeof(double))
/* Cast away type qualifiers (necessary as macro takes argument by value). */
#define doublestore(T,V) memcpy((T), (void*) &V, sizeof(double))
#define longlongget(V,M) memcpy(&V, (M), sizeof(ulonglong))
#define longlongstore(T,V) memcpy((T), &V, sizeof(ulonglong))
PK ! my_global.hnu [ /*
Copyright (c) 2001, 2013, Oracle and/or its affiliates.
Copyright (c) 2009, 2022, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/* This is the include file that should be included 'first' in every C file. */
#ifndef MY_GLOBAL_INCLUDED
#define MY_GLOBAL_INCLUDED
/*
MDEV-25602 Deprecate __WIN__ symbol.
*/
#if defined (_MSC_VER) && !defined(__clang__)
#pragma deprecated("__WIN__")
#elif defined (__GNUC__)
#pragma GCC poison __WIN__
#endif
#if defined(_MSC_VER) && !defined(__clang__)
/*
Following functions have bugs, when used with UTF-8 active codepage.
#include will use the non-buggy wrappers
*/
#pragma deprecated("CreateServiceA", "OpenServiceA", "ChangeServiceConfigA")
#endif
/*
InnoDB depends on some MySQL internals which other plugins should not
need. This is because of InnoDB's foreign key support, "safe" binlog
truncation, and other similar legacy features.
We define accessors for these internals unconditionally, but do not
expose them in mysql/plugin.h. They are declared in ha_innodb.h for
InnoDB's use.
*/
#define INNODB_COMPATIBILITY_HOOKS
#ifdef __CYGWIN__
/* We use a Unix API, so pretend it's not Windows */
#undef WIN
#undef WIN32
#undef _WIN
#undef _WIN32
#undef _WIN64
#undef _WIN32
#undef __WIN32__
#define HAVE_ERRNO_AS_DEFINE
#define _POSIX_MONOTONIC_CLOCK
#define _POSIX_THREAD_CPUTIME
#endif /* __CYGWIN__ */
#if defined(__OpenBSD__) && (OpenBSD >= 200411)
#define HAVE_ERRNO_AS_DEFINE
#endif
#if defined(i386) && !defined(__i386__)
#define __i386__
#endif
/* Macros to make switching between C and C++ mode easier */
#ifdef __cplusplus
#define C_MODE_START extern "C" {
#define C_MODE_END }
#else
#define C_MODE_START
#define C_MODE_END
#endif
#ifdef __cplusplus
#define CPP_UNNAMED_NS_START namespace {
#define CPP_UNNAMED_NS_END }
#endif
#include
#ifdef WITH_PERFSCHEMA_STORAGE_ENGINE
#define HAVE_PSI_INTERFACE
#endif /* WITH_PERFSCHEMA_STORAGE_ENGINE */
/* Make it easier to add conditional code in _expressions_ */
#ifdef _WIN32
#define IF_WIN(A,B) A
#else
#define IF_WIN(A,B) B
#endif
#ifdef EMBEDDED_LIBRARY
#define IF_EMBEDDED(A,B) A
#else
#define IF_EMBEDDED(A,B) B
#endif
#ifdef WITH_PARTITION_STORAGE_ENGINE
#define IF_PARTITIONING(A,B) A
#else
#define IF_PARTITIONING(A,B) B
#endif
#if defined (_WIN32)
/*
off_t is 32 bit long. We do not use C runtime functions
with off_t but native Win32 file IO APIs, that work with
64 bit offsets.
*/
#undef SIZEOF_OFF_T
#define SIZEOF_OFF_T 8
/*
Prevent inclusion of Windows GDI headers - they define symbol
ERROR that conflicts with mysql headers.
*/
#ifndef NOGDI
#define NOGDI
#endif
/* Include common headers.*/
#include
#include /* SOCKET */
#include /* access(), chmod() */
#include /* getpid() */
#define sleep(a) Sleep((a)*1000)
/* Define missing access() modes. */
#define F_OK 0
#define W_OK 2
#define R_OK 4 /* Test for read permission. */
/* Define missing file locking constants. */
#define F_RDLCK 1
#define F_WRLCK 2
#define F_UNLCK 3
#define F_TO_EOF 0x3FFFFFFF
#endif /* _WIN32*/
/*
The macros below are used to allow build of Universal/fat binaries of
MySQL and MySQL applications under darwin.
*/
#if defined(__APPLE__) && defined(__MACH__)
# undef SIZEOF_CHARP
# undef SIZEOF_INT
# undef SIZEOF_LONG
# undef SIZEOF_LONG_LONG
# undef SIZEOF_OFF_T
# undef WORDS_BIGENDIAN
# define SIZEOF_INT 4
# define SIZEOF_LONG_LONG 8
# define SIZEOF_OFF_T 8
# if defined(__i386__) || defined(__ppc__)
# define SIZEOF_CHARP 4
# define SIZEOF_LONG 4
# elif defined(__x86_64__) || defined(__ppc64__) || defined(__aarch64__) || defined(__arm64__)
# define SIZEOF_CHARP 8
# define SIZEOF_LONG 8
# else
# error Building FAT binary for an unknown architecture.
# endif
# if defined(__ppc__) || defined(__ppc64__)
# define WORDS_BIGENDIAN
# endif
#endif /* defined(__APPLE__) && defined(__MACH__) */
/*
The macros below are borrowed from include/linux/compiler.h in the
Linux kernel. Use them to indicate the likelihood of the truthfulness
of a condition. This serves two purposes - newer versions of gcc will be
able to optimize for branch predication, which could yield siginficant
performance gains in frequently executed sections of the code, and the
other reason to use them is for documentation
*/
#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
#define __builtin_expect(x, expected_value) (x)
#endif
/* Fix problem with S_ISLNK() on Linux */
#if defined(TARGET_OS_LINUX) || defined(__GLIBC__)
#undef _GNU_SOURCE
#define _GNU_SOURCE 1
#endif
/*
Temporary solution to solve bug#7156. Include "sys/types.h" before
the thread headers, else the function madvise() will not be defined
*/
#if defined(HAVE_SYS_TYPES_H) && ( defined(sun) || defined(__sun) )
#include
#endif
#define __EXTENSIONS__ 1 /* We want some extension */
#ifndef __STDC_EXT__
#define __STDC_EXT__ 1 /* To get large file support on hpux */
#endif
/*
Solaris 9 include file refers to X/Open document
System Interfaces and Headers, Issue 5
saying we should define _XOPEN_SOURCE=500 to get POSIX.1c prototypes,
but apparently other systems (namely FreeBSD) don't agree.
On a newer Solaris 10, the above file recognizes also _XOPEN_SOURCE=600.
Furthermore, it tests that if a program requires older standard
(_XOPEN_SOURCE<600 or _POSIX_C_SOURCE<200112L) it cannot be
run on a new compiler (that defines _STDC_C99) and issues an #error.
It's also an #error if a program requires new standard (_XOPEN_SOURCE=600
or _POSIX_C_SOURCE=200112L) and a compiler does not define _STDC_C99.
To add more to this mess, Sun Studio C compiler defines _STDC_C99 while
C++ compiler does not!
So, in a desperate attempt to get correct prototypes for both
C and C++ code, we define either _XOPEN_SOURCE=600 or _XOPEN_SOURCE=500
depending on the compiler's announced C standard support.
Cleaner solutions are welcome.
*/
#ifdef __sun
#if __STDC_VERSION__ - 0 >= 199901L
#define _XOPEN_SOURCE 600
#else
#define _XOPEN_SOURCE 500
#endif
#endif
#ifdef _AIX
/*
AIX includes inttypes.h from sys/types.h
Explicitly request format macros before the first inclusion of inttypes.h
*/
#if !defined(__STDC_FORMAT_MACROS)
#define __STDC_FORMAT_MACROS
#endif // !defined(__STDC_FORMAT_MACROS)
#endif
#if !defined(_WIN32)
#ifndef _POSIX_PTHREAD_SEMANTICS
#define _POSIX_PTHREAD_SEMANTICS /* We want posix threads */
#endif
#if !defined(SCO)
#define _REENTRANT 1 /* Some thread libraries require this */
#endif
#if !defined(_THREAD_SAFE) && !defined(_AIX)
#define _THREAD_SAFE /* Required for OSF1 */
#endif
#if defined(HPUX10) || defined(HPUX11)
C_MODE_START /* HPUX needs this, signal.h bug */
#include
C_MODE_END
#else
#include /* AIX must have this included first */
#endif
#if !defined(SCO) && !defined(_REENTRANT)
#define _REENTRANT 1 /* Threads requires reentrant code */
#endif
#endif /* !defined(_WIN32) */
/* gcc/egcs issues */
#if defined(__GNUC) && defined(__EXCEPTIONS)
#error "Please add -fno-exceptions to CXXFLAGS and reconfigure/recompile"
#endif
#ifndef stdin
#include
#endif
#include
#ifdef HAVE_STDLIB_H
#include
#endif
#ifdef HAVE_STDDEF_H
#include
#endif
#include
#ifdef HAVE_LIMITS_H
#include
#endif
#ifdef HAVE_FLOAT_H
#include
#endif
#ifdef HAVE_FENV_H
#include /* For fesetround() */
#endif
#ifdef HAVE_SYS_TYPES_H
#include
#endif
#ifdef HAVE_FCNTL_H
#include
#endif
#ifdef HAVE_SYS_STAT_H
#include
#endif
#if TIME_WITH_SYS_TIME
# include
# include
#else
# if HAVE_SYS_TIME_H
# include
# else
# include
# endif
#endif /* TIME_WITH_SYS_TIME */
#ifdef HAVE_UNISTD_H
#include
#endif
#include /* Recommended by debian */
/* We need the following to go around a problem with openssl on solaris */
#if defined(HAVE_CRYPT_H)
#include
#endif
/* Add checking if we are using likely/unlikely wrong */
#ifdef CHECK_UNLIKELY
C_MODE_START
extern void init_my_likely(), end_my_likely(FILE *);
extern int my_likely_ok(const char *file_name, uint line);
extern int my_likely_fail(const char *file_name, uint line);
C_MODE_END
#define likely(A) ((A) ? (my_likely_ok(__FILE__, __LINE__),1) : (my_likely_fail(__FILE__, __LINE__), 0))
#define unlikely(A) ((A) ? (my_likely_fail(__FILE__, __LINE__),1) : (my_likely_ok(__FILE__, __LINE__), 0))
/*
These macros should be used when the check fails often when running benchmarks but
we know for sure that the check is correct in a production environment
*/
#define checked_likely(A) (A)
#define checked_unlikely(A) (A)
#else
/**
The semantics of builtin_expect() are that
1) its two arguments are long
2) it's likely that they are ==
Those of our likely(x) are that x can be bool/int/longlong/pointer.
*/
#define likely(x) __builtin_expect(((x) != 0),1)
#define unlikely(x) __builtin_expect(((x) != 0),0)
#define checked_likely(x) likely(x)
#define checked_unlikely(x) unlikely(x)
#endif /* CHECK_UNLIKELY */
/*
A lot of our programs uses asserts, so better to always include it
This also fixes a problem when people uses DBUG_ASSERT without including
assert.h
*/
#include
/* an assert that works at compile-time. only for constant expression */
#ifdef _some_old_compiler_that_does_not_understand_the_construct_below_
#define compile_time_assert(X) do { } while(0)
#else
#define compile_time_assert(X) \
do \
{ \
typedef char compile_time_assert[(X) ? 1 : -1] __attribute__((unused)); \
} while(0)
#endif
/* Go around some bugs in different OS and compilers */
#if defined (HPUX11) && defined(_LARGEFILE_SOURCE)
#ifndef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE
#endif
#endif
#if defined(_HPUX_SOURCE) && defined(HAVE_SYS_STREAM_H)
#include /* HPUX 10.20 defines ulong here. UGLY !!! */
#define HAVE_ULONG
#endif
#if defined(HPUX10) && defined(_LARGEFILE64_SOURCE)
/* Fix bug in setrlimit */
#undef setrlimit
#define setrlimit cma_setrlimit64
#endif
/* Declare madvise where it is not declared for C++, like Solaris */
#if HAVE_MADVISE && !HAVE_DECL_MADVISE && defined(__cplusplus)
extern "C" int madvise(void *addr, size_t len, int behav);
#endif
#ifdef HAVE_SYS_MMAN_H
#include
#endif
/** FreeBSD equivalent */
#if defined(MADV_CORE) && !defined(MADV_DODUMP)
#define MADV_DODUMP MADV_CORE
#define MADV_DONTDUMP MADV_NOCORE
#define DODUMP_STR "MADV_CORE"
#define DONTDUMP_STR "MADV_NOCORE"
#else
#define DODUMP_STR "MADV_DODUMP"
#define DONTDUMP_STR "MADV_DONTDUMP"
#endif
#define QUOTE_ARG(x) #x /* Quote argument (before cpp) */
#define STRINGIFY_ARG(x) QUOTE_ARG(x) /* Quote argument, after cpp */
/* Paranoid settings. Define I_AM_PARANOID if you are paranoid */
#ifdef I_AM_PARANOID
#define DONT_ALLOW_USER_CHANGE 1
#define DONT_USE_MYSQL_PWD 1
#endif
/* Does the system remember a signal handler after a signal ? */
#if !defined(HAVE_BSD_SIGNALS) && !defined(HAVE_SIGACTION)
#define SIGNAL_HANDLER_RESET_ON_DELIVERY
#endif
/* don't assume that STDERR_FILENO is 2, mysqld can freopen */
#undef STDERR_FILENO
#ifndef SO_EXT
#ifdef _WIN32
#define SO_EXT ".dll"
#else
#define SO_EXT ".so"
#endif
#endif
/*
Suppress uninitialized variable warning without generating code.
*/
#if defined(__GNUC__) && !defined(__clang__)
/*
GCC specific self-initialization which inhibits the warning.
clang and static analysis will complain loudly about this.
*/
#define UNINIT_VAR(x) x= x
#elif defined(FORCE_INIT_OF_VARS)
#define UNINIT_VAR(x) x= 0
#else
#define UNINIT_VAR(x) x
#endif
#if !defined(HAVE_UINT)
#undef HAVE_UINT
#define HAVE_UINT
typedef unsigned int uint;
typedef unsigned short ushort;
#endif
#define swap_variables(t, a, b) do { t dummy; dummy= a; a= b; b= dummy; } while(0)
#define MY_TEST(a) ((a) ? 1 : 0)
#define set_if_bigger(a,b) do { if ((a) < (b)) (a)=(b); } while(0)
#define set_if_smaller(a,b) do { if ((a) > (b)) (a)=(b); } while(0)
#define set_bits(type, bit_count) (sizeof(type)*8 <= (bit_count) ? ~(type) 0 : ((((type) 1) << (bit_count)) - (type) 1))
#define test_all_bits(a,b) (((a) & (b)) == (b))
#define array_elements(A) ((uint) (sizeof(A)/sizeof(A[0])))
/* Define some general constants */
#ifndef TRUE
#define TRUE (1) /* Logical true */
#define FALSE (0) /* Logical false */
#endif
#include
#include
/*
Wen using the embedded library, users might run into link problems,
duplicate declaration of __cxa_pure_virtual, solved by declaring it a
weak symbol.
*/
#if defined(USE_MYSYS_NEW) && ! defined(DONT_DECLARE_CXA_PURE_VIRTUAL)
C_MODE_START
int __cxa_pure_virtual () __attribute__ ((weak));
C_MODE_END
#endif
/* The DBUG_ON flag always takes precedence over default DBUG_OFF */
#if defined(DBUG_ON) && defined(DBUG_OFF)
#undef DBUG_OFF
#endif
/* We might be forced to turn debug off, if not turned off already */
#if defined(FORCE_DBUG_OFF) && !defined(DBUG_OFF)
# define DBUG_OFF
# ifdef DBUG_ON
# undef DBUG_ON
# endif
#endif
#ifdef DBUG_OFF
#undef EXTRA_DEBUG
#endif
/* Some types that is different between systems */
typedef int File; /* File descriptor */
#ifdef _WIN32
typedef SOCKET my_socket;
#else
typedef int my_socket; /* File descriptor for sockets */
#define INVALID_SOCKET -1
#endif
/* Type for functions that handles signals */
#define sig_handler RETSIGTYPE
#if defined(__GNUC__)
typedef char pchar; /* Mixed prototypes can take char */
typedef char puchar; /* Mixed prototypes can take char */
typedef char pbool; /* Mixed prototypes can take char */
typedef short pshort; /* Mixed prototypes can take short int */
typedef float pfloat; /* Mixed prototypes can take float */
#else
typedef int pchar; /* Mixed prototypes can't take char */
typedef uint puchar; /* Mixed prototypes can't take char */
typedef int pbool; /* Mixed prototypes can't take char */
typedef int pshort; /* Mixed prototypes can't take short int */
typedef double pfloat; /* Mixed prototypes can't take float */
#endif
#include
#define qsort_t RETQSORTTYPE /* Broken GCC can't handle typedef !!!! */
#ifdef HAVE_SYS_SOCKET_H
#include
#endif
typedef SOCKET_SIZE_TYPE size_socket;
#ifndef SOCKOPT_OPTLEN_TYPE
#define SOCKOPT_OPTLEN_TYPE size_socket
#endif
/* file create flags */
#ifndef O_SHARE /* Probably not windows */
#define O_SHARE 0 /* Flag to my_open for shared files */
#ifndef O_BINARY
#define O_BINARY 0 /* Flag to my_open for binary files */
#endif
#ifndef FILE_BINARY
#define FILE_BINARY O_BINARY /* Flag to my_fopen for binary streams */
#endif
#ifdef HAVE_FCNTL
#define HAVE_FCNTL_LOCK
#define F_TO_EOF 0L /* Param to lockf() to lock rest of file */
#endif
#endif /* O_SHARE */
#ifndef O_SEQUENTIAL
#define O_SEQUENTIAL 0
#endif
#ifndef O_SHORT_LIVED
#define O_SHORT_LIVED 0
#endif
#ifndef O_NOFOLLOW
#define O_NOFOLLOW 0
#endif
#ifndef O_CLOEXEC
#define O_CLOEXEC 0
#endif
#ifdef __GLIBC__
#define STR_O_CLOEXEC "e"
#else
#define STR_O_CLOEXEC ""
#endif
#ifndef SOCK_CLOEXEC
#define SOCK_CLOEXEC 0
#else
#define HAVE_SOCK_CLOEXEC
#endif
#ifndef O_TEXT
#define O_TEXT 0
#endif
/* additional file share flags for win32 */
#ifdef _WIN32
#define _SH_DENYRWD 0x110 /* deny read/write mode & delete */
#define _SH_DENYWRD 0x120 /* deny write mode & delete */
#define _SH_DENYRDD 0x130 /* deny read mode & delete */
#define _SH_DENYDEL 0x140 /* deny delete only */
#endif /* _WIN32 */
/* General constants */
#define FN_LEN 256 /* Max file name len */
#define FN_HEADLEN 253 /* Max length of filepart of file name */
#define FN_EXTLEN 20 /* Max length of extension (part of FN_LEN) */
#define FN_REFLEN 512 /* Max length of full path-name */
#define FN_EXTCHAR '.'
#define FN_HOMELIB '~' /* ~/ is used as abbrev for home dir */
#define FN_CURLIB '.' /* ./ is used as abbrev for current dir */
#define FN_PARENTDIR ".." /* Parent directory; Must be a string */
#ifdef _WIN32
#define FN_LIBCHAR '\\'
#define FN_LIBCHAR2 '/'
#define FN_DIRSEP "/\\" /* Valid directory separators */
#define FN_EXEEXT ".exe"
#define FN_SOEXT ".dll"
#define FN_ROOTDIR "\\"
#define FN_DEVCHAR ':'
#define FN_NETWORK_DRIVES /* Uses \\ to indicate network drives */
#define FN_NO_CASE_SENCE /* Files are not case-sensitive */
#else
#define FN_LIBCHAR '/'
#define FN_LIBCHAR2 '/'
#define FN_DIRSEP "/" /* Valid directory separators */
#define FN_EXEEXT ""
#define FN_SOEXT ".so"
#define FN_ROOTDIR "/"
#endif
/*
MY_FILE_MIN is Windows speciality and is used to quickly detect
the mismatch of CRT and mysys file IO usage on Windows at runtime.
CRT file descriptors can be in the range 0-2047, whereas descriptors returned
by my_open() will start with 2048. If a file descriptor with value less then
MY_FILE_MIN is passed to mysys IO function, chances are it stems from
open()/fileno() and not my_open()/my_fileno.
For Posix, mysys functions are light wrappers around libc, and MY_FILE_MIN
is logically 0.
*/
#ifdef _WIN32
#define MY_FILE_MIN 2048
#else
#define MY_FILE_MIN 0
#endif
/*
MY_NFILE is the default size of my_file_info array.
It is larger on Windows, because it all file handles are stored in my_file_info
Default size is 16384 and this should be enough for most cases.If it is not
enough, --max-open-files with larger value can be used.
For Posix , my_file_info array is only used to store filenames for
error reporting and its size is not a limitation for number of open files.
*/
#ifdef _WIN32
#define MY_NFILE (16384 + MY_FILE_MIN)
#else
#define MY_NFILE 64
#endif
#ifndef OS_FILE_LIMIT
#define OS_FILE_LIMIT UINT_MAX
#endif
/*
Io buffer size; Must be a power of 2 and a multiple of 512. May be
smaller what the disk page size. This influences the speed of the
isam btree library. eg to big to slow.
4096 is a common block size on SSDs.
*/
#define IO_SIZE 4096U
/*
How much overhead does malloc/my_malloc have. The code often allocates
something like 1024-MALLOC_OVERHEAD bytes
*/
#define MALLOC_OVERHEAD (8+24)
/* get memory in huncs */
#define ONCE_ALLOC_INIT (uint) 4096
/* Typical record cache */
#define RECORD_CACHE_SIZE (uint) (128*1024)
/* Typical key cache */
#define KEY_CACHE_SIZE (uint) (128L*1024L*1024L)
/* Default size of a key cache block */
#define KEY_CACHE_BLOCK_SIZE (uint) 1024
/* Some things that this system doesn't have */
#ifdef _WIN32
#define NO_DIR_LIBRARY /* Not standard dir-library */
#endif
/* Some defines of functions for portability */
#undef remove /* Crashes MySQL on SCO 5.0.0 */
#ifndef _WIN32
#define closesocket(A) close(A)
#endif
#if defined(_MSC_VER)
#if !defined(_WIN64)
inline double my_ulonglong2double(unsigned long long value)
{
long long nr=(long long) value;
if (nr >= 0)
return (double) nr;
return (18446744073709551616.0 + (double) nr);
}
#define ulonglong2double my_ulonglong2double
#define my_off_t2double my_ulonglong2double
#endif /* _WIN64 */
inline unsigned long long my_double2ulonglong(double d)
{
double t= d - (double) 0x8000000000000000ULL;
if (t >= 0)
return ((unsigned long long) t) + 0x8000000000000000ULL;
return (unsigned long long) d;
}
#define double2ulonglong my_double2ulonglong
#endif
#ifndef ulonglong2double
#define ulonglong2double(A) ((double) (ulonglong) (A))
#define my_off_t2double(A) ((double) (my_off_t) (A))
#endif
#ifndef double2ulonglong
#define double2ulonglong(A) ((ulonglong) (double) (A))
#endif
#ifndef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#endif
#define ulong_to_double(X) ((double) (ulong) (X))
#ifndef STACK_DIRECTION
#error "please add -DSTACK_DIRECTION=1 or -1 to your CPPFLAGS"
#endif
#if !defined(HAVE_STRTOK_R)
#define strtok_r(A,B,C) strtok((A),(B))
#endif
#if SIZEOF_LONG_LONG >= 8
#define HAVE_LONG_LONG 1
#else
#error WHAT? sizeof(long long) < 8 ???
#endif
/*
Some pre-ANSI-C99 systems like AIX 5.1 and Linux/GCC 2.95 define
ULONGLONG_MAX, LONGLONG_MIN, LONGLONG_MAX; we use them if they're defined.
*/
#if defined(HAVE_LONG_LONG) && !defined(LONGLONG_MIN)
#define LONGLONG_MIN ((long long) 0x8000000000000000LL)
#define LONGLONG_MAX ((long long) 0x7FFFFFFFFFFFFFFFLL)
#endif
/* Max length needed for a buffer to hold a longlong or ulonglong + end \0 */
#define LONGLONG_BUFFER_SIZE 21
#if defined(HAVE_LONG_LONG) && !defined(ULONGLONG_MAX)
/* First check for ANSI C99 definition: */
#ifdef ULLONG_MAX
#define ULONGLONG_MAX ULLONG_MAX
#else
#define ULONGLONG_MAX ((unsigned long long)(~0ULL))
#endif
#endif /* defined (HAVE_LONG_LONG) && !defined(ULONGLONG_MAX)*/
#define INT_MIN64 (~0x7FFFFFFFFFFFFFFFLL)
#define INT_MAX64 0x7FFFFFFFFFFFFFFFLL
#define INT_MIN32 (~0x7FFFFFFFL)
#define INT_MAX32 0x7FFFFFFFL
#define UINT_MAX32 0xFFFFFFFFL
#define INT_MIN24 (~0x007FFFFF)
#define INT_MAX24 0x007FFFFF
#define UINT_MAX24 0x00FFFFFF
#define INT_MIN16 (~0x7FFF)
#define INT_MAX16 0x7FFF
#define UINT_MAX16 0xFFFF
#define INT_MIN8 (~0x7F)
#define INT_MAX8 0x7F
#define UINT_MAX8 0xFF
/* From limits.h instead */
#ifndef DBL_MIN
#define DBL_MIN 4.94065645841246544e-324
#define FLT_MIN ((float)1.40129846432481707e-45)
#endif
#ifndef DBL_MAX
#define DBL_MAX 1.79769313486231470e+308
#define FLT_MAX ((float)3.40282346638528860e+38)
#endif
#ifndef SIZE_T_MAX
#define SIZE_T_MAX (~((size_t) 0))
#endif
/* Define missing math constants. */
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#ifndef M_E
#define M_E 2.7182818284590452354
#endif
#ifndef M_LN2
#define M_LN2 0.69314718055994530942
#endif
/*
Max size that must be added to a so that we know Size to make
addressable obj.
*/
#if SIZEOF_CHARP == 4
typedef long my_ptrdiff_t;
#else
typedef long long my_ptrdiff_t;
#endif
#define MY_ALIGN(A,L) (((A) + (L) - 1) & ~((L) - 1))
#define MY_ALIGN_DOWN(A,L) ((A) & ~((L) - 1))
#define ALIGN_SIZE(A) MY_ALIGN((A),sizeof(double))
#define ALIGN_MAX_UNIT (sizeof(double))
/* Size to make addressable obj. */
#define ALIGN_PTR(A, t) ((t*) MY_ALIGN((A), sizeof(double)))
#define ADD_TO_PTR(ptr,size,type) (type) ((uchar*) (ptr)+size)
#define PTR_BYTE_DIFF(A,B) (my_ptrdiff_t) ((uchar*) (A) - (uchar*) (B))
/*
Custom version of standard offsetof() macro which can be used to get
offsets of members in class for non-POD types (according to the current
version of C++ standard offsetof() macro can't be used in such cases and
attempt to do so causes warnings to be emitted, OTOH in many cases it is
still OK to assume that all instances of the class has the same offsets
for the same members).
This is temporary solution which should be removed once File_parser class
and related routines are refactored.
*/
#define my_offsetof(TYPE, MEMBER) PTR_BYTE_DIFF(&((TYPE *)0x10)->MEMBER, 0x10)
#define NullS (char *) 0
#ifdef STDCALL
#undef STDCALL
#endif
#ifdef _WIN32
#define STDCALL __stdcall
#else
#define STDCALL
#endif
/* Typdefs for easier portability */
#ifndef HAVE_UCHAR
typedef unsigned char uchar; /* Short for unsigned char */
#endif
#ifndef HAVE_INT8
typedef signed char int8; /* Signed integer >= 8 bits */
#endif
#ifndef HAVE_UINT8
typedef unsigned char uint8; /* Unsigned integer >= 8 bits */
#endif
#ifndef HAVE_INT16
typedef short int16;
#endif
#ifndef HAVE_UINT16
typedef unsigned short uint16;
#endif
#if SIZEOF_INT == 4
#ifndef HAVE_INT32
typedef int int32;
#endif
#ifndef HAVE_UINT32
typedef unsigned int uint32;
#endif
#elif SIZEOF_LONG == 4
#ifndef HAVE_INT32
typedef long int32;
#endif
#ifndef HAVE_UINT32
typedef unsigned long uint32;
#endif
#else
#error Neither int or long is of 4 bytes width
#endif
#if !defined(HAVE_ULONG) && !defined(__USE_MISC)
typedef unsigned long ulong; /* Short for unsigned long */
#endif
#ifndef longlong_defined
/*
Using [unsigned] long long is preferable as [u]longlong because we use
[unsigned] long long unconditionally in many places,
for example in constants with [U]LL suffix.
*/
#if defined(HAVE_LONG_LONG) && SIZEOF_LONG_LONG == 8
typedef unsigned long long int ulonglong; /* ulong or unsigned long long */
typedef long long int longlong;
#else
typedef unsigned long ulonglong; /* ulong or unsigned long long */
typedef long longlong;
#endif
#endif
#ifndef HAVE_INT64
typedef longlong int64;
#endif
#ifndef HAVE_UINT64
typedef ulonglong uint64;
#endif
#if defined(NO_CLIENT_LONG_LONG)
typedef unsigned long my_ulonglong;
#elif defined (_WIN32)
typedef unsigned __int64 my_ulonglong;
#else
typedef unsigned long long my_ulonglong;
#endif
#if SIZEOF_CHARP == SIZEOF_INT
typedef unsigned int intptr;
#elif SIZEOF_CHARP == SIZEOF_LONG
typedef unsigned long intptr;
#elif SIZEOF_CHARP == SIZEOF_LONG_LONG
typedef unsigned long long intptr;
#else
#error sizeof(void *) is neither sizeof(int) nor sizeof(long) nor sizeof(long long)
#endif
#define MY_ERRPTR ((void*)(intptr)1)
#if defined(_WIN32)
typedef unsigned long long my_off_t;
typedef unsigned long long os_off_t;
#else
typedef off_t os_off_t;
#if SIZEOF_OFF_T > 4
typedef ulonglong my_off_t;
#else
typedef unsigned long my_off_t;
#endif
#endif /*_WIN32*/
#define MY_FILEPOS_ERROR (~(my_off_t) 0)
/*
TODO Convert these to use Bitmap class.
*/
typedef ulonglong table_map; /* Used for table bits in join */
/* often used type names - opaque declarations */
typedef const struct charset_info_st CHARSET_INFO;
typedef struct st_mysql_lex_string LEX_STRING;
#if defined(_WIN32)
#define socket_errno WSAGetLastError()
#define SOCKET_EINTR WSAEINTR
#define SOCKET_ETIMEDOUT WSAETIMEDOUT
#define SOCKET_EWOULDBLOCK WSAEWOULDBLOCK
#define SOCKET_EADDRINUSE WSAEADDRINUSE
#define SOCKET_ECONNRESET WSAECONNRESET
#define SOCKET_ENFILE ENFILE
#define SOCKET_EMFILE EMFILE
#define SOCKET_CLOSED EIO
#else /* Unix */
#define socket_errno errno
#define closesocket(A) close(A)
#define SOCKET_EINTR EINTR
#define SOCKET_EAGAIN EAGAIN
#define SOCKET_EWOULDBLOCK EWOULDBLOCK
#define SOCKET_EADDRINUSE EADDRINUSE
#define SOCKET_ETIMEDOUT ETIMEDOUT
#define SOCKET_ECONNRESET ECONNRESET
#define SOCKET_CLOSED EIO
#define SOCKET_ENFILE ENFILE
#define SOCKET_EMFILE EMFILE
#endif
#include /* my_bool */
typedef ulong myf; /* Type of MyFlags in my_funcs */
#define MYF(v) (myf) (v)
/*
Defines to make it possible to prioritize register assignments. No
longer that important with modern compilers.
*/
#ifndef USING_X
#define reg1 register
#define reg2 register
#define reg3 register
#define reg4 register
#define reg5 register
#define reg6 register
#define reg7 register
#define reg8 register
#define reg9 register
#define reg10 register
#define reg11 register
#define reg12 register
#define reg13 register
#define reg14 register
#define reg15 register
#define reg16 register
#endif
/*
MYSQL_PLUGIN_IMPORT macro is used to export mysqld data
(i.e variables) for usage in storage engine loadable plugins.
Outside of Windows, it is dummy.
*/
#ifndef MYSQL_PLUGIN_IMPORT
#if (defined(_WIN32) && defined(MYSQL_DYNAMIC_PLUGIN))
#define MYSQL_PLUGIN_IMPORT __declspec(dllimport)
#else
#define MYSQL_PLUGIN_IMPORT
#endif
#endif
#include
/* Some helper macros */
#define YESNO(X) ((X) ? "yes" : "no")
#define MY_HOW_OFTEN_TO_ALARM 2 /* How often we want info on screen */
#define MY_HOW_OFTEN_TO_WRITE 100000 /* How often we want info on screen */
#include
#ifdef HAVE_CHARSET_utf8mb4
#define MYSQL_UNIVERSAL_CLIENT_CHARSET "utf8mb4"
#elif defined(HAVE_CHARSET_utf8mb3)
#define MYSQL_UNIVERSAL_CLIENT_CHARSET "utf8mb3"
#else
#define MYSQL_UNIVERSAL_CLIENT_CHARSET MYSQL_DEFAULT_CHARSET_NAME
#endif
#if defined(EMBEDDED_LIBRARY) && !defined(HAVE_EMBEDDED_PRIVILEGE_CONTROL)
#define NO_EMBEDDED_ACCESS_CHECKS
#endif
#ifdef _WIN32
#define dlsym(lib, name) (void*)GetProcAddress((HMODULE)lib, name)
#define dlopen(libname, unused) LoadLibraryEx(libname, NULL, 0)
#define RTLD_DEFAULT GetModuleHandle(NULL)
#define dlclose(lib) FreeLibrary((HMODULE)lib)
static inline char *dlerror(void)
{
static char win_errormsg[2048];
FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS |
FORMAT_MESSAGE_MAX_WIDTH_MASK,
0, GetLastError(),
MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
win_errormsg, 2048, NULL);
return win_errormsg;
}
#define HAVE_DLOPEN 1
#define HAVE_DLERROR 1
#endif
#ifdef HAVE_DLFCN_H
#include
#endif
#ifdef HAVE_DLOPEN
#ifndef HAVE_DLERROR
#define dlerror() ""
#endif
#ifndef HAVE_DLADDR
#define dladdr(A, B) 0
/* Dummy definition in case we're missing dladdr() */
typedef struct { const char *dli_fname, dli_fbase; } Dl_info;
#endif
#else
#define dlerror() "No support for dynamic loading (static build?)"
#define dlopen(A,B) 0
#define dlsym(A,B) 0
#define dlclose(A) 0
#define dladdr(A, B) 0
/* Dummy definition in case we're missing dladdr() */
typedef struct { const char *dli_fname, dli_fbase; } Dl_info;
#endif
/*
* Include standard definitions of operator new and delete.
*/
#ifdef __cplusplus
#include
#endif
/* Length of decimal number represented by INT32. */
#define MY_INT32_NUM_DECIMAL_DIGITS 11
/* Length of decimal number represented by INT64. */
#define MY_INT64_NUM_DECIMAL_DIGITS 21
#ifdef __cplusplus
#include /* should be included before min/max macros */
#endif
/* Define some useful general macros (should be done after all headers). */
#define MY_MAX(a, b) ((a) > (b) ? (a) : (b))
#define MY_MIN(a, b) ((a) < (b) ? (a) : (b))
#define CMP_NUM(a,b) (((a) < (b)) ? -1 : ((a) == (b)) ? 0 : 1)
/*
Only Linux is known to need an explicit sync of the directory to make sure a
file creation/deletion/renaming in(from,to) this directory durable.
*/
#ifdef TARGET_OS_LINUX
#define NEED_EXPLICIT_SYNC_DIR 1
#else
/*
On linux default rwlock scheduling policy is good enough for
waiting_threads.c, on other systems use our special implementation
(which is slower).
QQ perhaps this should be tested in configure ? how ?
*/
#define WT_RWLOCKS_USE_MUTEXES 1
#endif
#if !defined(__cplusplus) && !defined(bool)
#define bool In_C_you_should_use_my_bool_instead()
#endif
/* Provide __func__ macro definition for platforms that miss it. */
#if !defined (__func__)
#if defined(__STDC_VERSION__) && __STDC_VERSION__ < 199901L
# if __GNUC__ >= 2
# define __func__ __FUNCTION__
# else
# define __func__ ""
# endif
#elif defined(_MSC_VER)
# if _MSC_VER < 1300
# define __func__ ""
# else
# define __func__ __FUNCTION__
# endif
#elif defined(__BORLANDC__)
# define __func__ __FUNC__
#else
# define __func__ ""
#endif
#endif /* !defined(__func__) */
/* Defines that are unique to the embedded version of MySQL */
#ifdef EMBEDDED_LIBRARY
/* Things we don't need in the embedded version of MySQL */
/* TODO HF add #undef HAVE_VIO if we don't want client in embedded library */
#else
#define HAVE_REPLICATION
#define HAVE_EXTERNAL_CLIENT
#endif /* EMBEDDED_LIBRARY */
/*
Provide defaults for the CPU cache line size, if it has not been detected by
CMake using getconf
*/
#if !defined(CPU_LEVEL1_DCACHE_LINESIZE) || CPU_LEVEL1_DCACHE_LINESIZE == 0
#if defined(CPU_LEVEL1_DCACHE_LINESIZE) && CPU_LEVEL1_DCACHE_LINESIZE == 0
#undef CPU_LEVEL1_DCACHE_LINESIZE
#endif
#if defined(__s390__)
#define CPU_LEVEL1_DCACHE_LINESIZE 256
#elif defined(__powerpc__) || defined(__aarch64__)
#define CPU_LEVEL1_DCACHE_LINESIZE 128
#else
#define CPU_LEVEL1_DCACHE_LINESIZE 64
#endif
#endif
#define FLOATING_POINT_DECIMALS 31
/* Keep client compatible with earlier versions */
#ifdef MYSQL_SERVER
#define NOT_FIXED_DEC DECIMAL_NOT_SPECIFIED
#else
#define NOT_FIXED_DEC FLOATING_POINT_DECIMALS
#endif
#endif /* my_global_h */
PK ! mysql/service_print_check_msg.hnu [ /* Copyright (c) 2019, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#pragma once
/**
@file include/mysql/service_print_check_msg.h
This service provides functions to write messages for check or repair
*/
#ifdef __cplusplus
extern "C" {
#endif
extern struct print_check_msg_service_st {
void (*print_check_msg)(MYSQL_THD, const char *db_name, const char *table_name,
const char *op, const char *msg_type, const char *message,
my_bool print_to_log);
} *print_check_msg_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
# define print_check_msg_context(_THD) print_check_msg_service->print_check_msg
#else
extern void print_check_msg(MYSQL_THD, const char *db_name, const char *table_name,
const char *op, const char *msg_type, const char *message,
my_bool print_to_log);
#endif
#ifdef __cplusplus
}
#endif
PK ! Q7" " mysql/service_encryption.hnu [ #ifndef MYSQL_SERVICE_ENCRYPTION_INCLUDED
/* Copyright (c) 2015, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
encryption service
Functions to support data encryption and encryption key management.
They are normally implemented in an encryption plugin, so this service
connects encryption *consumers* (e.g. storage engines) to the encryption
*provider* (encryption plugin).
*/
#ifndef MYSQL_ABI_CHECK
#include
#ifdef _WIN32
#ifndef __cplusplus
#define inline __inline
#endif
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MYSQL_ABI_CHECK
#include
#endif
/* returned from encryption_key_get_latest_version() */
#define ENCRYPTION_KEY_VERSION_INVALID (~(unsigned int)0)
#define ENCRYPTION_KEY_NOT_ENCRYPTED (0)
#define ENCRYPTION_KEY_SYSTEM_DATA 1
#define ENCRYPTION_KEY_TEMPORARY_DATA 2
/* returned from encryption_key_get() */
#define ENCRYPTION_KEY_BUFFER_TOO_SMALL (100)
#define ENCRYPTION_FLAG_DECRYPT 0
#define ENCRYPTION_FLAG_ENCRYPT 1
#define ENCRYPTION_FLAG_NOPAD 2
struct encryption_service_st {
unsigned int (*encryption_key_get_latest_version_func)(unsigned int key_id);
unsigned int (*encryption_key_get_func)(unsigned int key_id, unsigned int key_version,
unsigned char* buffer, unsigned int* length);
unsigned int (*encryption_ctx_size_func)(unsigned int key_id, unsigned int key_version);
int (*encryption_ctx_init_func)(void *ctx, const unsigned char* key, unsigned int klen,
const unsigned char* iv, unsigned int ivlen,
int flags, unsigned int key_id,
unsigned int key_version);
int (*encryption_ctx_update_func)(void *ctx, const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen);
int (*encryption_ctx_finish_func)(void *ctx, unsigned char* dst, unsigned int* dlen);
unsigned int (*encryption_encrypted_length_func)(unsigned int slen, unsigned int key_id, unsigned int key_version);
};
#ifdef MYSQL_DYNAMIC_PLUGIN
extern struct encryption_service_st *encryption_service;
#define encryption_key_get_latest_version(KI) encryption_service->encryption_key_get_latest_version_func(KI)
#define encryption_key_get(KI,KV,K,S) encryption_service->encryption_key_get_func((KI),(KV),(K),(S))
#define encryption_ctx_size(KI,KV) encryption_service->encryption_ctx_size_func((KI),(KV))
#define encryption_ctx_init(CTX,K,KL,IV,IVL,F,KI,KV) encryption_service->encryption_ctx_init_func((CTX),(K),(KL),(IV),(IVL),(F),(KI),(KV))
#define encryption_ctx_update(CTX,S,SL,D,DL) encryption_service->encryption_ctx_update_func((CTX),(S),(SL),(D),(DL))
#define encryption_ctx_finish(CTX,D,DL) encryption_service->encryption_ctx_finish_func((CTX),(D),(DL))
#define encryption_encrypted_length(SL,KI,KV) encryption_service->encryption_encrypted_length_func((SL),(KI),(KV))
#else
extern struct encryption_service_st encryption_handler;
#define encryption_key_get_latest_version(KI) encryption_handler.encryption_key_get_latest_version_func(KI)
#define encryption_key_get(KI,KV,K,S) encryption_handler.encryption_key_get_func((KI),(KV),(K),(S))
#define encryption_ctx_size(KI,KV) encryption_handler.encryption_ctx_size_func((KI),(KV))
#define encryption_ctx_init(CTX,K,KL,IV,IVL,F,KI,KV) encryption_handler.encryption_ctx_init_func((CTX),(K),(KL),(IV),(IVL),(F),(KI),(KV))
#define encryption_ctx_update(CTX,S,SL,D,DL) encryption_handler.encryption_ctx_update_func((CTX),(S),(SL),(D),(DL))
#define encryption_ctx_finish(CTX,D,DL) encryption_handler.encryption_ctx_finish_func((CTX),(D),(DL))
#define encryption_encrypted_length(SL,KI,KV) encryption_handler.encryption_encrypted_length_func((SL),(KI),(KV))
#endif
static inline unsigned int encryption_key_id_exists(unsigned int id)
{
return encryption_key_get_latest_version(id) != ENCRYPTION_KEY_VERSION_INVALID;
}
static inline unsigned int encryption_key_version_exists(unsigned int id, unsigned int version)
{
unsigned int unused;
return encryption_key_get(id, version, NULL, &unused) != ENCRYPTION_KEY_VERSION_INVALID;
}
/** main entrypoint to perform encryption or decryption
* @invariant `src` is valid for `slen`
* @invariant `dst` is valid for `*dlen`, `*dlen` is initialized
* @invariant `src` and `dst` do not overlap
*/
static inline int encryption_crypt(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
const unsigned char* key, unsigned int klen,
const unsigned char* iv, unsigned int ivlen,
int flags, unsigned int key_id, unsigned int key_version)
{
void *ctx= alloca(encryption_ctx_size(key_id, key_version));
int res1, res2;
unsigned int d1, d2= *dlen;
// Verify dlen is initialized properly. See MDEV-30389
assert(*dlen >= slen);
assert((dst[*dlen - 1]= 1) == 1);
// Verify buffers do not overlap
if (src < dst)
assert(src + slen <= dst);
else
assert(dst + *dlen <= src);
if ((res1= encryption_ctx_init(ctx, key, klen, iv, ivlen, flags, key_id, key_version)))
return res1;
res1= encryption_ctx_update(ctx, src, slen, dst, &d1);
d2-= d1;
res2= encryption_ctx_finish(ctx, dst + d1, &d2);
*dlen= d1 + d2;
return res1 ? res1 : res2;
}
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_ENCRYPTION_INCLUDED
#endif
PK ! 2b
#endif
/* Allow multiple chunks 'AAA= AA== AA==', binlog uses this */
#define MY_BASE64_DECODE_ALLOW_MULTIPLE_CHUNKS 1
extern struct base64_service_st {
int (*base64_needed_encoded_length_ptr)(int length_of_data);
int (*base64_encode_max_arg_length_ptr)(void);
int (*base64_needed_decoded_length_ptr)(int length_of_encoded_data);
int (*base64_decode_max_arg_length_ptr)();
int (*base64_encode_ptr)(const void *src, size_t src_len, char *dst);
int (*base64_decode_ptr)(const char *src, size_t src_len,
void *dst, const char **end_ptr, int flags);
} *base64_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define my_base64_needed_encoded_length(A) base64_service->base64_needed_encoded_length_ptr(A)
#define my_base64_encode_max_arg_length() base64_service->base64_encode_max_arg_length_ptr()
#define my_base64_needed_decoded_length(A) base64_service->base64_needed_decoded_length_ptr(A)
#define my_base64_decode_max_arg_length() base64_service->base64_decode_max_arg_length_ptr()
#define my_base64_encode(A,B,C) base64_service->base64_encode_ptr(A,B,C)
#define my_base64_decode(A,B,C,D,E) base64_service->base64_decode_ptr(A,B,C,D,E)
#else
/* Calculate how much memory needed for dst of my_base64_encode() */
int my_base64_needed_encoded_length(int length_of_data);
/* Maximum length my_base64_encode_needed_length() can accept with no overflow. */
int my_base64_encode_max_arg_length(void);
/* Calculate how much memory needed for dst of my_base64_decode() */
int my_base64_needed_decoded_length(int length_of_encoded_data);
/* Maximum length my_base64_decode_needed_length() can accept with no overflow. */
int my_base64_decode_max_arg_length();
/* Encode data as a my_base64 string */
int my_base64_encode(const void *src, size_t src_len, char *dst);
/* Decode a my_base64 string into data */
int my_base64_decode(const char *src, size_t src_len,
void *dst, const char **end_ptr, int flags);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_BASE64_INCLUDED
#endif
PK ! 5> mysql/service_my_snprintf.hnu [ #ifndef MYSQL_SERVICE_MY_SNPRINTF_INCLUDED
/* Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
my_snprintf service
Portable and limited vsnprintf() implementation.
This is a portable, limited vsnprintf() implementation, with some
extra features. "Portable" means that it'll produce identical result
on all platforms (for example, on Windows and Linux system printf %e
formats the exponent differently, on different systems %p either
prints leading 0x or not, %s may accept null pointer or crash on
it). "Limited" means that it does not support all the C89 features.
But it supports few extensions, not in any standard.
my_vsnprintf(to, n, fmt, ap)
@param[out] to A buffer to store the result in
@param[in] n Store up to n-1 characters, followed by an end 0
@param[in] fmt printf-like format string
@param[in] ap Arguments
@return a number of bytes written to a buffer *excluding* terminating '\0'
@post
The syntax of a format string is generally the same:
%
where everything but the format is optional.
Three one-character flags are recognized:
'0' has the standard zero-padding semantics;
'-' is parsed, but silently ignored;
'`' (backtick) is only supported for strings (%s) and means that the
string will be quoted according to MySQL identifier quoting rules.
Both and can be specified as numbers or '*'.
If an asterisk is used, an argument of type int is consumed.
can be 'l', 'll', or 'z'.
Supported formats are 's' (null pointer is accepted, printed as
"(null)"), 'b' (extension, see below), 'c', 'd', 'i', 'u', 'x', 'o',
'X', 'p' (works as 0x%x), 'f', 'g', 'M' (extension, see below),
'T' (extension, see below).
Standard syntax for positional arguments $n is supported.
Extensions:
Flag '`' (backtick): see above.
Format 'b': binary buffer, prints exactly bytes from the
argument, without stopping at '\0'.
Format 'M': takes one integer, prints this integer, space, double quote
error message, double quote. In other words
printf("%M", n) === printf("%d \"%s\"", n, strerror(n))
Format 'T': takes string and print it like s but if the strints should be
truncated puts "..." at the end.
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MYSQL_ABI_CHECK
#include
#include
#endif
extern struct my_snprintf_service_st {
size_t (*my_snprintf_type)(char*, size_t, const char*, ...);
size_t (*my_vsnprintf_type)(char *, size_t, const char*, va_list);
} *my_snprintf_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define my_vsnprintf my_snprintf_service->my_vsnprintf_type
#define my_snprintf my_snprintf_service->my_snprintf_type
#else
size_t my_snprintf(char* to, size_t n, const char* fmt, ...);
size_t my_vsnprintf(char *to, size_t n, const char* fmt, va_list ap);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_MY_SNPRINTF_INCLUDED
#endif
PK ! | mysql/service_thd_timezone.hnu [ #ifndef MYSQL_SERVICE_THD_TIMEZONE_INCLUDED
/* Copyright (C) 2013 MariaDB Foundation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
This service provides functions to convert between my_time_t and
MYSQL_TIME taking into account the current value of the time_zone
session variable.
The values of the my_time_t type are in Unix timestamp format,
i.e. the number of seconds since "1970-01-01 00:00:00 UTC".
The values of the MYSQL_TIME type are in the current time zone,
according to thd->variables.time_zone.
If the MYSQL_THD parameter is NULL, then global_system_variables.time_zone
is used for conversion.
*/
#ifndef MYSQL_ABI_CHECK
/*
This service currently does not depend on any system headers.
If it needs system headers in the future, make sure to put
them inside this ifndef.
*/
#endif
#include "mysql_time.h"
#ifdef __cplusplus
extern "C" {
#endif
extern struct thd_timezone_service_st {
my_time_t (*thd_TIME_to_gmt_sec)(MYSQL_THD thd, const MYSQL_TIME *ltime, unsigned int *errcode);
void (*thd_gmt_sec_to_TIME)(MYSQL_THD thd, MYSQL_TIME *ltime, my_time_t t);
} *thd_timezone_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define thd_TIME_to_gmt_sec(thd, ltime, errcode) \
(thd_timezone_service->thd_TIME_to_gmt_sec((thd), (ltime), (errcode)))
#define thd_gmt_sec_to_TIME(thd, ltime, t) \
(thd_timezone_service->thd_gmt_sec_to_TIME((thd), (ltime), (t)))
#else
my_time_t thd_TIME_to_gmt_sec(MYSQL_THD thd, const MYSQL_TIME *ltime, unsigned int *errcode);
void thd_gmt_sec_to_TIME(MYSQL_THD thd, MYSQL_TIME *ltime, my_time_t t);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_THD_TIMEZONE_INCLUDED
#endif
PK ! 8A" mysql/service_thd_mdl.hnu [ /* Copyright (c) 2019, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#pragma once
/**
@file include/mysql/service_thd_mdl.h
This service provides functions for plugins and storage engines to access
metadata locks.
*/
#ifdef __cplusplus
extern "C" {
#endif
extern struct thd_mdl_service_st {
void *(*thd_mdl_context)(MYSQL_THD);
} *thd_mdl_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
# define thd_mdl_context(_THD) thd_mdl_service->thd_mdl_context(_THD)
#else
/**
MDL_context accessor
@param thd the current session
@return pointer to thd->mdl_context
*/
void *thd_mdl_context(MYSQL_THD thd);
#endif
#ifdef __cplusplus
}
#endif
PK ! qa a mysql/service_log_warnings.hnu [ /* Copyright (c) 2013, 2018, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_SERVICE_LOG_WARNINGS
#define MYSQL_SERVICE_LOG_WARNINGS
/**
@file
This service provides access to the log warning level for the
current session.
thd_log_warnings(thd)
@return thd->log_warnings
*/
#ifdef __cplusplus
extern "C" {
#endif
extern struct thd_log_warnings_service_st {
void *(*thd_log_warnings)(MYSQL_THD);
} *thd_log_warnings_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
# define thd_log_warnings(THD) thd_log_warnings_service->thd_log_warnings(THD)
#else
/**
MDL_context accessor
@param thd the current session
@return pointer to thd->mdl_context
*/
int thd_log_warnings(MYSQL_THD thd);
#endif
#ifdef __cplusplus
}
#endif
#endif
PK ! <4 mysql/services.hnu [ #ifndef MYSQL_SERVICES_INCLUDED
/* Copyright (c) 2009, 2010, Oracle and/or its affiliates.
Copyright (c) 2012, 2017, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifdef __cplusplus
extern "C" {
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
/*#include */
#include
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICES_INCLUDED
#endif
PK ! l`X@ mysql/plugin_audit.hnu [ /* Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2 of
the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _my_audit_h
#define _my_audit_h
/*************************************************************************
API for Audit plugin. (MYSQL_AUDIT_PLUGIN)
*/
#include "plugin.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MYSQL_AUDIT_CLASS_MASK_SIZE 1
#define MYSQL_AUDIT_INTERFACE_VERSION 0x0302
/*************************************************************************
AUDIT CLASS : GENERAL
LOG events occurs before emitting to the general query log.
ERROR events occur before transmitting errors to the user.
RESULT events occur after transmitting a resultset to the user.
STATUS events occur after transmitting a resultset or errors
to the user.
*/
#define MYSQL_AUDIT_GENERAL_CLASS 0
#define MYSQL_AUDIT_GENERAL_CLASSMASK (1 << MYSQL_AUDIT_GENERAL_CLASS)
#define MYSQL_AUDIT_GENERAL_LOG 0
#define MYSQL_AUDIT_GENERAL_ERROR 1
#define MYSQL_AUDIT_GENERAL_RESULT 2
#define MYSQL_AUDIT_GENERAL_STATUS 3
#define MYSQL_AUDIT_GENERAL_WARNING 4
struct mysql_event_general
{
unsigned int event_subclass;
int general_error_code;
unsigned long general_thread_id;
const char *general_user;
unsigned int general_user_length;
const char *general_command;
unsigned int general_command_length;
const char *general_query;
unsigned int general_query_length;
const struct charset_info_st *general_charset;
unsigned long long general_time;
unsigned long long general_rows;
/* Added in version 0x302 */
unsigned long long query_id;
MYSQL_CONST_LEX_STRING database;
};
/*
AUDIT CLASS : CONNECTION
CONNECT occurs after authentication phase is completed.
DISCONNECT occurs after connection is terminated.
CHANGE_USER occurs after COM_CHANGE_USER RPC is completed.
*/
#define MYSQL_AUDIT_CONNECTION_CLASS 1
#define MYSQL_AUDIT_CONNECTION_CLASSMASK (1 << MYSQL_AUDIT_CONNECTION_CLASS)
#define MYSQL_AUDIT_CONNECTION_CONNECT 0
#define MYSQL_AUDIT_CONNECTION_DISCONNECT 1
#define MYSQL_AUDIT_CONNECTION_CHANGE_USER 2
struct mysql_event_connection
{
unsigned int event_subclass;
int status;
unsigned long thread_id;
const char *user;
unsigned int user_length;
const char *priv_user;
unsigned int priv_user_length;
const char *external_user;
unsigned int external_user_length;
const char *proxy_user;
unsigned int proxy_user_length;
const char *host;
unsigned int host_length;
const char *ip;
unsigned int ip_length;
MYSQL_CONST_LEX_STRING database;
};
/*
AUDIT CLASS : TABLE
LOCK occurs when a connection "locks" (this does not necessarily mean a table
lock and also happens for row-locking engines) the table at the beginning of
a statement. This event is generated at the beginning of every statement for
every affected table, unless there's a LOCK TABLES statement in effect (in
which case it is generated once for LOCK TABLES and then is suppressed until
the tables are unlocked).
CREATE/DROP/RENAME occur when a table is created, dropped, or renamed.
*/
#define MYSQL_AUDIT_TABLE_CLASS 15
#define MYSQL_AUDIT_TABLE_CLASSMASK (1 << MYSQL_AUDIT_TABLE_CLASS)
#define MYSQL_AUDIT_TABLE_LOCK 0
#define MYSQL_AUDIT_TABLE_CREATE 1
#define MYSQL_AUDIT_TABLE_DROP 2
#define MYSQL_AUDIT_TABLE_RENAME 3
#define MYSQL_AUDIT_TABLE_ALTER 4
struct mysql_event_table
{
unsigned int event_subclass;
unsigned long thread_id;
const char *user;
const char *priv_user;
const char *priv_host;
const char *external_user;
const char *proxy_user;
const char *host;
const char *ip;
MYSQL_CONST_LEX_STRING database;
MYSQL_CONST_LEX_STRING table;
/* for MYSQL_AUDIT_TABLE_RENAME */
MYSQL_CONST_LEX_STRING new_database;
MYSQL_CONST_LEX_STRING new_table;
/* for MYSQL_AUDIT_TABLE_LOCK, true if read-only, false if read/write */
int read_only;
/* Added in version 0x302 */
unsigned long long query_id;
};
/*************************************************************************
Here we define the descriptor structure, that is referred from
st_mysql_plugin.
release_thd() event occurs when the event class consumer is to be
disassociated from the specified THD. This would typically occur
before some operation which may require sleeping - such as when
waiting for the next query from the client.
event_notify() is invoked whenever an event occurs which is of any
class for which the plugin has interest. The second argument
indicates the specific event class and the third argument is data
as required for that class.
class_mask is an array of bits used to indicate what event classes
that this plugin wants to receive.
*/
struct st_mysql_audit
{
int interface_version;
void (*release_thd)(MYSQL_THD);
void (*event_notify)(MYSQL_THD, unsigned int, const void *);
unsigned long class_mask[MYSQL_AUDIT_CLASS_MASK_SIZE];
};
#ifdef __cplusplus
}
#endif
#endif
PK ! <" ! mysql/service_encryption_scheme.hnu [ #ifndef MYSQL_SERVICE_ENCRYPTION_SCHEME_INCLUDED
/* Copyright (c) 2015, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
encryption scheme service
A higher-level access to encryption service.
This is a helper service that storage engines use to encrypt tables on disk.
It requests keys from the plugin, generates temporary or local keys
from the global (as returned by the plugin) keys, etc.
To use the service:
* st_encryption_scheme object is created per space. A "space" can be
a table space in XtraDB/InnoDB, a file in Aria, etc. The whole
space is encrypted with the one key id.
* The service does not take the key and the IV as parameters for
encryption or decryption. Instead it takes two 32-bit integers and
one 64-bit integer (and requests the key from an encryption
plugin, if needed).
* The service requests the global key from the encryption plugin
automatically as needed. Three last keys are cached in the
st_encryption_scheme. Number of key requests (number of cache
misses) are counted in st_encryption_scheme::keyserver_requests
* If an st_encryption_scheme can be used concurrently by different
threads, it needs to be able to lock itself when accessing the key
cache. Set the st_encryption_scheme::locker appropriately. If
non-zero, it will be invoked by encrypt/decrypt functions to lock
and unlock the scheme when needed.
* Implementation details (in particular, key derivation) are defined
by the scheme type. Currently only schema type 1 is supported.
In the schema type 1, every "space" (table space in XtraDB/InnoDB,
file in Aria) is encrypted with a different space-local key:
* Every space has a 16-byte unique identifier (typically it's
generated randomly and stored in the space). The caller should
put it into st_encryption_scheme::iv.
* Space-local key is generated by encrypting this identifier with
the global encryption key (of the given id and version) using AES_ECB.
* Encryption/decryption parameters for a page are typically the
4-byte space id, 4-byte page position (offset, page number, etc),
and the 8-byte LSN. This guarantees that they'll be different for
any two pages (of the same or different tablespaces) and also that
they'll change for the same page when it's modified. They don't need
to be secret (they create the IV, not the encryption key).
*/
#ifdef __cplusplus
extern "C" {
#endif
#define ENCRYPTION_SCHEME_KEY_INVALID -1
#define ENCRYPTION_SCHEME_BLOCK_LENGTH 16
struct st_encryption_scheme_key {
unsigned int version;
unsigned char key[ENCRYPTION_SCHEME_BLOCK_LENGTH];
};
struct st_encryption_scheme {
unsigned char iv[ENCRYPTION_SCHEME_BLOCK_LENGTH];
struct st_encryption_scheme_key key[3];
unsigned int keyserver_requests;
unsigned int key_id;
unsigned int type;
void (*locker)(struct st_encryption_scheme *self, int release);
};
extern struct encryption_scheme_service_st {
int (*encryption_scheme_encrypt_func)
(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
struct st_encryption_scheme *scheme,
unsigned int key_version, unsigned int i32_1,
unsigned int i32_2, unsigned long long i64);
int (*encryption_scheme_decrypt_func)
(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
struct st_encryption_scheme *scheme,
unsigned int key_version, unsigned int i32_1,
unsigned int i32_2, unsigned long long i64);
} *encryption_scheme_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define encryption_scheme_encrypt(S,SL,D,DL,SCH,KV,I32,J32,I64) encryption_scheme_service->encryption_scheme_encrypt_func(S,SL,D,DL,SCH,KV,I32,J32,I64)
#define encryption_scheme_decrypt(S,SL,D,DL,SCH,KV,I32,J32,I64) encryption_scheme_service->encryption_scheme_decrypt_func(S,SL,D,DL,SCH,KV,I32,J32,I64)
#else
int encryption_scheme_encrypt(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
struct st_encryption_scheme *scheme,
unsigned int key_version, unsigned int i32_1,
unsigned int i32_2, unsigned long long i64);
int encryption_scheme_decrypt(const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen,
struct st_encryption_scheme *scheme,
unsigned int key_version, unsigned int i32_1,
unsigned int i32_2, unsigned long long i64);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_ENCRYPTION_SCHEME_INCLUDED
#endif
PK ! u?r r mysql/service_sha1.hnu [ #ifndef MYSQL_SERVICE_SHA1_INCLUDED
/* Copyright (c) 2013, 2014, Monty Program Ab
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
my sha1 service
Functions to calculate SHA1 hash from a memory buffer
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MYSQL_ABI_CHECK
#include
#endif
#define MY_SHA1_HASH_SIZE 20 /* Hash size in bytes */
extern struct my_sha1_service_st {
void (*my_sha1_type)(unsigned char*, const char*, size_t);
void (*my_sha1_multi_type)(unsigned char*, ...);
size_t (*my_sha1_context_size_type)();
void (*my_sha1_init_type)(void *);
void (*my_sha1_input_type)(void *, const unsigned char *, size_t);
void (*my_sha1_result_type)(void *, unsigned char *);
} *my_sha1_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define my_sha1(A,B,C) my_sha1_service->my_sha1_type(A,B,C)
#define my_sha1_multi my_sha1_service->my_sha1_multi_type
#define my_sha1_context_size() my_sha1_service->my_sha1_context_size_type()
#define my_sha1_init(A) my_sha1_service->my_sha1_init_type(A)
#define my_sha1_input(A,B,C) my_sha1_service->my_sha1_input_type(A,B,C)
#define my_sha1_result(A,B) my_sha1_service->my_sha1_result_type(A,B)
#else
void my_sha1(unsigned char*, const char*, size_t);
void my_sha1_multi(unsigned char*, ...);
size_t my_sha1_context_size();
void my_sha1_init(void *context);
void my_sha1_input(void *context, const unsigned char *buf, size_t len);
void my_sha1_result(void *context, unsigned char *digest);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_SHA1_INCLUDED
#endif
PK ! d mysql/service_kill_statement.hnu [ /* Copyright (c) 2013, 2018, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_SERVICE_KILL_STATEMENT_INCLUDED
#define MYSQL_SERVICE_KILL_STATEMENT_INCLUDED
/**
@file
This service provides functions that allow plugins to support
the KILL statement.
In MySQL support for the KILL statement is cooperative. The KILL
statement only sets a "killed" flag. This function returns the value
of that flag. A thread should check it often, especially inside
time-consuming loops, and gracefully abort the operation if it is
non-zero.
thd_killed(thd)
@return 0 - no KILL statement was issued, continue normally
@return 1 - there was a KILL statement, abort the execution.
thd_kill_level(thd)
@return thd_kill_levels_enum values
*/
#ifdef __cplusplus
extern "C" {
#endif
enum thd_kill_levels {
THD_IS_NOT_KILLED=0,
THD_ABORT_SOFTLY=50, /**< abort when possible, don't leave tables corrupted */
THD_ABORT_ASAP=100, /**< abort asap */
};
extern struct kill_statement_service_st {
enum thd_kill_levels (*thd_kill_level_func)(const MYSQL_THD);
} *thd_kill_statement_service;
/* backward compatibility helper */
#define thd_killed(THD) (thd_kill_level(THD) == THD_ABORT_ASAP)
#ifdef MYSQL_DYNAMIC_PLUGIN
#define thd_kill_level(THD) \
thd_kill_statement_service->thd_kill_level_func(THD)
#else
enum thd_kill_levels thd_kill_level(const MYSQL_THD);
#endif
#ifdef __cplusplus
}
#endif
#endif
PK ! sG G mysql/service_md5.hnu [ #ifndef MYSQL_SERVICE_MD5_INCLUDED
/* Copyright (c) 2014, Monty Program Ab
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
my md5 service
Functions to calculate MD5 hash from a memory buffer
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MYSQL_ABI_CHECK
#include
#endif
#define MY_MD5_HASH_SIZE 16 /* Hash size in bytes */
extern struct my_md5_service_st {
void (*my_md5_type)(unsigned char*, const char*, size_t);
void (*my_md5_multi_type)(unsigned char*, ...);
size_t (*my_md5_context_size_type)();
void (*my_md5_init_type)(void *);
void (*my_md5_input_type)(void *, const unsigned char *, size_t);
void (*my_md5_result_type)(void *, unsigned char *);
} *my_md5_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define my_md5(A,B,C) my_md5_service->my_md5_type(A,B,C)
#define my_md5_multi my_md5_service->my_md5_multi_type
#define my_md5_context_size() my_md5_service->my_md5_context_size_type()
#define my_md5_init(A) my_md5_service->my_md5_init_type(A)
#define my_md5_input(A,B,C) my_md5_service->my_md5_input_type(A,B,C)
#define my_md5_result(A,B) my_md5_service->my_md5_result_type(A,B)
#else
void my_md5(unsigned char*, const char*, size_t);
void my_md5_multi(unsigned char*, ...);
size_t my_md5_context_size();
void my_md5_init(void *context);
void my_md5_input(void *context, const unsigned char *buf, size_t len);
void my_md5_result(void *context, unsigned char *digest);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_MD5_INCLUDED
#endif
PK ! T A mysql/psi/mysql_thread.hnu [ /* Copyright (c) 2008, 2023, Oracle and/or its affiliates.
Copyright (c) 2020, 2021, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_THREAD_H
#define MYSQL_THREAD_H
/**
@file mysql/psi/mysql_thread.h
Instrumentation helpers for mysys threads, mutexes,
read write locks and conditions.
This header file provides the necessary declarations
to use the mysys thread API with the performance schema instrumentation.
In some compilers (SunStudio), 'static inline' functions, when declared
but not used, are not optimized away (because they are unused) by default,
so that including a static inline function from a header file does
create unwanted dependencies, causing unresolved symbols at link time.
Other compilers, like gcc, optimize these dependencies by default.
Since the instrumented APIs declared here are wrapper on top
of my_pthread / safemutex / etc APIs,
including mysql/psi/mysql_thread.h assumes that
the dependency on my_pthread and safemutex already exists.
*/
/*
Note: there are several orthogonal dimensions here.
Dimension 1: Instrumentation
HAVE_PSI_INTERFACE is defined when the instrumentation is compiled in.
This may happen both in debug or production builds.
Dimension 2: Debug
SAFE_MUTEX is defined when debug is compiled in.
This may happen both with and without instrumentation.
Dimension 3: Platform
Mutexes are implemented with one of:
- the pthread library
- fast mutexes
- window apis
This is implemented by various macro definitions in my_pthread.h
This causes complexity with '#ifdef'-ery that can't be avoided.
*/
#include "mysql/psi/psi.h"
#ifdef MYSQL_SERVER
#ifndef MYSQL_DYNAMIC_PLUGIN
#include "pfs_thread_provider.h"
#endif
#endif
#ifndef PSI_MUTEX_CALL
#define PSI_MUTEX_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
#ifndef PSI_RWLOCK_CALL
#define PSI_RWLOCK_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
#ifndef PSI_COND_CALL
#define PSI_COND_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
#ifndef PSI_THREAD_CALL
#define PSI_THREAD_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
/**
@defgroup Thread_instrumentation Thread Instrumentation
@ingroup Instrumentation_interface
@{
*/
#ifdef HAVE_PSI_THREAD_INTERFACE
#define PSI_CALL_delete_current_thread PSI_THREAD_CALL(delete_current_thread)
#define PSI_CALL_get_thread PSI_THREAD_CALL(get_thread)
#define PSI_CALL_new_thread PSI_THREAD_CALL(new_thread)
#define PSI_CALL_register_thread PSI_THREAD_CALL(register_thread)
#define PSI_CALL_set_thread PSI_THREAD_CALL(set_thread)
#define PSI_CALL_set_thread_THD PSI_THREAD_CALL(set_thread_THD)
#define PSI_CALL_set_thread_connect_attrs PSI_THREAD_CALL(set_thread_connect_attrs)
#define PSI_CALL_set_thread_db PSI_THREAD_CALL(set_thread_db)
#define PSI_CALL_set_thread_id PSI_THREAD_CALL(set_thread_id)
#define PSI_CALL_set_thread_os_id PSI_THREAD_CALL(set_thread_os_id)
#define PSI_CALL_set_thread_info PSI_THREAD_CALL(set_thread_info)
#define PSI_CALL_set_thread_start_time PSI_THREAD_CALL(set_thread_start_time)
#define PSI_CALL_set_thread_account PSI_THREAD_CALL(set_thread_account)
#define PSI_CALL_spawn_thread PSI_THREAD_CALL(spawn_thread)
#define PSI_CALL_set_connection_type PSI_THREAD_CALL(set_connection_type)
#else
#define PSI_CALL_delete_current_thread() do { } while(0)
#define PSI_CALL_get_thread() NULL
#define PSI_CALL_new_thread(A1,A2,A3) NULL
#define PSI_CALL_register_thread(A1,A2,A3) do { } while(0)
#define PSI_CALL_set_thread(A1) do { } while(0)
#define PSI_CALL_set_thread_THD(A1,A2) do { } while(0)
#define PSI_CALL_set_thread_connect_attrs(A1,A2,A3) 0
#define PSI_CALL_set_thread_db(A1,A2) do { } while(0)
#define PSI_CALL_set_thread_id(A1,A2) do { } while(0)
#define PSI_CALL_set_thread_os_id(A1) do { } while(0)
#define PSI_CALL_set_thread_info(A1, A2) do { } while(0)
#define PSI_CALL_set_thread_start_time(A1) do { } while(0)
#define PSI_CALL_set_thread_account(A1, A2, A3, A4) do { } while(0)
#define PSI_CALL_spawn_thread(A1, A2, A3, A4, A5) 0
#define PSI_CALL_set_connection_type(A) do { } while(0)
#endif
/**
An instrumented mutex structure.
@sa mysql_mutex_t
*/
struct st_mysql_mutex
{
/** The real mutex. */
#ifdef SAFE_MUTEX
safe_mutex_t m_mutex;
#else
pthread_mutex_t m_mutex;
#endif
/**
The instrumentation hook.
Note that this hook is not conditionally defined,
for binary compatibility of the @c mysql_mutex_t interface.
*/
struct PSI_mutex *m_psi;
};
/**
Type of an instrumented mutex.
@c mysql_mutex_t is a drop-in replacement for @c pthread_mutex_t.
@sa mysql_mutex_assert_owner
@sa mysql_mutex_assert_not_owner
@sa mysql_mutex_init
@sa mysql_mutex_lock
@sa mysql_mutex_unlock
@sa mysql_mutex_destroy
*/
typedef struct st_mysql_mutex mysql_mutex_t;
/**
An instrumented rwlock structure.
@sa mysql_rwlock_t
*/
struct st_mysql_rwlock
{
/** The real rwlock */
rw_lock_t m_rwlock;
/**
The instrumentation hook.
Note that this hook is not conditionally defined,
for binary compatibility of the @c mysql_rwlock_t interface.
*/
struct PSI_rwlock *m_psi;
};
/**
An instrumented prlock structure.
@sa mysql_prlock_t
*/
struct st_mysql_prlock
{
/** The real prlock */
rw_pr_lock_t m_prlock;
/**
The instrumentation hook.
Note that this hook is not conditionally defined,
for binary compatibility of the @c mysql_rwlock_t interface.
*/
struct PSI_rwlock *m_psi;
};
/**
Type of an instrumented rwlock.
@c mysql_rwlock_t is a drop-in replacement for @c pthread_rwlock_t.
@sa mysql_rwlock_init
@sa mysql_rwlock_rdlock
@sa mysql_rwlock_tryrdlock
@sa mysql_rwlock_wrlock
@sa mysql_rwlock_trywrlock
@sa mysql_rwlock_unlock
@sa mysql_rwlock_destroy
*/
typedef struct st_mysql_rwlock mysql_rwlock_t;
/**
Type of an instrumented prlock.
A prlock is a read write lock that 'prefers readers' (pr).
@c mysql_prlock_t is a drop-in replacement for @c rw_pr_lock_t.
@sa mysql_prlock_init
@sa mysql_prlock_rdlock
@sa mysql_prlock_wrlock
@sa mysql_prlock_unlock
@sa mysql_prlock_destroy
*/
typedef struct st_mysql_prlock mysql_prlock_t;
/**
An instrumented cond structure.
@sa mysql_cond_t
*/
struct st_mysql_cond
{
/** The real condition */
pthread_cond_t m_cond;
/**
The instrumentation hook.
Note that this hook is not conditionally defined,
for binary compatibility of the @c mysql_cond_t interface.
*/
struct PSI_cond *m_psi;
};
/**
Type of an instrumented condition.
@c mysql_cond_t is a drop-in replacement for @c pthread_cond_t.
@sa mysql_cond_init
@sa mysql_cond_wait
@sa mysql_cond_timedwait
@sa mysql_cond_signal
@sa mysql_cond_broadcast
@sa mysql_cond_destroy
*/
typedef struct st_mysql_cond mysql_cond_t;
/*
Consider the following code:
static inline void foo() { bar(); }
when foo() is never called.
With gcc, foo() is a local static function, so the dependencies
are optimized away at compile time, and there is no dependency on bar().
With other compilers (HP, Sun Studio), the function foo() implementation
is compiled, and bar() needs to be present to link.
Due to the existing header dependencies in MySQL code, this header file
is sometime used when it is not needed, which in turn cause link failures
on some platforms.
The proper fix would be to cut these extra dependencies in the calling code.
DISABLE_MYSQL_THREAD_H is a work around to limit dependencies.
DISABLE_MYSQL_PRLOCK_H is similar, and is used to disable specifically
the prlock wrappers.
*/
#ifndef DISABLE_MYSQL_THREAD_H
#define mysql_mutex_is_owner(M) safe_mutex_is_owner(&(M)->m_mutex)
/**
@def mysql_mutex_assert_owner(M)
Wrapper, to use safe_mutex_assert_owner with instrumented mutexes.
@c mysql_mutex_assert_owner is a drop-in replacement
for @c safe_mutex_assert_owner.
*/
#define mysql_mutex_assert_owner(M) \
safe_mutex_assert_owner(&(M)->m_mutex)
/**
@def mysql_mutex_assert_not_owner(M)
Wrapper, to use safe_mutex_assert_not_owner with instrumented mutexes.
@c mysql_mutex_assert_not_owner is a drop-in replacement
for @c safe_mutex_assert_not_owner.
*/
#define mysql_mutex_assert_not_owner(M) \
safe_mutex_assert_not_owner(&(M)->m_mutex)
#define mysql_mutex_setflags(M, F) \
safe_mutex_setflags(&(M)->m_mutex, (F))
/**
@def mysql_prlock_assert_write_owner(M)
Drop-in replacement
for @c rw_pr_lock_assert_write_owner.
*/
#define mysql_prlock_assert_write_owner(M) \
rw_pr_lock_assert_write_owner(&(M)->m_prlock)
/**
@def mysql_prlock_assert_not_write_owner(M)
Drop-in replacement
for @c rw_pr_lock_assert_not_write_owner.
*/
#define mysql_prlock_assert_not_write_owner(M) \
rw_pr_lock_assert_not_write_owner(&(M)->m_prlock)
/**
@def mysql_mutex_register(P1, P2, P3)
Mutex registration.
*/
#define mysql_mutex_register(P1, P2, P3) \
inline_mysql_mutex_register(P1, P2, P3)
/**
@def mysql_mutex_init(K, M, A)
Instrumented mutex_init.
@c mysql_mutex_init is a replacement for @c pthread_mutex_init.
@param K The PSI_mutex_key for this instrumented mutex
@param M The mutex to initialize
@param A Mutex attributes
*/
#ifdef HAVE_PSI_MUTEX_INTERFACE
#ifdef SAFE_MUTEX
#define mysql_mutex_init(K, M, A) \
inline_mysql_mutex_init(K, M, A, #M, __FILE__, __LINE__)
#else
#define mysql_mutex_init(K, M, A) \
inline_mysql_mutex_init(K, M, A)
#endif
#else
#ifdef SAFE_MUTEX
#define mysql_mutex_init(K, M, A) \
inline_mysql_mutex_init(M, A, #M, __FILE__, __LINE__)
#else
#define mysql_mutex_init(K, M, A) \
inline_mysql_mutex_init(M, A)
#endif
#endif
/**
@def mysql_mutex_destroy(M)
Instrumented mutex_destroy.
@c mysql_mutex_destroy is a drop-in replacement
for @c pthread_mutex_destroy.
*/
#ifdef SAFE_MUTEX
#define mysql_mutex_destroy(M) \
inline_mysql_mutex_destroy(M, __FILE__, __LINE__)
#else
#define mysql_mutex_destroy(M) \
inline_mysql_mutex_destroy(M)
#endif
/**
@def mysql_mutex_lock(M)
Instrumented mutex_lock.
@c mysql_mutex_lock is a drop-in replacement for @c pthread_mutex_lock.
@param M The mutex to lock
*/
#if defined(SAFE_MUTEX) || defined (HAVE_PSI_MUTEX_INTERFACE)
#define mysql_mutex_lock(M) \
inline_mysql_mutex_lock(M, __FILE__, __LINE__)
#else
#define mysql_mutex_lock(M) \
inline_mysql_mutex_lock(M)
#endif
/**
@def mysql_mutex_trylock(M)
Instrumented mutex_lock.
@c mysql_mutex_trylock is a drop-in replacement
for @c pthread_mutex_trylock.
*/
#if defined(SAFE_MUTEX) || defined (HAVE_PSI_MUTEX_INTERFACE)
#define mysql_mutex_trylock(M) \
inline_mysql_mutex_trylock(M, __FILE__, __LINE__)
#else
#define mysql_mutex_trylock(M) \
inline_mysql_mutex_trylock(M)
#endif
/**
@def mysql_mutex_unlock(M)
Instrumented mutex_unlock.
@c mysql_mutex_unlock is a drop-in replacement for @c pthread_mutex_unlock.
*/
#ifdef SAFE_MUTEX
#define mysql_mutex_unlock(M) \
inline_mysql_mutex_unlock(M, __FILE__, __LINE__)
#else
#define mysql_mutex_unlock(M) \
inline_mysql_mutex_unlock(M)
#endif
/**
@def mysql_rwlock_register(P1, P2, P3)
Rwlock registration.
*/
#define mysql_rwlock_register(P1, P2, P3) \
inline_mysql_rwlock_register(P1, P2, P3)
/**
@def mysql_rwlock_init(K, RW)
Instrumented rwlock_init.
@c mysql_rwlock_init is a replacement for @c pthread_rwlock_init.
Note that pthread_rwlockattr_t is not supported in MySQL.
@param K The PSI_rwlock_key for this instrumented rwlock
@param RW The rwlock to initialize
*/
#ifdef HAVE_PSI_RWLOCK_INTERFACE
#define mysql_rwlock_init(K, RW) inline_mysql_rwlock_init(K, RW)
#else
#define mysql_rwlock_init(K, RW) inline_mysql_rwlock_init(RW)
#endif
/**
@def mysql_prlock_init(K, RW)
Instrumented rw_pr_init.
@c mysql_prlock_init is a replacement for @c rw_pr_init.
@param K The PSI_rwlock_key for this instrumented prlock
@param RW The prlock to initialize
*/
#ifdef HAVE_PSI_RWLOCK_INTERFACE
#define mysql_prlock_init(K, RW) inline_mysql_prlock_init(K, RW)
#else
#define mysql_prlock_init(K, RW) inline_mysql_prlock_init(RW)
#endif
/**
@def mysql_rwlock_destroy(RW)
Instrumented rwlock_destroy.
@c mysql_rwlock_destroy is a drop-in replacement
for @c pthread_rwlock_destroy.
*/
#define mysql_rwlock_destroy(RW) inline_mysql_rwlock_destroy(RW)
/**
@def mysql_prlock_destroy(RW)
Instrumented rw_pr_destroy.
@c mysql_prlock_destroy is a drop-in replacement
for @c rw_pr_destroy.
*/
#define mysql_prlock_destroy(RW) inline_mysql_prlock_destroy(RW)
/**
@def mysql_rwlock_rdlock(RW)
Instrumented rwlock_rdlock.
@c mysql_rwlock_rdlock is a drop-in replacement
for @c pthread_rwlock_rdlock.
*/
#ifdef HAVE_PSI_RWLOCK_INTERFACE
#define mysql_rwlock_rdlock(RW) \
inline_mysql_rwlock_rdlock(RW, __FILE__, __LINE__)
#else
#define mysql_rwlock_rdlock(RW) \
inline_mysql_rwlock_rdlock(RW)
#endif
/**
@def mysql_prlock_rdlock(RW)
Instrumented rw_pr_rdlock.
@c mysql_prlock_rdlock is a drop-in replacement
for @c rw_pr_rdlock.
*/
#ifdef HAVE_PSI_RWLOCK_INTERFACE
#define mysql_prlock_rdlock(RW) \
inline_mysql_prlock_rdlock(RW, __FILE__, __LINE__)
#else
#define mysql_prlock_rdlock(RW) \
inline_mysql_prlock_rdlock(RW)
#endif
/**
@def mysql_rwlock_wrlock(RW)
Instrumented rwlock_wrlock.
@c mysql_rwlock_wrlock is a drop-in replacement
for @c pthread_rwlock_wrlock.
*/
#ifdef HAVE_PSI_RWLOCK_INTERFACE
#define mysql_rwlock_wrlock(RW) \
inline_mysql_rwlock_wrlock(RW, __FILE__, __LINE__)
#else
#define mysql_rwlock_wrlock(RW) \
inline_mysql_rwlock_wrlock(RW)
#endif
/**
@def mysql_prlock_wrlock(RW)
Instrumented rw_pr_wrlock.
@c mysql_prlock_wrlock is a drop-in replacement
for @c rw_pr_wrlock.
*/
#ifdef HAVE_PSI_RWLOCK_INTERFACE
#define mysql_prlock_wrlock(RW) \
inline_mysql_prlock_wrlock(RW, __FILE__, __LINE__)
#else
#define mysql_prlock_wrlock(RW) \
inline_mysql_prlock_wrlock(RW)
#endif
/**
@def mysql_rwlock_tryrdlock(RW)
Instrumented rwlock_tryrdlock.
@c mysql_rwlock_tryrdlock is a drop-in replacement
for @c pthread_rwlock_tryrdlock.
*/
#ifdef HAVE_PSI_RWLOCK_INTERFACE
#define mysql_rwlock_tryrdlock(RW) \
inline_mysql_rwlock_tryrdlock(RW, __FILE__, __LINE__)
#else
#define mysql_rwlock_tryrdlock(RW) \
inline_mysql_rwlock_tryrdlock(RW)
#endif
/**
@def mysql_rwlock_trywrlock(RW)
Instrumented rwlock_trywrlock.
@c mysql_rwlock_trywrlock is a drop-in replacement
for @c pthread_rwlock_trywrlock.
*/
#ifdef HAVE_PSI_RWLOCK_INTERFACE
#define mysql_rwlock_trywrlock(RW) \
inline_mysql_rwlock_trywrlock(RW, __FILE__, __LINE__)
#else
#define mysql_rwlock_trywrlock(RW) \
inline_mysql_rwlock_trywrlock(RW)
#endif
/**
@def mysql_rwlock_unlock(RW)
Instrumented rwlock_unlock.
@c mysql_rwlock_unlock is a drop-in replacement
for @c pthread_rwlock_unlock.
*/
#define mysql_rwlock_unlock(RW) inline_mysql_rwlock_unlock(RW)
/**
@def mysql_prlock_unlock(RW)
Instrumented rw_pr_unlock.
@c mysql_prlock_unlock is a drop-in replacement
for @c rw_pr_unlock.
*/
#define mysql_prlock_unlock(RW) inline_mysql_prlock_unlock(RW)
/**
@def mysql_cond_register(P1, P2, P3)
Cond registration.
*/
#define mysql_cond_register(P1, P2, P3) \
inline_mysql_cond_register(P1, P2, P3)
/**
@def mysql_cond_init(K, C, A)
Instrumented cond_init.
@c mysql_cond_init is a replacement for @c pthread_cond_init.
@param C The cond to initialize
@param K The PSI_cond_key for this instrumented cond
@param A Condition attributes
*/
#ifdef HAVE_PSI_COND_INTERFACE
#define mysql_cond_init(K, C, A) inline_mysql_cond_init(K, C, A)
#else
#define mysql_cond_init(K, C, A) inline_mysql_cond_init(C, A)
#endif
/**
@def mysql_cond_destroy(C)
Instrumented cond_destroy.
@c mysql_cond_destroy is a drop-in replacement for @c pthread_cond_destroy.
*/
#define mysql_cond_destroy(C) inline_mysql_cond_destroy(C)
/**
@def mysql_cond_wait(C)
Instrumented cond_wait.
@c mysql_cond_wait is a drop-in replacement for @c pthread_cond_wait.
*/
#if defined(SAFE_MUTEX) || defined(HAVE_PSI_COND_INTERFACE)
#define mysql_cond_wait(C, M) \
inline_mysql_cond_wait(C, M, __FILE__, __LINE__)
#else
#define mysql_cond_wait(C, M) \
inline_mysql_cond_wait(C, M)
#endif
/**
@def mysql_cond_timedwait(C, M, W)
Instrumented cond_timedwait.
@c mysql_cond_timedwait is a drop-in replacement
for @c pthread_cond_timedwait.
*/
#if defined(SAFE_MUTEX) || defined(HAVE_PSI_COND_INTERFACE)
#define mysql_cond_timedwait(C, M, W) \
inline_mysql_cond_timedwait(C, M, W, __FILE__, __LINE__)
#else
#define mysql_cond_timedwait(C, M, W) \
inline_mysql_cond_timedwait(C, M, W)
#endif
/**
@def mysql_cond_signal(C)
Instrumented cond_signal.
@c mysql_cond_signal is a drop-in replacement for @c pthread_cond_signal.
*/
#define mysql_cond_signal(C) inline_mysql_cond_signal(C)
/**
@def mysql_cond_broadcast(C)
Instrumented cond_broadcast.
@c mysql_cond_broadcast is a drop-in replacement
for @c pthread_cond_broadcast.
*/
#define mysql_cond_broadcast(C) inline_mysql_cond_broadcast(C)
/**
@def mysql_thread_register(P1, P2, P3)
Thread registration.
*/
#define mysql_thread_register(P1, P2, P3) \
inline_mysql_thread_register(P1, P2, P3)
#include
GOV_LVE_PTHREAD_CREATE_DECL();
/**
@def mysql_thread_create(K, P1, P2, P3, P4)
Instrumented pthread_create.
This function creates both the thread instrumentation and a thread.
@c mysql_thread_create is a replacement for @c pthread_create.
The parameter P4 (or, if it is NULL, P1) will be used as the
instrumented thread "identity".
Providing a P1 / P4 parameter with a different value for each call
will on average improve performances, since this thread identity value
is used internally to randomize access to data and prevent contention.
This is optional, and the improvement is not guaranteed, only statistical.
@param K The PSI_thread_key for this instrumented thread
@param P1 pthread_create parameter 1
@param P2 pthread_create parameter 2
@param P3 pthread_create parameter 3
@param P4 pthread_create parameter 4
*/
#ifdef HAVE_PSI_THREAD_INTERFACE
#define mysql_thread_create(K, P1, P2, P3, P4) \
inline_mysql_thread_create(K, P1, P2, P3, P4)
#else
#define mysql_thread_create(K, P1, P2, P3, P4) \
GOV_LVE_PTHREAD_CREATE(P1, P2, P3, P4)
#endif
/**
@def mysql_thread_set_psi_id(I)
Set the thread identifier for the instrumentation.
@param I The thread identifier
*/
#ifdef HAVE_PSI_THREAD_INTERFACE
#define mysql_thread_set_psi_id(I) inline_mysql_thread_set_psi_id(I)
#else
#define mysql_thread_set_psi_id(I) do {} while (0)
#endif
/**
@def mysql_thread_set_psi_THD(T)
Set the thread sql session for the instrumentation.
@param I The thread identifier
*/
#ifdef HAVE_PSI_THREAD_INTERFACE
#define mysql_thread_set_psi_THD(T) inline_mysql_thread_set_psi_THD(T)
#else
#define mysql_thread_set_psi_THD(T) do {} while (0)
#endif
static inline void inline_mysql_mutex_register(
#ifdef HAVE_PSI_MUTEX_INTERFACE
const char *category,
PSI_mutex_info *info,
int count
#else
const char *category __attribute__ ((unused)),
void *info __attribute__ ((unused)),
int count __attribute__ ((unused))
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
PSI_MUTEX_CALL(register_mutex)(category, info, count);
#endif
}
static inline int inline_mysql_mutex_init(
#ifdef HAVE_PSI_MUTEX_INTERFACE
PSI_mutex_key key,
#endif
mysql_mutex_t *that,
const pthread_mutexattr_t *attr
#ifdef SAFE_MUTEX
, const char *src_name, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
that->m_psi= PSI_MUTEX_CALL(init_mutex)(key, &that->m_mutex);
#else
that->m_psi= NULL;
#endif
#ifdef SAFE_MUTEX
return safe_mutex_init(&that->m_mutex, attr, src_name, src_file, src_line);
#else
return pthread_mutex_init(&that->m_mutex, attr);
#endif
}
static inline int inline_mysql_mutex_destroy(
mysql_mutex_t *that
#ifdef SAFE_MUTEX
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
if (that->m_psi != NULL)
{
PSI_MUTEX_CALL(destroy_mutex)(that->m_psi);
that->m_psi= NULL;
}
#endif
#ifdef SAFE_MUTEX
return safe_mutex_destroy(&that->m_mutex, src_file, src_line);
#else
return pthread_mutex_destroy(&that->m_mutex);
#endif
}
#ifdef HAVE_PSI_MUTEX_INTERFACE
ATTRIBUTE_COLD int psi_mutex_lock(mysql_mutex_t *that,
const char *file, uint line);
ATTRIBUTE_COLD int psi_mutex_trylock(mysql_mutex_t *that,
const char *file, uint line);
#endif
static inline int inline_mysql_mutex_lock(
mysql_mutex_t *that
#if defined(SAFE_MUTEX) || defined (HAVE_PSI_MUTEX_INTERFACE)
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
if (psi_likely(that->m_psi != NULL))
return psi_mutex_lock(that, src_file, src_line);
#endif
/* Non instrumented code */
#ifdef SAFE_MUTEX
return safe_mutex_lock(&that->m_mutex, FALSE, src_file, src_line);
#else
return pthread_mutex_lock(&that->m_mutex);
#endif
}
static inline int inline_mysql_mutex_trylock(
mysql_mutex_t *that
#if defined(SAFE_MUTEX) || defined (HAVE_PSI_MUTEX_INTERFACE)
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
if (psi_likely(that->m_psi != NULL))
return psi_mutex_trylock(that, src_file, src_line);
#endif
/* Non instrumented code */
#ifdef SAFE_MUTEX
return safe_mutex_lock(&that->m_mutex, TRUE, src_file, src_line);
#else
return pthread_mutex_trylock(&that->m_mutex);
#endif
}
static inline int inline_mysql_mutex_unlock(
mysql_mutex_t *that
#ifdef SAFE_MUTEX
, const char *src_file, uint src_line
#endif
)
{
int result;
#ifdef HAVE_PSI_MUTEX_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_MUTEX_CALL(unlock_mutex)(that->m_psi);
#endif
#ifdef SAFE_MUTEX
result= safe_mutex_unlock(&that->m_mutex, src_file, src_line);
#else
result= pthread_mutex_unlock(&that->m_mutex);
#endif
return result;
}
static inline void inline_mysql_rwlock_register(
#ifdef HAVE_PSI_RWLOCK_INTERFACE
const char *category,
PSI_rwlock_info *info,
int count
#else
const char *category __attribute__ ((unused)),
void *info __attribute__ ((unused)),
int count __attribute__ ((unused))
#endif
)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
PSI_RWLOCK_CALL(register_rwlock)(category, info, count);
#endif
}
static inline int inline_mysql_rwlock_init(
#ifdef HAVE_PSI_RWLOCK_INTERFACE
PSI_rwlock_key key,
#endif
mysql_rwlock_t *that)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
that->m_psi= PSI_RWLOCK_CALL(init_rwlock)(key, &that->m_rwlock);
#else
that->m_psi= NULL;
#endif
/*
pthread_rwlockattr_t is not used in MySQL.
*/
return my_rwlock_init(&that->m_rwlock, NULL);
}
#ifndef DISABLE_MYSQL_PRLOCK_H
static inline int inline_mysql_prlock_init(
#ifdef HAVE_PSI_RWLOCK_INTERFACE
PSI_rwlock_key key,
#endif
mysql_prlock_t *that)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
that->m_psi= PSI_RWLOCK_CALL(init_rwlock)(key, &that->m_prlock);
#else
that->m_psi= NULL;
#endif
return rw_pr_init(&that->m_prlock);
}
#endif
static inline int inline_mysql_rwlock_destroy(
mysql_rwlock_t *that)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
{
PSI_RWLOCK_CALL(destroy_rwlock)(that->m_psi);
that->m_psi= NULL;
}
#endif
return rwlock_destroy(&that->m_rwlock);
}
#ifndef DISABLE_MYSQL_PRLOCK_H
static inline int inline_mysql_prlock_destroy(
mysql_prlock_t *that)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
{
PSI_RWLOCK_CALL(destroy_rwlock)(that->m_psi);
that->m_psi= NULL;
}
#endif
return rw_pr_destroy(&that->m_prlock);
}
#endif
#ifdef HAVE_PSI_RWLOCK_INTERFACE
ATTRIBUTE_COLD
int psi_rwlock_rdlock(mysql_rwlock_t *that, const char *file, uint line);
ATTRIBUTE_COLD
int psi_rwlock_tryrdlock(mysql_rwlock_t *that, const char *file, uint line);
ATTRIBUTE_COLD
int psi_rwlock_wrlock(mysql_rwlock_t *that, const char *file, uint line);
ATTRIBUTE_COLD
int psi_rwlock_trywrlock(mysql_rwlock_t *that, const char *file, uint line);
# ifndef DISABLE_MYSQL_PRLOCK_H
ATTRIBUTE_COLD
int psi_prlock_rdlock(mysql_prlock_t *that, const char *file, uint line);
ATTRIBUTE_COLD
int psi_prlock_wrlock(mysql_prlock_t *that, const char *file, uint line);
# endif
#endif
static inline int inline_mysql_rwlock_rdlock(
mysql_rwlock_t *that
#ifdef HAVE_PSI_RWLOCK_INTERFACE
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
return psi_rwlock_rdlock(that, src_file, src_line);
#endif
return rw_rdlock(&that->m_rwlock);
}
#ifndef DISABLE_MYSQL_PRLOCK_H
static inline int inline_mysql_prlock_rdlock(
mysql_prlock_t *that
#ifdef HAVE_PSI_RWLOCK_INTERFACE
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
return psi_prlock_rdlock(that, src_file, src_line);
#endif
return rw_pr_rdlock(&that->m_prlock);
}
#endif
static inline int inline_mysql_rwlock_wrlock(
mysql_rwlock_t *that
#ifdef HAVE_PSI_RWLOCK_INTERFACE
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
return psi_rwlock_wrlock(that, src_file, src_line);
#endif
return rw_wrlock(&that->m_rwlock);
}
#ifndef DISABLE_MYSQL_PRLOCK_H
static inline int inline_mysql_prlock_wrlock(
mysql_prlock_t *that
#ifdef HAVE_PSI_RWLOCK_INTERFACE
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
return psi_prlock_wrlock(that, src_file, src_line);
#endif
return rw_pr_wrlock(&that->m_prlock);
}
#endif
static inline int inline_mysql_rwlock_tryrdlock(
mysql_rwlock_t *that
#ifdef HAVE_PSI_RWLOCK_INTERFACE
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
return psi_rwlock_tryrdlock(that, src_file, src_line);
#endif
return rw_tryrdlock(&that->m_rwlock);
}
static inline int inline_mysql_rwlock_trywrlock(
mysql_rwlock_t *that
#ifdef HAVE_PSI_RWLOCK_INTERFACE
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
return psi_rwlock_trywrlock(that, src_file, src_line);
#endif
return rw_trywrlock(&that->m_rwlock);
}
static inline int inline_mysql_rwlock_unlock(
mysql_rwlock_t *that)
{
int result;
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_RWLOCK_CALL(unlock_rwlock)(that->m_psi);
#endif
result= rw_unlock(&that->m_rwlock);
return result;
}
#ifndef DISABLE_MYSQL_PRLOCK_H
static inline int inline_mysql_prlock_unlock(
mysql_prlock_t *that)
{
int result;
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_RWLOCK_CALL(unlock_rwlock)(that->m_psi);
#endif
result= rw_pr_unlock(&that->m_prlock);
return result;
}
#endif
static inline void inline_mysql_cond_register(
#ifdef HAVE_PSI_COND_INTERFACE
const char *category,
PSI_cond_info *info,
int count
#else
const char *category __attribute__ ((unused)),
void *info __attribute__ ((unused)),
int count __attribute__ ((unused))
#endif
)
{
#ifdef HAVE_PSI_COND_INTERFACE
PSI_COND_CALL(register_cond)(category, info, count);
#endif
}
static inline int inline_mysql_cond_init(
#ifdef HAVE_PSI_COND_INTERFACE
PSI_cond_key key,
#endif
mysql_cond_t *that,
const pthread_condattr_t *attr)
{
#ifdef HAVE_PSI_COND_INTERFACE
that->m_psi= PSI_COND_CALL(init_cond)(key, &that->m_cond);
#else
that->m_psi= NULL;
#endif
return pthread_cond_init(&that->m_cond, attr);
}
static inline int inline_mysql_cond_destroy(
mysql_cond_t *that)
{
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
{
PSI_COND_CALL(destroy_cond)(that->m_psi);
that->m_psi= NULL;
}
#endif
return pthread_cond_destroy(&that->m_cond);
}
#ifdef HAVE_PSI_COND_INTERFACE
ATTRIBUTE_COLD int psi_cond_wait(mysql_cond_t *that, mysql_mutex_t *mutex,
const char *file, uint line);
ATTRIBUTE_COLD int psi_cond_timedwait(mysql_cond_t *that, mysql_mutex_t *mutex,
const struct timespec *abstime,
const char *file, uint line);
#endif
static inline int inline_mysql_cond_wait(
mysql_cond_t *that,
mysql_mutex_t *mutex
#if defined(SAFE_MUTEX) || defined(HAVE_PSI_COND_INTERFACE)
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
return psi_cond_wait(that, mutex, src_file, src_line);
#endif
return my_cond_wait(&that->m_cond, &mutex->m_mutex);
}
static inline int inline_mysql_cond_timedwait(
mysql_cond_t *that,
mysql_mutex_t *mutex,
const struct timespec *abstime
#if defined(SAFE_MUTEX) || defined(HAVE_PSI_COND_INTERFACE)
, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
return psi_cond_timedwait(that, mutex, abstime, src_file, src_line);
#endif
return my_cond_timedwait(&that->m_cond, &mutex->m_mutex, abstime);
}
static inline int inline_mysql_cond_signal(
mysql_cond_t *that)
{
int result;
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_COND_CALL(signal_cond)(that->m_psi);
#endif
result= pthread_cond_signal(&that->m_cond);
return result;
}
static inline int inline_mysql_cond_broadcast(
mysql_cond_t *that)
{
int result;
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_COND_CALL(broadcast_cond)(that->m_psi);
#endif
result= pthread_cond_broadcast(&that->m_cond);
return result;
}
static inline void inline_mysql_thread_register(
#ifdef HAVE_PSI_THREAD_INTERFACE
const char *category,
PSI_thread_info *info,
int count
#else
const char *category __attribute__ ((unused)),
void *info __attribute__ ((unused)),
int count __attribute__ ((unused))
#endif
)
{
#ifdef HAVE_PSI_THREAD_INTERFACE
PSI_THREAD_CALL(register_thread)(category, info, count);
#endif
}
#ifdef HAVE_PSI_THREAD_INTERFACE
static inline int inline_mysql_thread_create(
PSI_thread_key key,
pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine)(void*), void *arg)
{
int result;
GOV_LVE_SLOT_RESERVE();
result= PSI_THREAD_CALL(spawn_thread)(key, thread, attr, start_routine, arg);
GOV_LVE_SLOT_RELEASE();
return result;
}
static inline void inline_mysql_thread_set_psi_id(my_thread_id id)
{
struct PSI_thread *psi= PSI_THREAD_CALL(get_thread)();
PSI_THREAD_CALL(set_thread_id)(psi, id);
}
#ifdef __cplusplus
class THD;
static inline void inline_mysql_thread_set_psi_THD(THD *thd)
{
struct PSI_thread *psi= PSI_THREAD_CALL(get_thread)();
PSI_THREAD_CALL(set_thread_THD)(psi, thd);
}
#endif /* __cplusplus */
static inline void mysql_thread_set_peer_port(uint port __attribute__ ((unused))) {
#ifdef HAVE_PSI_THREAD_INTERFACE
struct PSI_thread *psi = PSI_THREAD_CALL(get_thread)();
PSI_THREAD_CALL(set_thread_peer_port)(psi, port);
#endif
}
#endif
#endif /* DISABLE_MYSQL_THREAD_H */
/** @} (end of group Thread_instrumentation) */
#endif
PK ! ZtB mysql/psi/psi_memory.hnu [ /* Copyright (c) 2013, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
Without limiting anything contained in the foregoing, this file,
which is part of C Driver for MySQL (Connector/C), is also subject to the
Universal FOSS Exception, version 1.0, a copy of which can be found at
http://oss.oracle.com/licenses/universal-foss-exception.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_PSI_MEMORY_H
#define MYSQL_PSI_MEMORY_H
#include "psi_base.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
@file mysql/psi/psi_memory.h
Performance schema instrumentation interface.
@defgroup Instrumentation_interface Instrumentation Interface
@ingroup Performance_schema
@{
*/
#ifdef HAVE_PSI_INTERFACE
#ifndef DISABLE_ALL_PSI
#ifndef DISABLE_PSI_MEMORY
#define HAVE_PSI_MEMORY_INTERFACE
#endif /* DISABLE_PSI_MEMORY */
#endif /* DISABLE_ALL_PSI */
#endif /* HAVE_PSI_INTERFACE */
struct PSI_thread;
#ifdef HAVE_PSI_1
/**
@defgroup Group_PSI_v1 Application Binary Interface, version 1
@ingroup Instrumentation_interface
@{
*/
/**
Memory instrument information.
@since PSI_VERSION_1
This structure is used to register instrumented memory.
*/
struct PSI_memory_info_v1
{
/** Pointer to the key assigned to the registered memory. */
PSI_memory_key *m_key;
/** The name of the memory instrument to register. */
const char *m_name;
/**
The flags of the socket instrument to register.
@sa PSI_FLAG_GLOBAL
*/
int m_flags;
};
typedef struct PSI_memory_info_v1 PSI_memory_info_v1;
/**
Memory registration API.
@param category a category name (typically a plugin name)
@param info an array of memory info to register
@param count the size of the info array
*/
typedef void (*register_memory_v1_t)
(const char *category, struct PSI_memory_info_v1 *info, int count);
/**
Instrument memory allocation.
@param key the memory instrument key
@param size the size of memory allocated
@param[out] owner the memory owner
@return the effective memory instrument key
*/
typedef PSI_memory_key (*memory_alloc_v1_t)
(PSI_memory_key key, size_t size, struct PSI_thread ** owner);
/**
Instrument memory re allocation.
@param key the memory instrument key
@param old_size the size of memory previously allocated
@param new_size the size of memory re allocated
@param[in, out] owner the memory owner
@return the effective memory instrument key
*/
typedef PSI_memory_key (*memory_realloc_v1_t)
(PSI_memory_key key, size_t old_size, size_t new_size, struct PSI_thread ** owner);
/**
Instrument memory claim.
@param key the memory instrument key
@param size the size of memory allocated
@param[in, out] owner the memory owner
@return the effective memory instrument key
*/
typedef PSI_memory_key (*memory_claim_v1_t)
(PSI_memory_key key, size_t size, struct PSI_thread ** owner);
/**
Instrument memory free.
@param key the memory instrument key
@param size the size of memory allocated
@param owner the memory owner
*/
typedef void (*memory_free_v1_t)
(PSI_memory_key key, size_t size, struct PSI_thread * owner);
/** @} (end of group Group_PSI_v1) */
#ifdef _AIX
PSI_memory_key key_memory_log_event;
#endif
#endif /* HAVE_PSI_1 */
#ifdef HAVE_PSI_2
struct PSI_memory_info_v2
{
int placeholder;
};
#endif /* HAVE_PSI_2 */
#ifdef USE_PSI_1
typedef struct PSI_memory_info_v1 PSI_memory_info;
#endif
#ifdef USE_PSI_2
typedef struct PSI_memory_info_v2 PSI_memory_info;
#endif
/** @} (end of group Instrumentation_interface) */
#ifdef __cplusplus
}
#endif
#endif /* MYSQL_PSI_MEMORY_H */
PK ! ᒣJ J mysql/psi/mysql_stage.hnu [ /* Copyright (c) 2010, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_STAGE_H
#define MYSQL_STAGE_H
/**
@file mysql/psi/mysql_stage.h
Instrumentation helpers for stages.
*/
#include "mysql/psi/psi.h"
#ifndef PSI_STAGE_CALL
#define PSI_STAGE_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
/**
@defgroup Stage_instrumentation Stage Instrumentation
@ingroup Instrumentation_interface
@{
*/
/**
@def mysql_stage_register(P1, P2, P3)
Stage registration.
*/
#ifdef HAVE_PSI_STAGE_INTERFACE
#define mysql_stage_register(P1, P2, P3) \
inline_mysql_stage_register(P1, P2, P3)
#else
#define mysql_stage_register(P1, P2, P3) \
do {} while (0)
#endif
/**
@def MYSQL_SET_STAGE
Set the current stage.
Use this API when the file and line
is passed from the caller.
@param K the stage key
@param F the source file name
@param L the source file line
@return the current stage progress
*/
#ifdef HAVE_PSI_STAGE_INTERFACE
#define MYSQL_SET_STAGE(K, F, L) \
inline_mysql_set_stage(K, F, L)
#else
#define MYSQL_SET_STAGE(K, F, L) \
NULL
#endif
/**
@def mysql_set_stage
Set the current stage.
@param K the stage key
@return the current stage progress
*/
#ifdef HAVE_PSI_STAGE_INTERFACE
#define mysql_set_stage(K) \
inline_mysql_set_stage(K, __FILE__, __LINE__)
#else
#define mysql_set_stage(K) \
NULL
#endif
/**
@def mysql_end_stage
End the last stage
*/
#ifdef HAVE_PSI_STAGE_INTERFACE
#define mysql_end_stage() \
inline_mysql_end_stage()
#else
#define mysql_end_stage() \
do {} while (0)
#endif
#ifdef HAVE_PSI_STAGE_INTERFACE
static inline void inline_mysql_stage_register(
const char *category, PSI_stage_info **info, int count)
{
PSI_STAGE_CALL(register_stage)(category, info, count);
}
#endif
#ifdef HAVE_PSI_STAGE_INTERFACE
static inline PSI_stage_progress*
inline_mysql_set_stage(PSI_stage_key key,
const char *src_file, int src_line)
{
return PSI_STAGE_CALL(start_stage)(key, src_file, src_line);
}
#endif
#ifdef HAVE_PSI_STAGE_INTERFACE
static inline void
inline_mysql_end_stage()
{
PSI_STAGE_CALL(end_stage)();
}
#endif
#ifdef HAVE_PSI_STAGE_INTERFACE
#define mysql_stage_set_work_completed(P1, P2) \
inline_mysql_stage_set_work_completed(P1, P2)
#define mysql_stage_get_work_completed(P1) \
inline_mysql_stage_get_work_completed(P1)
#else
#define mysql_stage_set_work_completed(P1, P2) \
do {} while (0)
#define mysql_stage_get_work_completed(P1) \
do {} while (0)
#endif
#ifdef HAVE_PSI_STAGE_INTERFACE
#define mysql_stage_inc_work_completed(P1, P2) \
inline_mysql_stage_inc_work_completed(P1, P2)
#else
#define mysql_stage_inc_work_completed(P1, P2) \
do {} while (0)
#endif
#ifdef HAVE_PSI_STAGE_INTERFACE
#define mysql_stage_set_work_estimated(P1, P2) \
inline_mysql_stage_set_work_estimated(P1, P2)
#define mysql_stage_get_work_estimated(P1) \
inline_mysql_stage_get_work_estimated(P1)
#else
#define mysql_stage_set_work_estimated(P1, P2) \
do {} while (0)
#define mysql_stage_get_work_estimated(P1) \
do {} while (0)
#endif
#ifdef HAVE_PSI_STAGE_INTERFACE
static inline void
inline_mysql_stage_set_work_completed(PSI_stage_progress *progress,
ulonglong val)
{
if (progress != NULL)
progress->m_work_completed= val;
}
static inline ulonglong
inline_mysql_stage_get_work_completed(PSI_stage_progress *progress)
{
return progress->m_work_completed;
}
#endif
#ifdef HAVE_PSI_STAGE_INTERFACE
static inline void
inline_mysql_stage_inc_work_completed(PSI_stage_progress *progress,
ulonglong val)
{
if (progress != NULL)
progress->m_work_completed+= val;
}
#endif
#ifdef HAVE_PSI_STAGE_INTERFACE
static inline void
inline_mysql_stage_set_work_estimated(PSI_stage_progress *progress,
ulonglong val)
{
if (progress != NULL)
progress->m_work_estimated= val;
}
static inline ulonglong
inline_mysql_stage_get_work_estimated(PSI_stage_progress *progress)
{
return progress->m_work_estimated;
}
#endif
/** @} (end of group Stage_instrumentation) */
#endif
PK ! #.8W W mysql/psi/psi.hnu [ /* Copyright (c) 2008, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_PERFORMANCE_SCHEMA_INTERFACE_H
#define MYSQL_PERFORMANCE_SCHEMA_INTERFACE_H
#ifndef MY_GLOBAL_INCLUDED
/*
Make sure a .c or .cc file contains an include to my_global.h first.
When this include is missing, all the #ifdef HAVE_XXX have no effect,
and the resulting binary won't build, or won't link,
or will crash at runtime
since various structures will have different binary definitions.
*/
#error "You must include my_global.h in the code for the build to be correct."
#endif
/*
If PSI_ON_BY_DFAULT is defined, assume PSI will be enabled by default and
optimize jumps testing for PSI this case. If not, optimize the binary for
that PSI is not enabled
*/
#ifdef PSI_ON_BY_DEFAULT
#define psi_likely(A) likely(A)
#define psi_unlikely(A) unlikely(A)
#else
#define psi_likely(A) unlikely(A)
#define psi_unlikely(A) likely(A)
#endif
#include "psi_base.h"
#include "psi_memory.h"
#ifdef _WIN32
typedef struct thread_attr pthread_attr_t;
typedef DWORD pthread_t;
typedef DWORD pthread_key_t;
#endif
/*
MAINTAINER:
The following pattern:
typedef struct XYZ XYZ;
is not needed in C++, but required for C.
*/
C_MODE_START
/** @sa MDL_key. */
struct MDL_key;
typedef struct MDL_key MDL_key;
/** @sa enum_mdl_type. */
typedef int opaque_mdl_type;
/** @sa enum_mdl_duration. */
typedef int opaque_mdl_duration;
/** @sa MDL_wait::enum_wait_status. */
typedef int opaque_mdl_status;
/** @sa enum_vio_type. */
typedef int opaque_vio_type;
struct TABLE_SHARE;
struct sql_digest_storage;
#ifdef __cplusplus
class THD;
#else
/*
Phony declaration when compiling C code.
This is ok, because the C code will never have a THD anyway.
*/
struct opaque_THD
{
int dummy;
};
typedef struct opaque_THD THD;
#endif
/**
@file mysql/psi/psi.h
Performance schema instrumentation interface.
@defgroup Instrumentation_interface Instrumentation Interface
@ingroup Performance_schema
@{
*/
/**
Interface for an instrumented mutex.
This is an opaque structure.
*/
struct PSI_mutex;
typedef struct PSI_mutex PSI_mutex;
/**
Interface for an instrumented rwlock.
This is an opaque structure.
*/
struct PSI_rwlock;
typedef struct PSI_rwlock PSI_rwlock;
/**
Interface for an instrumented condition.
This is an opaque structure.
*/
struct PSI_cond;
typedef struct PSI_cond PSI_cond;
/**
Interface for an instrumented table share.
This is an opaque structure.
*/
struct PSI_table_share;
typedef struct PSI_table_share PSI_table_share;
/**
Interface for an instrumented table handle.
This is an opaque structure.
*/
struct PSI_table;
typedef struct PSI_table PSI_table;
/**
Interface for an instrumented thread.
This is an opaque structure.
*/
struct PSI_thread;
typedef struct PSI_thread PSI_thread;
/**
Interface for an instrumented file handle.
This is an opaque structure.
*/
struct PSI_file;
typedef struct PSI_file PSI_file;
/**
Interface for an instrumented socket descriptor.
This is an opaque structure.
*/
struct PSI_socket;
typedef struct PSI_socket PSI_socket;
/**
Interface for an instrumented prepared statement.
This is an opaque structure.
*/
struct PSI_prepared_stmt;
typedef struct PSI_prepared_stmt PSI_prepared_stmt;
/**
Interface for an instrumented table operation.
This is an opaque structure.
*/
struct PSI_table_locker;
typedef struct PSI_table_locker PSI_table_locker;
/**
Interface for an instrumented statement.
This is an opaque structure.
*/
struct PSI_statement_locker;
typedef struct PSI_statement_locker PSI_statement_locker;
/**
Interface for an instrumented transaction.
This is an opaque structure.
*/
struct PSI_transaction_locker;
typedef struct PSI_transaction_locker PSI_transaction_locker;
/**
Interface for an instrumented idle operation.
This is an opaque structure.
*/
struct PSI_idle_locker;
typedef struct PSI_idle_locker PSI_idle_locker;
/**
Interface for an instrumented statement digest operation.
This is an opaque structure.
*/
struct PSI_digest_locker;
typedef struct PSI_digest_locker PSI_digest_locker;
/**
Interface for an instrumented stored procedure share.
This is an opaque structure.
*/
struct PSI_sp_share;
typedef struct PSI_sp_share PSI_sp_share;
/**
Interface for an instrumented stored program.
This is an opaque structure.
*/
struct PSI_sp_locker;
typedef struct PSI_sp_locker PSI_sp_locker;
/**
Interface for an instrumented metadata lock.
This is an opaque structure.
*/
struct PSI_metadata_lock;
typedef struct PSI_metadata_lock PSI_metadata_lock;
/**
Interface for an instrumented stage progress.
This is a public structure, for efficiency.
*/
struct PSI_stage_progress
{
ulonglong m_work_completed;
ulonglong m_work_estimated;
};
typedef struct PSI_stage_progress PSI_stage_progress;
/** IO operation performed on an instrumented table. */
enum PSI_table_io_operation
{
/** Row fetch. */
PSI_TABLE_FETCH_ROW= 0,
/** Row write. */
PSI_TABLE_WRITE_ROW= 1,
/** Row update. */
PSI_TABLE_UPDATE_ROW= 2,
/** Row delete. */
PSI_TABLE_DELETE_ROW= 3
};
typedef enum PSI_table_io_operation PSI_table_io_operation;
/**
State data storage for @c start_table_io_wait_v1_t,
@c start_table_lock_wait_v1_t.
This structure provide temporary storage to a table locker.
The content of this structure is considered opaque,
the fields are only hints of what an implementation
of the psi interface can use.
This memory is provided by the instrumented code for performance reasons.
@sa start_table_io_wait_v1_t
@sa start_table_lock_wait_v1_t
*/
struct PSI_table_locker_state
{
/** Internal state. */
uint m_flags;
/** Current io operation. */
enum PSI_table_io_operation m_io_operation;
/** Current table handle. */
struct PSI_table *m_table;
/** Current table share. */
struct PSI_table_share *m_table_share;
/** Current thread. */
struct PSI_thread *m_thread;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Internal data. */
void *m_wait;
/**
Implementation specific.
For table io, the table io index.
For table lock, the lock type.
*/
uint m_index;
};
typedef struct PSI_table_locker_state PSI_table_locker_state;
/** Entry point for the performance schema interface. */
struct PSI_bootstrap
{
/**
ABI interface finder.
Calling this method with an interface version number returns either
an instance of the ABI for this version, or NULL.
@param version the interface version number to find
@return a versioned interface (PSI_v1, PSI_v2 or PSI)
@sa PSI_VERSION_1
@sa PSI_v1
@sa PSI_VERSION_2
@sa PSI_v2
@sa PSI_CURRENT_VERSION
@sa PSI
*/
void* (*get_interface)(int version);
};
typedef struct PSI_bootstrap PSI_bootstrap;
#ifdef HAVE_PSI_INTERFACE
#ifdef DISABLE_ALL_PSI
#ifndef DISABLE_PSI_THREAD
#define DISABLE_PSI_THREAD
#endif
#ifndef DISABLE_PSI_MUTEX
#define DISABLE_PSI_MUTEX
#endif
#ifndef DISABLE_PSI_RWLOCK
#define DISABLE_PSI_RWLOCK
#endif
#ifndef DISABLE_PSI_COND
#define DISABLE_PSI_COND
#endif
#ifndef DISABLE_PSI_FILE
#define DISABLE_PSI_FILE
#endif
#ifndef DISABLE_PSI_TABLE
#define DISABLE_PSI_TABLE
#endif
#ifndef DISABLE_PSI_SOCKET
#define DISABLE_PSI_SOCKET
#endif
#ifndef DISABLE_PSI_STAGE
#define DISABLE_PSI_STAGE
#endif
#ifndef DISABLE_PSI_STATEMENT
#define DISABLE_PSI_STATEMENT
#endif
#ifndef DISABLE_PSI_SP
#define DISABLE_PSI_SP
#endif
#ifndef DISABLE_PSI_IDLE
#define DISABLE_PSI_IDLE
#endif
#ifndef DISABLE_PSI_STATEMENT_DIGEST
#define DISABLE_PSI_STATEMENT_DIGEST
#endif
#ifndef DISABLE_PSI_METADATA
#define DISABLE_PSI_METADATA
#endif
#ifndef DISABLE_PSI_MEMORY
#define DISABLE_PSI_MEMORY
#endif
#ifndef DISABLE_PSI_TRANSACTION
#define DISABLE_PSI_TRANSACTION
#endif
#ifndef DISABLE_PSI_SP
#define DISABLE_PSI_SP
#endif
#ifndef DISABLE_PSI_PS
#define DISABLE_PSI_PS
#endif
#endif
/**
@def DISABLE_PSI_MUTEX
Compiling option to disable the mutex instrumentation.
This option is mostly intended to be used during development,
when doing special builds with only a subset of the performance schema instrumentation,
for code analysis / profiling / performance tuning of a specific instrumentation alone.
@sa DISABLE_PSI_RWLOCK
@sa DISABLE_PSI_COND
@sa DISABLE_PSI_FILE
@sa DISABLE_PSI_THREAD
@sa DISABLE_PSI_TABLE
@sa DISABLE_PSI_STAGE
@sa DISABLE_PSI_STATEMENT
@sa DISABLE_PSI_SP
@sa DISABLE_PSI_STATEMENT_DIGEST
@sa DISABLE_PSI_SOCKET
@sa DISABLE_PSI_MEMORY
@sa DISABLE_PSI_IDLE
@sa DISABLE_PSI_METADATA
@sa DISABLE PSI_TRANSACTION
*/
#ifndef DISABLE_PSI_MUTEX
#define HAVE_PSI_MUTEX_INTERFACE
#endif
/**
@def DISABLE_PSI_RWLOCK
Compiling option to disable the rwlock instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_RWLOCK
#define HAVE_PSI_RWLOCK_INTERFACE
#endif
/**
@def DISABLE_PSI_COND
Compiling option to disable the cond instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_COND
#define HAVE_PSI_COND_INTERFACE
#endif
/**
@def DISABLE_PSI_FILE
Compiling option to disable the file instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_FILE
#define HAVE_PSI_FILE_INTERFACE
#endif
/**
@def DISABLE_PSI_THREAD
Compiling option to disable the thread instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_THREAD
#define HAVE_PSI_THREAD_INTERFACE
#endif
/**
@def DISABLE_PSI_TABLE
Compiling option to disable the table instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_TABLE
#define HAVE_PSI_TABLE_INTERFACE
#endif
/**
@def DISABLE_PSI_STAGE
Compiling option to disable the stage instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_STAGE
#define HAVE_PSI_STAGE_INTERFACE
#endif
/**
@def DISABLE_PSI_STATEMENT
Compiling option to disable the statement instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_STATEMENT
#define HAVE_PSI_STATEMENT_INTERFACE
#endif
/**
@def DISABLE_PSI_SP
Compiling option to disable the stored program instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_SP
#define HAVE_PSI_SP_INTERFACE
#endif
/**
@def DISABLE_PSI_PS
Compiling option to disable the prepared statement instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_STATEMENT
#ifndef DISABLE_PSI_PS
#define HAVE_PSI_PS_INTERFACE
#endif
#endif
/**
@def DISABLE_PSI_STATEMENT_DIGEST
Compiling option to disable the statement digest instrumentation.
*/
#ifndef DISABLE_PSI_STATEMENT
#ifndef DISABLE_PSI_STATEMENT_DIGEST
#define HAVE_PSI_STATEMENT_DIGEST_INTERFACE
#endif
#endif
/**
@def DISABLE_PSI_TRANSACTION
Compiling option to disable the transaction instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_TRANSACTION
#define HAVE_PSI_TRANSACTION_INTERFACE
#endif
/**
@def DISABLE_PSI_SOCKET
Compiling option to disable the statement instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_SOCKET
#define HAVE_PSI_SOCKET_INTERFACE
#endif
/**
@def DISABLE_PSI_MEMORY
Compiling option to disable the memory instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_MEMORY
#define HAVE_PSI_MEMORY_INTERFACE
#endif
/**
@def DISABLE_PSI_IDLE
Compiling option to disable the idle instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_IDLE
#define HAVE_PSI_IDLE_INTERFACE
#endif
/**
@def DISABLE_PSI_METADATA
Compiling option to disable the metadata instrumentation.
@sa DISABLE_PSI_MUTEX
*/
#ifndef DISABLE_PSI_METADATA
#define HAVE_PSI_METADATA_INTERFACE
#endif
/**
@def PSI_VERSION_1
Performance Schema Interface number for version 1.
This version is supported.
*/
#define PSI_VERSION_1 1
/**
@def PSI_VERSION_2
Performance Schema Interface number for version 2.
This version is not implemented, it's a placeholder.
*/
#define PSI_VERSION_2 2
/**
@def PSI_CURRENT_VERSION
Performance Schema Interface number for the most recent version.
The most current version is @c PSI_VERSION_1
*/
#define PSI_CURRENT_VERSION 1
#ifndef USE_PSI_2
#ifndef USE_PSI_1
#define USE_PSI_1
#endif
#endif
/**
Interface for an instrumented mutex operation.
This is an opaque structure.
*/
struct PSI_mutex_locker;
typedef struct PSI_mutex_locker PSI_mutex_locker;
/**
Interface for an instrumented rwlock operation.
This is an opaque structure.
*/
struct PSI_rwlock_locker;
typedef struct PSI_rwlock_locker PSI_rwlock_locker;
/**
Interface for an instrumented condition operation.
This is an opaque structure.
*/
struct PSI_cond_locker;
typedef struct PSI_cond_locker PSI_cond_locker;
/**
Interface for an instrumented file operation.
This is an opaque structure.
*/
struct PSI_file_locker;
typedef struct PSI_file_locker PSI_file_locker;
/**
Interface for an instrumented socket operation.
This is an opaque structure.
*/
struct PSI_socket_locker;
typedef struct PSI_socket_locker PSI_socket_locker;
/**
Interface for an instrumented MDL operation.
This is an opaque structure.
*/
struct PSI_metadata_locker;
typedef struct PSI_metadata_locker PSI_metadata_locker;
/** Operation performed on an instrumented mutex. */
enum PSI_mutex_operation
{
/** Lock. */
PSI_MUTEX_LOCK= 0,
/** Lock attempt. */
PSI_MUTEX_TRYLOCK= 1
};
typedef enum PSI_mutex_operation PSI_mutex_operation;
/**
Operation performed on an instrumented rwlock.
For basic READ / WRITE lock,
operations are "READ" or "WRITE".
For SX-locks, operations are "SHARED", "SHARED-EXCLUSIVE" or "EXCLUSIVE".
*/
enum PSI_rwlock_operation
{
/** Read lock. */
PSI_RWLOCK_READLOCK= 0,
/** Write lock. */
PSI_RWLOCK_WRITELOCK= 1,
/** Read lock attempt. */
PSI_RWLOCK_TRYREADLOCK= 2,
/** Write lock attempt. */
PSI_RWLOCK_TRYWRITELOCK= 3,
/** Shared lock. */
PSI_RWLOCK_SHAREDLOCK= 4,
/** Shared Exclusive lock. */
PSI_RWLOCK_SHAREDEXCLUSIVELOCK= 5,
/** Exclusive lock. */
PSI_RWLOCK_EXCLUSIVELOCK= 6,
/** Shared lock attempt. */
PSI_RWLOCK_TRYSHAREDLOCK= 7,
/** Shared Exclusive lock attempt. */
PSI_RWLOCK_TRYSHAREDEXCLUSIVELOCK= 8,
/** Exclusive lock attempt. */
PSI_RWLOCK_TRYEXCLUSIVELOCK= 9
};
typedef enum PSI_rwlock_operation PSI_rwlock_operation;
/** Operation performed on an instrumented condition. */
enum PSI_cond_operation
{
/** Wait. */
PSI_COND_WAIT= 0,
/** Wait, with timeout. */
PSI_COND_TIMEDWAIT= 1
};
typedef enum PSI_cond_operation PSI_cond_operation;
/** Operation performed on an instrumented file. */
enum PSI_file_operation
{
/** File creation, as in @c create(). */
PSI_FILE_CREATE= 0,
/** Temporary file creation, as in @c create_temp_file(). */
PSI_FILE_CREATE_TMP= 1,
/** File open, as in @c open(). */
PSI_FILE_OPEN= 2,
/** File open, as in @c fopen(). */
PSI_FILE_STREAM_OPEN= 3,
/** File close, as in @c close(). */
PSI_FILE_CLOSE= 4,
/** File close, as in @c fclose(). */
PSI_FILE_STREAM_CLOSE= 5,
/**
Generic file read, such as @c fgets(), @c fgetc(), @c fread(), @c read(),
@c pread().
*/
PSI_FILE_READ= 6,
/**
Generic file write, such as @c fputs(), @c fputc(), @c fprintf(),
@c vfprintf(), @c fwrite(), @c write(), @c pwrite().
*/
PSI_FILE_WRITE= 7,
/** Generic file seek, such as @c fseek() or @c seek(). */
PSI_FILE_SEEK= 8,
/** Generic file tell, such as @c ftell() or @c tell(). */
PSI_FILE_TELL= 9,
/** File flush, as in @c fflush(). */
PSI_FILE_FLUSH= 10,
/** File stat, as in @c stat(). */
PSI_FILE_STAT= 11,
/** File stat, as in @c fstat(). */
PSI_FILE_FSTAT= 12,
/** File chsize, as in @c my_chsize(). */
PSI_FILE_CHSIZE= 13,
/** File delete, such as @c my_delete() or @c my_handler_delete_with_symlink(). */
PSI_FILE_DELETE= 14,
/** File rename, such as @c my_rename() or @c my_rename_with_symlink(). */
PSI_FILE_RENAME= 15,
/** File sync, as in @c fsync() or @c my_sync(). */
PSI_FILE_SYNC= 16
};
typedef enum PSI_file_operation PSI_file_operation;
/** Lock operation performed on an instrumented table. */
enum PSI_table_lock_operation
{
/** Table lock, in the server layer. */
PSI_TABLE_LOCK= 0,
/** Table lock, in the storage engine layer. */
PSI_TABLE_EXTERNAL_LOCK= 1
};
typedef enum PSI_table_lock_operation PSI_table_lock_operation;
/** State of an instrumented socket. */
enum PSI_socket_state
{
/** Idle, waiting for the next command. */
PSI_SOCKET_STATE_IDLE= 1,
/** Active, executing a command. */
PSI_SOCKET_STATE_ACTIVE= 2
};
typedef enum PSI_socket_state PSI_socket_state;
/** Operation performed on an instrumented socket. */
enum PSI_socket_operation
{
/** Socket creation, as in @c socket() or @c socketpair(). */
PSI_SOCKET_CREATE= 0,
/** Socket connection, as in @c connect(), @c listen() and @c accept(). */
PSI_SOCKET_CONNECT= 1,
/** Socket bind, as in @c bind(), @c getsockname() and @c getpeername(). */
PSI_SOCKET_BIND= 2,
/** Socket close, as in @c shutdown(). */
PSI_SOCKET_CLOSE= 3,
/** Socket send, @c send(). */
PSI_SOCKET_SEND= 4,
/** Socket receive, @c recv(). */
PSI_SOCKET_RECV= 5,
/** Socket send, @c sendto(). */
PSI_SOCKET_SENDTO= 6,
/** Socket receive, @c recvfrom). */
PSI_SOCKET_RECVFROM= 7,
/** Socket send, @c sendmsg(). */
PSI_SOCKET_SENDMSG= 8,
/** Socket receive, @c recvmsg(). */
PSI_SOCKET_RECVMSG= 9,
/** Socket seek, such as @c fseek() or @c seek(). */
PSI_SOCKET_SEEK= 10,
/** Socket options, as in @c getsockopt() and @c setsockopt(). */
PSI_SOCKET_OPT= 11,
/** Socket status, as in @c sockatmark() and @c isfdtype(). */
PSI_SOCKET_STAT= 12,
/** Socket shutdown, as in @c shutdown(). */
PSI_SOCKET_SHUTDOWN= 13,
/** Socket select, as in @c select() and @c poll(). */
PSI_SOCKET_SELECT= 14
};
typedef enum PSI_socket_operation PSI_socket_operation;
#endif
/**
Instrumented mutex key.
To instrument a mutex, a mutex key must be obtained using @c register_mutex.
Using a zero key always disable the instrumentation.
*/
typedef unsigned int PSI_mutex_key;
/**
Instrumented rwlock key.
To instrument a rwlock, a rwlock key must be obtained
using @c register_rwlock.
Using a zero key always disable the instrumentation.
*/
typedef unsigned int PSI_rwlock_key;
/**
Instrumented cond key.
To instrument a condition, a condition key must be obtained
using @c register_cond.
Using a zero key always disable the instrumentation.
*/
typedef unsigned int PSI_cond_key;
/**
Instrumented thread key.
To instrument a thread, a thread key must be obtained
using @c register_thread.
Using a zero key always disable the instrumentation.
*/
typedef unsigned int PSI_thread_key;
/**
Instrumented file key.
To instrument a file, a file key must be obtained using @c register_file.
Using a zero key always disable the instrumentation.
*/
typedef unsigned int PSI_file_key;
/**
Instrumented stage key.
To instrument a stage, a stage key must be obtained using @c register_stage.
Using a zero key always disable the instrumentation.
*/
typedef unsigned int PSI_stage_key;
/**
Instrumented statement key.
To instrument a statement, a statement key must be obtained using @c register_statement.
Using a zero key always disable the instrumentation.
*/
typedef unsigned int PSI_statement_key;
/**
Instrumented socket key.
To instrument a socket, a socket key must be obtained using @c register_socket.
Using a zero key always disable the instrumentation.
*/
typedef unsigned int PSI_socket_key;
#ifdef HAVE_PSI_1
/**
@defgroup Group_PSI_v1 Application Binary Interface, version 1
@ingroup Instrumentation_interface
@{
*/
/**
Mutex information.
@since PSI_VERSION_1
This structure is used to register an instrumented mutex.
*/
struct PSI_mutex_info_v1
{
/**
Pointer to the key assigned to the registered mutex.
*/
PSI_mutex_key *m_key;
/**
The name of the mutex to register.
*/
const char *m_name;
/**
The flags of the mutex to register.
@sa PSI_FLAG_GLOBAL
*/
int m_flags;
};
typedef struct PSI_mutex_info_v1 PSI_mutex_info_v1;
/**
Rwlock information.
@since PSI_VERSION_1
This structure is used to register an instrumented rwlock.
*/
struct PSI_rwlock_info_v1
{
/**
Pointer to the key assigned to the registered rwlock.
*/
PSI_rwlock_key *m_key;
/**
The name of the rwlock to register.
*/
const char *m_name;
/**
The flags of the rwlock to register.
@sa PSI_FLAG_GLOBAL
*/
int m_flags;
};
typedef struct PSI_rwlock_info_v1 PSI_rwlock_info_v1;
/**
Condition information.
@since PSI_VERSION_1
This structure is used to register an instrumented cond.
*/
struct PSI_cond_info_v1
{
/**
Pointer to the key assigned to the registered cond.
*/
PSI_cond_key *m_key;
/**
The name of the cond to register.
*/
const char *m_name;
/**
The flags of the cond to register.
@sa PSI_FLAG_GLOBAL
*/
int m_flags;
};
typedef struct PSI_cond_info_v1 PSI_cond_info_v1;
/**
Thread instrument information.
@since PSI_VERSION_1
This structure is used to register an instrumented thread.
*/
struct PSI_thread_info_v1
{
/**
Pointer to the key assigned to the registered thread.
*/
PSI_thread_key *m_key;
/**
The name of the thread instrument to register.
*/
const char *m_name;
/**
The flags of the thread to register.
@sa PSI_FLAG_GLOBAL
*/
int m_flags;
};
typedef struct PSI_thread_info_v1 PSI_thread_info_v1;
/**
File instrument information.
@since PSI_VERSION_1
This structure is used to register an instrumented file.
*/
struct PSI_file_info_v1
{
/**
Pointer to the key assigned to the registered file.
*/
PSI_file_key *m_key;
/**
The name of the file instrument to register.
*/
const char *m_name;
/**
The flags of the file instrument to register.
@sa PSI_FLAG_GLOBAL
*/
int m_flags;
};
typedef struct PSI_file_info_v1 PSI_file_info_v1;
/**
Stage instrument information.
@since PSI_VERSION_1
This structure is used to register an instrumented stage.
*/
struct PSI_stage_info_v1
{
/** The registered stage key. */
PSI_stage_key m_key;
/** The name of the stage instrument to register. */
const char *m_name;
/** The flags of the stage instrument to register. */
int m_flags;
};
typedef struct PSI_stage_info_v1 PSI_stage_info_v1;
/**
Statement instrument information.
@since PSI_VERSION_1
This structure is used to register an instrumented statement.
*/
struct PSI_statement_info_v1
{
/** The registered statement key. */
PSI_statement_key m_key;
/** The name of the statement instrument to register. */
const char *m_name;
/** The flags of the statement instrument to register. */
int m_flags;
};
typedef struct PSI_statement_info_v1 PSI_statement_info_v1;
/**
Socket instrument information.
@since PSI_VERSION_1
This structure is used to register an instrumented socket.
*/
struct PSI_socket_info_v1
{
/**
Pointer to the key assigned to the registered socket.
*/
PSI_socket_key *m_key;
/**
The name of the socket instrument to register.
*/
const char *m_name;
/**
The flags of the socket instrument to register.
@sa PSI_FLAG_GLOBAL
*/
int m_flags;
};
typedef struct PSI_socket_info_v1 PSI_socket_info_v1;
/**
State data storage for @c start_idle_wait_v1_t.
This structure provide temporary storage to an idle locker.
The content of this structure is considered opaque,
the fields are only hints of what an implementation
of the psi interface can use.
This memory is provided by the instrumented code for performance reasons.
@sa start_idle_wait_v1_t.
*/
struct PSI_idle_locker_state_v1
{
/** Internal state. */
uint m_flags;
/** Current thread. */
struct PSI_thread *m_thread;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Internal data. */
void *m_wait;
};
typedef struct PSI_idle_locker_state_v1 PSI_idle_locker_state_v1;
/**
State data storage for @c start_mutex_wait_v1_t.
This structure provide temporary storage to a mutex locker.
The content of this structure is considered opaque,
the fields are only hints of what an implementation
of the psi interface can use.
This memory is provided by the instrumented code for performance reasons.
@sa start_mutex_wait_v1_t
*/
struct PSI_mutex_locker_state_v1
{
/** Internal state. */
uint m_flags;
/** Current operation. */
enum PSI_mutex_operation m_operation;
/** Current mutex. */
struct PSI_mutex *m_mutex;
/** Current thread. */
struct PSI_thread *m_thread;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Internal data. */
void *m_wait;
};
typedef struct PSI_mutex_locker_state_v1 PSI_mutex_locker_state_v1;
/**
State data storage for @c start_rwlock_rdwait_v1_t, @c start_rwlock_wrwait_v1_t.
This structure provide temporary storage to a rwlock locker.
The content of this structure is considered opaque,
the fields are only hints of what an implementation
of the psi interface can use.
This memory is provided by the instrumented code for performance reasons.
@sa start_rwlock_rdwait_v1_t
@sa start_rwlock_wrwait_v1_t
*/
struct PSI_rwlock_locker_state_v1
{
/** Internal state. */
uint m_flags;
/** Current operation. */
enum PSI_rwlock_operation m_operation;
/** Current rwlock. */
struct PSI_rwlock *m_rwlock;
/** Current thread. */
struct PSI_thread *m_thread;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Internal data. */
void *m_wait;
};
typedef struct PSI_rwlock_locker_state_v1 PSI_rwlock_locker_state_v1;
/**
State data storage for @c start_cond_wait_v1_t.
This structure provide temporary storage to a condition locker.
The content of this structure is considered opaque,
the fields are only hints of what an implementation
of the psi interface can use.
This memory is provided by the instrumented code for performance reasons.
@sa start_cond_wait_v1_t
*/
struct PSI_cond_locker_state_v1
{
/** Internal state. */
uint m_flags;
/** Current operation. */
enum PSI_cond_operation m_operation;
/** Current condition. */
struct PSI_cond *m_cond;
/** Current mutex. */
struct PSI_mutex *m_mutex;
/** Current thread. */
struct PSI_thread *m_thread;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Internal data. */
void *m_wait;
};
typedef struct PSI_cond_locker_state_v1 PSI_cond_locker_state_v1;
/**
State data storage for @c get_thread_file_name_locker_v1_t.
This structure provide temporary storage to a file locker.
The content of this structure is considered opaque,
the fields are only hints of what an implementation
of the psi interface can use.
This memory is provided by the instrumented code for performance reasons.
@sa get_thread_file_name_locker_v1_t
@sa get_thread_file_stream_locker_v1_t
@sa get_thread_file_descriptor_locker_v1_t
*/
struct PSI_file_locker_state_v1
{
/** Internal state. */
uint m_flags;
/** Current operation. */
enum PSI_file_operation m_operation;
/** Current file. */
struct PSI_file *m_file;
/** Current file name. */
const char *m_name;
/** Current file class. */
void *m_class;
/** Current thread. */
struct PSI_thread *m_thread;
/** Operation number of bytes. */
size_t m_number_of_bytes;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Internal data. */
void *m_wait;
};
typedef struct PSI_file_locker_state_v1 PSI_file_locker_state_v1;
/**
State data storage for @c start_metadata_wait_v1_t.
This structure provide temporary storage to a metadata locker.
The content of this structure is considered opaque,
the fields are only hints of what an implementation
of the psi interface can use.
This memory is provided by the instrumented code for performance reasons.
@sa start_metadata_wait_v1_t
*/
struct PSI_metadata_locker_state_v1
{
/** Internal state. */
uint m_flags;
/** Current metadata lock. */
struct PSI_metadata_lock *m_metadata_lock;
/** Current thread. */
struct PSI_thread *m_thread;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Internal data. */
void *m_wait;
};
typedef struct PSI_metadata_locker_state_v1 PSI_metadata_locker_state_v1;
/* Duplicate of NAME_LEN, to avoid dependency on mysql_com.h */
#define PSI_SCHEMA_NAME_LEN (64 * 3)
/**
State data storage for @c get_thread_statement_locker_v1_t,
@c get_thread_statement_locker_v1_t.
This structure provide temporary storage to a statement locker.
The content of this structure is considered opaque,
the fields are only hints of what an implementation
of the psi interface can use.
This memory is provided by the instrumented code for performance reasons.
@sa get_thread_statement_locker_v1_t
*/
struct PSI_statement_locker_state_v1
{
/** Discarded flag. */
my_bool m_discarded;
/** In prepare flag. */
my_bool m_in_prepare;
/** Metric, no index used flag. */
uchar m_no_index_used;
/** Metric, no good index used flag. */
uchar m_no_good_index_used;
/** Internal state. */
uint m_flags;
/** Instrumentation class. */
void *m_class;
/** Current thread. */
struct PSI_thread *m_thread;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Internal data. */
void *m_statement;
/** Locked time. */
ulonglong m_lock_time;
/** Rows sent. */
ulonglong m_rows_sent;
/** Rows examined. */
ulonglong m_rows_examined;
/** Metric, temporary tables created on disk. */
ulong m_created_tmp_disk_tables;
/** Metric, temporary tables created. */
ulong m_created_tmp_tables;
/** Metric, number of select full join. */
ulong m_select_full_join;
/** Metric, number of select full range join. */
ulong m_select_full_range_join;
/** Metric, number of select range. */
ulong m_select_range;
/** Metric, number of select range check. */
ulong m_select_range_check;
/** Metric, number of select scan. */
ulong m_select_scan;
/** Metric, number of sort merge passes. */
ulong m_sort_merge_passes;
/** Metric, number of sort merge. */
ulong m_sort_range;
/** Metric, number of sort rows. */
ulong m_sort_rows;
/** Metric, number of sort scans. */
ulong m_sort_scan;
/** Statement digest. */
const struct sql_digest_storage *m_digest;
/** Current schema name. */
char m_schema_name[PSI_SCHEMA_NAME_LEN];
/** Length in bytes of @c m_schema_name. */
uint m_schema_name_length;
/** Statement character set number. */
uint m_cs_number;
PSI_sp_share *m_parent_sp_share;
PSI_prepared_stmt *m_parent_prepared_stmt;
};
typedef struct PSI_statement_locker_state_v1 PSI_statement_locker_state_v1;
/**
State data storage for @c get_thread_transaction_locker_v1_t,
@c get_thread_transaction_locker_v1_t.
This structure provide temporary storage to a transaction locker.
The content of this structure is considered opaque,
the fields are only hints of what an implementation
of the psi interface can use.
This memory is provided by the instrumented code for performance reasons.
@sa get_thread_transaction_locker_v1_t
*/
struct PSI_transaction_locker_state_v1
{
/** Internal state. */
uint m_flags;
/** Instrumentation class. */
void *m_class;
/** Current thread. */
struct PSI_thread *m_thread;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Internal data. */
void *m_transaction;
/** True if read-only transaction, false if read-write. */
my_bool m_read_only;
/** True if transaction is autocommit. */
my_bool m_autocommit;
/** Number of statements. */
ulong m_statement_count;
/** Total number of savepoints. */
ulong m_savepoint_count;
/** Number of rollback_to_savepoint. */
ulong m_rollback_to_savepoint_count;
/** Number of release_savepoint. */
ulong m_release_savepoint_count;
};
typedef struct PSI_transaction_locker_state_v1 PSI_transaction_locker_state_v1;
/**
State data storage for @c start_socket_wait_v1_t.
This structure provide temporary storage to a socket locker.
The content of this structure is considered opaque,
the fields are only hints of what an implementation
of the psi interface can use.
This memory is provided by the instrumented code for performance reasons.
@sa start_socket_wait_v1_t
*/
struct PSI_socket_locker_state_v1
{
/** Internal state. */
uint m_flags;
/** Current socket. */
struct PSI_socket *m_socket;
/** Current thread. */
struct PSI_thread *m_thread;
/** Operation number of bytes. */
size_t m_number_of_bytes;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Current operation. */
enum PSI_socket_operation m_operation;
/** Source file. */
const char* m_src_file;
/** Source line number. */
int m_src_line;
/** Internal data. */
void *m_wait;
};
typedef struct PSI_socket_locker_state_v1 PSI_socket_locker_state_v1;
struct PSI_sp_locker_state_v1
{
/** Internal state. */
uint m_flags;
/** Current thread. */
struct PSI_thread *m_thread;
/** Timer start. */
ulonglong m_timer_start;
/** Timer function. */
ulonglong (*m_timer)(void);
/** Stored Procedure share. */
PSI_sp_share* m_sp_share;
};
typedef struct PSI_sp_locker_state_v1 PSI_sp_locker_state_v1;
/* Using typedef to make reuse between PSI_v1 and PSI_v2 easier later. */
/**
Mutex registration API.
@param category a category name (typically a plugin name)
@param info an array of mutex info to register
@param count the size of the info array
*/
typedef void (*register_mutex_v1_t)
(const char *category, struct PSI_mutex_info_v1 *info, int count);
/**
Rwlock registration API.
@param category a category name (typically a plugin name)
@param info an array of rwlock info to register
@param count the size of the info array
*/
typedef void (*register_rwlock_v1_t)
(const char *category, struct PSI_rwlock_info_v1 *info, int count);
/**
Cond registration API.
@param category a category name (typically a plugin name)
@param info an array of cond info to register
@param count the size of the info array
*/
typedef void (*register_cond_v1_t)
(const char *category, struct PSI_cond_info_v1 *info, int count);
/**
Thread registration API.
@param category a category name (typically a plugin name)
@param info an array of thread info to register
@param count the size of the info array
*/
typedef void (*register_thread_v1_t)
(const char *category, struct PSI_thread_info_v1 *info, int count);
/**
File registration API.
@param category a category name (typically a plugin name)
@param info an array of file info to register
@param count the size of the info array
*/
typedef void (*register_file_v1_t)
(const char *category, struct PSI_file_info_v1 *info, int count);
/**
Stage registration API.
@param category a category name
@param info an array of stage info to register
@param count the size of the info array
*/
typedef void (*register_stage_v1_t)
(const char *category, struct PSI_stage_info_v1 **info, int count);
/**
Statement registration API.
@param category a category name
@param info an array of stage info to register
@param count the size of the info array
*/
typedef void (*register_statement_v1_t)
(const char *category, struct PSI_statement_info_v1 *info, int count);
/**
Socket registration API.
@param category a category name (typically a plugin name)
@param info an array of socket info to register
@param count the size of the info array
*/
typedef void (*register_socket_v1_t)
(const char *category, struct PSI_socket_info_v1 *info, int count);
/**
Mutex instrumentation initialisation API.
@param key the registered mutex key
@param identity the address of the mutex itself
@return an instrumented mutex
*/
typedef struct PSI_mutex* (*init_mutex_v1_t)
(PSI_mutex_key key, void *identity);
/**
Mutex instrumentation destruction API.
@param mutex the mutex to destroy
*/
typedef void (*destroy_mutex_v1_t)(struct PSI_mutex *mutex);
/**
Rwlock instrumentation initialisation API.
@param key the registered rwlock key
@param identity the address of the rwlock itself
@return an instrumented rwlock
*/
typedef struct PSI_rwlock* (*init_rwlock_v1_t)
(PSI_rwlock_key key, void *identity);
/**
Rwlock instrumentation destruction API.
@param rwlock the rwlock to destroy
*/
typedef void (*destroy_rwlock_v1_t)(struct PSI_rwlock *rwlock);
/**
Cond instrumentation initialisation API.
@param key the registered key
@param identity the address of the rwlock itself
@return an instrumented cond
*/
typedef struct PSI_cond* (*init_cond_v1_t)
(PSI_cond_key key, void *identity);
/**
Cond instrumentation destruction API.
@param cond the rcond to destroy
*/
typedef void (*destroy_cond_v1_t)(struct PSI_cond *cond);
/**
Socket instrumentation initialisation API.
@param key the registered mutex key
@param socket descriptor
@param addr the socket ip address
@param addr_len length of socket ip address
@return an instrumented socket
*/
typedef struct PSI_socket* (*init_socket_v1_t)
(PSI_socket_key key, const my_socket *fd,
const struct sockaddr *addr, socklen_t addr_len);
/**
socket instrumentation destruction API.
@param socket the socket to destroy
*/
typedef void (*destroy_socket_v1_t)(struct PSI_socket *socket);
/**
Acquire a table share instrumentation.
@param temporary True for temporary tables
@param share The SQL layer table share
@return a table share instrumentation, or NULL
*/
typedef struct PSI_table_share* (*get_table_share_v1_t)
(my_bool temporary, struct TABLE_SHARE *share);
/**
Release a table share.
@param info the table share to release
*/
typedef void (*release_table_share_v1_t)(struct PSI_table_share *share);
/**
Drop a table share.
@param temporary True for temporary tables
@param schema_name the table schema name
@param schema_name_length the table schema name length
@param table_name the table name
@param table_name_length the table name length
*/
typedef void (*drop_table_share_v1_t)
(my_bool temporary, const char *schema_name, int schema_name_length,
const char *table_name, int table_name_length);
/**
Open an instrumentation table handle.
@param share the table to open
@param identity table handle identity
@return a table handle, or NULL
*/
typedef struct PSI_table* (*open_table_v1_t)
(struct PSI_table_share *share, const void *identity);
/**
Unbind a table handle from the current thread.
This operation happens when an opened table is added to the open table cache.
@param table the table to unbind
*/
typedef void (*unbind_table_v1_t)
(struct PSI_table *table);
/**
Rebind a table handle to the current thread.
This operation happens when a table from the open table cache
is reused for a thread.
@param table the table to unbind
*/
typedef PSI_table* (*rebind_table_v1_t)
(PSI_table_share *share, const void *identity, PSI_table *table);
/**
Close an instrumentation table handle.
Note that the table handle is invalid after this call.
@param table the table handle to close
*/
typedef void (*close_table_v1_t)(struct TABLE_SHARE *server_share,
struct PSI_table *table);
/**
Create a file instrumentation for a created file.
This method does not create the file itself, but is used to notify the
instrumentation interface that a file was just created.
@param key the file instrumentation key for this file
@param name the file name
@param file the file handle
*/
typedef void (*create_file_v1_t)(PSI_file_key key, const char *name,
File file);
/**
Spawn a thread.
This method creates a new thread, with instrumentation.
@param key the instrumentation key for this thread
@param thread the resulting thread
@param attr the thread attributes
@param start_routine the thread start routine
@param arg the thread start routine argument
*/
typedef int (*spawn_thread_v1_t)(PSI_thread_key key,
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)(void*), void *arg);
/**
Create instrumentation for a thread.
@param key the registered key
@param identity an address typical of the thread
@return an instrumented thread
*/
typedef struct PSI_thread* (*new_thread_v1_t)
(PSI_thread_key key, const void *identity, ulonglong thread_id);
/**
Assign a THD to an instrumented thread.
@param thread the instrumented thread
@param THD the sql layer THD to assign
*/
typedef void (*set_thread_THD_v1_t)(struct PSI_thread *thread,
THD *thd);
/**
Assign an id to an instrumented thread.
@param thread the instrumented thread
@param id the id to assign
*/
typedef void (*set_thread_id_v1_t)(struct PSI_thread *thread,
ulonglong id);
/**
Assign the current operating system thread id to an instrumented thread.
The operating system task id is obtained from @c gettid()
@param thread the instrumented thread
*/
typedef void (*set_thread_os_id_v1_t)(struct PSI_thread *thread);
/**
Get the instrumentation for the running thread.
For this function to return a result,
the thread instrumentation must have been attached to the
running thread using @c set_thread()
@return the instrumentation for the running thread
*/
typedef struct PSI_thread* (*get_thread_v1_t)(void);
/**
Assign a user name to the instrumented thread.
@param user the user name
@param user_len the user name length
*/
typedef void (*set_thread_user_v1_t)(const char *user, int user_len);
/**
Assign a user name and host name to the instrumented thread.
@param user the user name
@param user_len the user name length
@param host the host name
@param host_len the host name length
*/
typedef void (*set_thread_account_v1_t)(const char *user, int user_len,
const char *host, int host_len);
/**
Assign a current database to the instrumented thread.
@param db the database name
@param db_len the database name length
*/
typedef void (*set_thread_db_v1_t)(const char* db, int db_len);
/**
Assign a current command to the instrumented thread.
@param command the current command
*/
typedef void (*set_thread_command_v1_t)(int command);
/**
Assign a connection type to the instrumented thread.
@param conn_type the connection type
*/
typedef void (*set_connection_type_v1_t)(opaque_vio_type conn_type);
/**
Assign a start time to the instrumented thread.
@param start_time the thread start time
*/
typedef void (*set_thread_start_time_v1_t)(time_t start_time);
/**
Assign a state to the instrumented thread.
@param state the thread state
*/
typedef void (*set_thread_state_v1_t)(const char* state);
/**
Assign a process info to the instrumented thread.
@param info the process into string
@param info_len the process into string length
*/
typedef void (*set_thread_info_v1_t)(const char* info, uint info_len);
/**
Attach a thread instrumentation to the running thread.
In case of thread pools, this method should be called when
a worker thread picks a work item and runs it.
Also, this method should be called if the instrumented code does not
keep the pointer returned by @c new_thread() and relies on @c get_thread()
instead.
@param thread the thread instrumentation
*/
typedef void (*set_thread_v1_t)(struct PSI_thread *thread);
/**
Assign the remote (peer) port to the instrumented thread.
@param thread pointer to the thread instrumentation
@param port the remote port
*/
typedef void (*set_thread_peer_port_v1_t)(PSI_thread *thread,
unsigned int port);
/** Delete the current thread instrumentation. */
typedef void (*delete_current_thread_v1_t)(void);
/** Delete a thread instrumentation. */
typedef void (*delete_thread_v1_t)(struct PSI_thread *thread);
/**
Get a file instrumentation locker, for opening or creating a file.
@param state data storage for the locker
@param key the file instrumentation key
@param op the operation to perform
@param name the file name
@param identity a pointer representative of this file.
@return a file locker, or NULL
*/
typedef struct PSI_file_locker* (*get_thread_file_name_locker_v1_t)
(struct PSI_file_locker_state_v1 *state,
PSI_file_key key, enum PSI_file_operation op, const char *name,
const void *identity);
/**
Get a file stream instrumentation locker.
@param state data storage for the locker
@param file the file stream to access
@param op the operation to perform
@return a file locker, or NULL
*/
typedef struct PSI_file_locker* (*get_thread_file_stream_locker_v1_t)
(struct PSI_file_locker_state_v1 *state,
struct PSI_file *file, enum PSI_file_operation op);
/**
Get a file instrumentation locker.
@param state data storage for the locker
@param file the file descriptor to access
@param op the operation to perform
@return a file locker, or NULL
*/
typedef struct PSI_file_locker* (*get_thread_file_descriptor_locker_v1_t)
(struct PSI_file_locker_state_v1 *state,
File file, enum PSI_file_operation op);
/**
Record a mutex instrumentation unlock event.
@param mutex the mutex instrumentation
*/
typedef void (*unlock_mutex_v1_t)
(struct PSI_mutex *mutex);
/**
Record a rwlock instrumentation unlock event.
@param rwlock the rwlock instrumentation
*/
typedef void (*unlock_rwlock_v1_t)
(struct PSI_rwlock *rwlock);
/**
Record a condition instrumentation signal event.
@param cond the cond instrumentation
*/
typedef void (*signal_cond_v1_t)
(struct PSI_cond *cond);
/**
Record a condition instrumentation broadcast event.
@param cond the cond instrumentation
*/
typedef void (*broadcast_cond_v1_t)
(struct PSI_cond *cond);
/**
Record an idle instrumentation wait start event.
@param state data storage for the locker
@param file the source file name
@param line the source line number
@return an idle locker, or NULL
*/
typedef struct PSI_idle_locker* (*start_idle_wait_v1_t)
(struct PSI_idle_locker_state_v1 *state, const char *src_file, uint src_line);
/**
Record an idle instrumentation wait end event.
@param locker a thread locker for the running thread
*/
typedef void (*end_idle_wait_v1_t)
(struct PSI_idle_locker *locker);
/**
Record a mutex instrumentation wait start event.
@param state data storage for the locker
@param mutex the instrumented mutex to lock
@param op the operation to perform
@param file the source file name
@param line the source line number
@return a mutex locker, or NULL
*/
typedef struct PSI_mutex_locker* (*start_mutex_wait_v1_t)
(struct PSI_mutex_locker_state_v1 *state,
struct PSI_mutex *mutex,
enum PSI_mutex_operation op,
const char *src_file, uint src_line);
/**
Record a mutex instrumentation wait end event.
@param locker a thread locker for the running thread
@param rc the wait operation return code
*/
typedef void (*end_mutex_wait_v1_t)
(struct PSI_mutex_locker *locker, int rc);
/**
Record a rwlock instrumentation read wait start event.
@param locker a thread locker for the running thread
@param must must block: 1 for lock, 0 for trylock
*/
typedef struct PSI_rwlock_locker* (*start_rwlock_rdwait_v1_t)
(struct PSI_rwlock_locker_state_v1 *state,
struct PSI_rwlock *rwlock,
enum PSI_rwlock_operation op,
const char *src_file, uint src_line);
/**
Record a rwlock instrumentation read wait end event.
@param locker a thread locker for the running thread
@param rc the wait operation return code
*/
typedef void (*end_rwlock_rdwait_v1_t)
(struct PSI_rwlock_locker *locker, int rc);
/**
Record a rwlock instrumentation write wait start event.
@param locker a thread locker for the running thread
@param must must block: 1 for lock, 0 for trylock
*/
typedef struct PSI_rwlock_locker* (*start_rwlock_wrwait_v1_t)
(struct PSI_rwlock_locker_state_v1 *state,
struct PSI_rwlock *rwlock,
enum PSI_rwlock_operation op,
const char *src_file, uint src_line);
/**
Record a rwlock instrumentation write wait end event.
@param locker a thread locker for the running thread
@param rc the wait operation return code
*/
typedef void (*end_rwlock_wrwait_v1_t)
(struct PSI_rwlock_locker *locker, int rc);
/**
Record a condition instrumentation wait start event.
@param locker a thread locker for the running thread
@param must must block: 1 for wait, 0 for timedwait
*/
typedef struct PSI_cond_locker* (*start_cond_wait_v1_t)
(struct PSI_cond_locker_state_v1 *state,
struct PSI_cond *cond,
struct PSI_mutex *mutex,
enum PSI_cond_operation op,
const char *src_file, uint src_line);
/**
Record a condition instrumentation wait end event.
@param locker a thread locker for the running thread
@param rc the wait operation return code
*/
typedef void (*end_cond_wait_v1_t)
(struct PSI_cond_locker *locker, int rc);
/**
Record a table instrumentation io wait start event.
@param locker a table locker for the running thread
@param file the source file name
@param line the source line number
*/
typedef struct PSI_table_locker* (*start_table_io_wait_v1_t)
(struct PSI_table_locker_state *state,
struct PSI_table *table,
enum PSI_table_io_operation op,
uint index,
const char *src_file, uint src_line);
/**
Record a table instrumentation io wait end event.
@param locker a table locker for the running thread
@param numrows the number of rows involved in io
*/
typedef void (*end_table_io_wait_v1_t)
(struct PSI_table_locker *locker,
ulonglong numrows);
/**
Record a table instrumentation lock wait start event.
@param locker a table locker for the running thread
@param file the source file name
@param line the source line number
*/
typedef struct PSI_table_locker* (*start_table_lock_wait_v1_t)
(struct PSI_table_locker_state *state,
struct PSI_table *table,
enum PSI_table_lock_operation op,
ulong flags,
const char *src_file, uint src_line);
/**
Record a table instrumentation lock wait end event.
@param locker a table locker for the running thread
*/
typedef void (*end_table_lock_wait_v1_t)(struct PSI_table_locker *locker);
typedef void (*unlock_table_v1_t)(struct PSI_table *table);
/**
Start a file instrumentation open operation.
@param locker the file locker
@param op the operation to perform
@param src_file the source file name
@param src_line the source line number
*/
typedef void (*start_file_open_wait_v1_t)
(struct PSI_file_locker *locker, const char *src_file, uint src_line);
/**
End a file instrumentation open operation, for file streams.
@param locker the file locker.
@param result the opened file (NULL indicates failure, non NULL success).
@return an instrumented file handle
*/
typedef struct PSI_file* (*end_file_open_wait_v1_t)
(struct PSI_file_locker *locker, void *result);
/**
End a file instrumentation open operation, for non stream files.
@param locker the file locker.
@param file the file number assigned by open() or create() for this file.
*/
typedef void (*end_file_open_wait_and_bind_to_descriptor_v1_t)
(struct PSI_file_locker *locker, File file);
/**
End a file instrumentation open operation, for non stream temporary files.
@param locker the file locker.
@param file the file number assigned by open() or create() for this file.
@param filename the file name generated during temporary file creation.
*/
typedef void (*end_temp_file_open_wait_and_bind_to_descriptor_v1_t)
(struct PSI_file_locker *locker, File file, const char *filename);
/**
Record a file instrumentation start event.
@param locker a file locker for the running thread
@param op file operation to be performed
@param count the number of bytes requested, or 0 if not applicable
@param src_file the source file name
@param src_line the source line number
*/
typedef void (*start_file_wait_v1_t)
(struct PSI_file_locker *locker, size_t count,
const char *src_file, uint src_line);
/**
Record a file instrumentation end event.
Note that for file close operations, the instrumented file handle
associated with the file (which was provided to obtain a locker)
is invalid after this call.
@param locker a file locker for the running thread
@param count the number of bytes actually used in the operation,
or 0 if not applicable, or -1 if the operation failed
@sa get_thread_file_name_locker
@sa get_thread_file_stream_locker
@sa get_thread_file_descriptor_locker
*/
typedef void (*end_file_wait_v1_t)
(struct PSI_file_locker *locker, size_t count);
/**
Start a file instrumentation close operation.
@param locker the file locker
@param op the operation to perform
@param src_file the source file name
@param src_line the source line number
*/
typedef void (*start_file_close_wait_v1_t)
(struct PSI_file_locker *locker, const char *src_file, uint src_line);
/**
End a file instrumentation close operation.
@param locker the file locker.
@param rc the close operation return code (0 for success).
@return an instrumented file handle
*/
typedef void (*end_file_close_wait_v1_t)
(struct PSI_file_locker *locker, int rc);
/**
Rename a file instrumentation close operation.
@param locker the file locker.
@param old_name name of the file to be renamed.
@param new_name name of the file after rename.
@param rc the rename operation return code (0 for success).
*/
typedef void (*end_file_rename_wait_v1_t)
(struct PSI_file_locker *locker, const char *old_name,
const char *new_name, int rc);
/**
Start a new stage, and implicitly end the previous stage.
@param key the key of the new stage
@param src_file the source file name
@param src_line the source line number
@return the new stage progress
*/
typedef PSI_stage_progress* (*start_stage_v1_t)
(PSI_stage_key key, const char *src_file, int src_line);
typedef PSI_stage_progress* (*get_current_stage_progress_v1_t)(void);
/** End the current stage. */
typedef void (*end_stage_v1_t) (void);
/**
Get a statement instrumentation locker.
@param state data storage for the locker
@param key the statement instrumentation key
@param charset client character set
@return a statement locker, or NULL
*/
typedef struct PSI_statement_locker* (*get_thread_statement_locker_v1_t)
(struct PSI_statement_locker_state_v1 *state,
PSI_statement_key key, const void *charset, PSI_sp_share *sp_share);
/**
Refine a statement locker to a more specific key.
Note that only events declared mutable can be refined.
@param the statement locker for the current event
@param key the new key for the event
@sa PSI_FLAG_MUTABLE
*/
typedef struct PSI_statement_locker* (*refine_statement_v1_t)
(struct PSI_statement_locker *locker,
PSI_statement_key key);
/**
Start a new statement event.
@param locker the statement locker for this event
@param db the active database name for this statement
@param db_length the active database name length for this statement
@param src_file source file name
@param src_line source line number
*/
typedef void (*start_statement_v1_t)
(struct PSI_statement_locker *locker,
const char *db, uint db_length,
const char *src_file, uint src_line);
/**
Set the statement text for a statement event.
@param locker the current statement locker
@param text the statement text
@param text_len the statement text length
*/
typedef void (*set_statement_text_v1_t)
(struct PSI_statement_locker *locker,
const char *text, uint text_len);
/**
Set a statement event lock time.
@param locker the statement locker
@param lock_time the locked time, in microseconds
*/
typedef void (*set_statement_lock_time_t)
(struct PSI_statement_locker *locker, ulonglong lock_time);
/**
Set a statement event rows sent metric.
@param locker the statement locker
@param count the number of rows sent
*/
typedef void (*set_statement_rows_sent_t)
(struct PSI_statement_locker *locker, ulonglong count);
/**
Set a statement event rows examined metric.
@param locker the statement locker
@param count the number of rows examined
*/
typedef void (*set_statement_rows_examined_t)
(struct PSI_statement_locker *locker, ulonglong count);
/**
Increment a statement event "created tmp disk tables" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_created_tmp_disk_tables_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Increment a statement event "created tmp tables" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_created_tmp_tables_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Increment a statement event "select full join" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_select_full_join_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Increment a statement event "select full range join" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_select_full_range_join_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Increment a statement event "select range join" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_select_range_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Increment a statement event "select range check" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_select_range_check_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Increment a statement event "select scan" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_select_scan_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Increment a statement event "sort merge passes" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_sort_merge_passes_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Increment a statement event "sort range" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_sort_range_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Increment a statement event "sort rows" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_sort_rows_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Increment a statement event "sort scan" metric.
@param locker the statement locker
@param count the metric increment value
*/
typedef void (*inc_statement_sort_scan_t)
(struct PSI_statement_locker *locker, ulong count);
/**
Set a statement event "no index used" metric.
@param locker the statement locker
@param count the metric value
*/
typedef void (*set_statement_no_index_used_t)
(struct PSI_statement_locker *locker);
/**
Set a statement event "no good index used" metric.
@param locker the statement locker
@param count the metric value
*/
typedef void (*set_statement_no_good_index_used_t)
(struct PSI_statement_locker *locker);
/**
End a statement event.
@param locker the statement locker
@param stmt_da the statement diagnostics area.
@sa Diagnostics_area
*/
typedef void (*end_statement_v1_t)
(struct PSI_statement_locker *locker, void *stmt_da);
/**
Get a transaction instrumentation locker.
@param state data storage for the locker
@param xid the xid for this transaction
@param trxid the InnoDB transaction id
@param iso_level isolation level for this transaction
@param read_only true if transaction access mode is read-only
@param autocommit true if transaction is autocommit
@return a transaction locker, or NULL
*/
typedef struct PSI_transaction_locker* (*get_thread_transaction_locker_v1_t)
(struct PSI_transaction_locker_state_v1 *state, const void *xid,
ulonglong trxid, int isolation_level, my_bool read_only,
my_bool autocommit);
/**
Start a new transaction event.
@param locker the transaction locker for this event
@param src_file source file name
@param src_line source line number
*/
typedef void (*start_transaction_v1_t)
(struct PSI_transaction_locker *locker,
const char *src_file, uint src_line);
/**
Set the transaction xid.
@param locker the transaction locker for this event
@param xid the id of the XA transaction
#param xa_state is the state of the XA transaction
*/
typedef void (*set_transaction_xid_v1_t)
(struct PSI_transaction_locker *locker,
const void *xid, int xa_state);
/**
Set the state of the XA transaction.
@param locker the transaction locker for this event
@param xa_state the new state of the xa transaction
*/
typedef void (*set_transaction_xa_state_v1_t)
(struct PSI_transaction_locker *locker,
int xa_state);
/**
Set the transaction gtid.
@param locker the transaction locker for this event
@param sid the source id for the transaction, mapped from sidno
@param gtid_spec the gtid specifier for the transaction
*/
typedef void (*set_transaction_gtid_v1_t)
(struct PSI_transaction_locker *locker,
const void *sid, const void *gtid_spec);
/**
Set the transaction trx_id.
@param locker the transaction locker for this event
@param trxid the storage engine transaction ID
*/
typedef void (*set_transaction_trxid_v1_t)
(struct PSI_transaction_locker *locker,
const ulonglong *trxid);
/**
Increment a transaction event savepoint count.
@param locker the transaction locker
@param count the increment value
*/
typedef void (*inc_transaction_savepoints_v1_t)
(struct PSI_transaction_locker *locker, ulong count);
/**
Increment a transaction event rollback to savepoint count.
@param locker the transaction locker
@param count the increment value
*/
typedef void (*inc_transaction_rollback_to_savepoint_v1_t)
(struct PSI_transaction_locker *locker, ulong count);
/**
Increment a transaction event release savepoint count.
@param locker the transaction locker
@param count the increment value
*/
typedef void (*inc_transaction_release_savepoint_v1_t)
(struct PSI_transaction_locker *locker, ulong count);
/**
Commit or rollback the transaction.
@param locker the transaction locker for this event
@param commit true if transaction was committed, false if rolled back
*/
typedef void (*end_transaction_v1_t)
(struct PSI_transaction_locker *locker,
my_bool commit);
/**
Record a socket instrumentation start event.
@param locker a socket locker for the running thread
@param op socket operation to be performed
@param count the number of bytes requested, or 0 if not applicable
@param src_file the source file name
@param src_line the source line number
*/
typedef struct PSI_socket_locker* (*start_socket_wait_v1_t)
(struct PSI_socket_locker_state_v1 *state,
struct PSI_socket *socket,
enum PSI_socket_operation op,
size_t count,
const char *src_file, uint src_line);
/**
Record a socket instrumentation end event.
Note that for socket close operations, the instrumented socket handle
associated with the socket (which was provided to obtain a locker)
is invalid after this call.
@param locker a socket locker for the running thread
@param count the number of bytes actually used in the operation,
or 0 if not applicable, or -1 if the operation failed
@sa get_thread_socket_locker
*/
typedef void (*end_socket_wait_v1_t)
(struct PSI_socket_locker *locker, size_t count);
/**
Set the socket state for an instrumented socket.
@param socket the instrumented socket
@param state socket state
*/
typedef void (*set_socket_state_v1_t)(struct PSI_socket *socket,
enum PSI_socket_state state);
/**
Set the socket info for an instrumented socket.
@param socket the instrumented socket
@param fd the socket descriptor
@param addr the socket ip address
@param addr_len length of socket ip address
@param thread_id associated thread id
*/
typedef void (*set_socket_info_v1_t)(struct PSI_socket *socket,
const my_socket *fd,
const struct sockaddr *addr,
socklen_t addr_len);
/**
Bind a socket to the thread that owns it.
@param socket instrumented socket
*/
typedef void (*set_socket_thread_owner_v1_t)(struct PSI_socket *socket);
/**
Get a prepare statement.
@param locker a statement locker for the running thread.
*/
typedef PSI_prepared_stmt* (*create_prepared_stmt_v1_t)
(void *identity, uint stmt_id, PSI_statement_locker *locker,
const char *stmt_name, size_t stmt_name_length);
/**
destroy a prepare statement.
@param prepared_stmt prepared statement.
*/
typedef void (*destroy_prepared_stmt_v1_t)
(PSI_prepared_stmt *prepared_stmt);
/**
repreare a prepare statement.
@param prepared_stmt prepared statement.
*/
typedef void (*reprepare_prepared_stmt_v1_t)
(PSI_prepared_stmt *prepared_stmt);
/**
Record a prepare statement instrumentation execute event.
@param locker a statement locker for the running thread.
@param prepared_stmt prepared statement.
*/
typedef void (*execute_prepared_stmt_v1_t)
(PSI_statement_locker *locker, PSI_prepared_stmt* prepared_stmt);
/**
Set the statement text for a prepared statement event.
@param prepared_stmt prepared statement.
@param text the prepared statement text
@param text_len the prepared statement text length
*/
typedef void (*set_prepared_stmt_text_v1_t)(PSI_prepared_stmt *prepared_stmt,
const char *text,
uint text_len);
/**
Get a digest locker for the current statement.
@param locker a statement locker for the running thread
*/
typedef struct PSI_digest_locker * (*digest_start_v1_t)
(struct PSI_statement_locker *locker);
/**
Add a token to the current digest instrumentation.
@param locker a digest locker for the current statement
@param token the lexical token to add
@param yylval the lexical token attributes
*/
typedef void (*digest_end_v1_t)
(struct PSI_digest_locker *locker, const struct sql_digest_storage *digest);
typedef PSI_sp_locker* (*start_sp_v1_t)
(struct PSI_sp_locker_state_v1 *state, struct PSI_sp_share* sp_share);
typedef void (*end_sp_v1_t)
(struct PSI_sp_locker *locker);
typedef void (*drop_sp_v1_t)
(uint object_type,
const char *schema_name, uint schema_name_length,
const char *object_name, uint object_name_length);
/**
Acquire a sp share instrumentation.
@param type of stored program
@param schema name of stored program
@param name of stored program
@return a stored program share instrumentation, or NULL
*/
typedef struct PSI_sp_share* (*get_sp_share_v1_t)
(uint object_type,
const char *schema_name, uint schema_name_length,
const char *object_name, uint object_name_length);
/**
Release a stored program share.
@param info the stored program share to release
*/
typedef void (*release_sp_share_v1_t)(struct PSI_sp_share *share);
typedef PSI_metadata_lock* (*create_metadata_lock_v1_t)
(void *identity,
const MDL_key *key,
opaque_mdl_type mdl_type,
opaque_mdl_duration mdl_duration,
opaque_mdl_status mdl_status,
const char *src_file,
uint src_line);
typedef void (*set_metadata_lock_status_v1_t)(PSI_metadata_lock *lock,
opaque_mdl_status mdl_status);
typedef void (*destroy_metadata_lock_v1_t)(PSI_metadata_lock *lock);
typedef struct PSI_metadata_locker* (*start_metadata_wait_v1_t)
(struct PSI_metadata_locker_state_v1 *state,
struct PSI_metadata_lock *mdl,
const char *src_file, uint src_line);
typedef void (*end_metadata_wait_v1_t)
(struct PSI_metadata_locker *locker, int rc);
/**
Stores an array of connection attributes
@param buffer char array of length encoded connection attributes
in network format
@param length length of the data in buffer
@param from_cs charset in which @c buffer is encoded
@return state
@retval non_0 attributes truncated
@retval 0 stored the attribute
*/
typedef int (*set_thread_connect_attrs_v1_t)(const char *buffer, uint length,
const void *from_cs);
/**
Performance Schema Interface, version 1.
@since PSI_VERSION_1
*/
struct PSI_v1
{
/** @sa register_mutex_v1_t. */
register_mutex_v1_t register_mutex;
/** @sa register_rwlock_v1_t. */
register_rwlock_v1_t register_rwlock;
/** @sa register_cond_v1_t. */
register_cond_v1_t register_cond;
/** @sa register_thread_v1_t. */
register_thread_v1_t register_thread;
/** @sa register_file_v1_t. */
register_file_v1_t register_file;
/** @sa register_stage_v1_t. */
register_stage_v1_t register_stage;
/** @sa register_statement_v1_t. */
register_statement_v1_t register_statement;
/** @sa register_socket_v1_t. */
register_socket_v1_t register_socket;
/** @sa init_mutex_v1_t. */
init_mutex_v1_t init_mutex;
/** @sa destroy_mutex_v1_t. */
destroy_mutex_v1_t destroy_mutex;
/** @sa init_rwlock_v1_t. */
init_rwlock_v1_t init_rwlock;
/** @sa destroy_rwlock_v1_t. */
destroy_rwlock_v1_t destroy_rwlock;
/** @sa init_cond_v1_t. */
init_cond_v1_t init_cond;
/** @sa destroy_cond_v1_t. */
destroy_cond_v1_t destroy_cond;
/** @sa init_socket_v1_t. */
init_socket_v1_t init_socket;
/** @sa destroy_socket_v1_t. */
destroy_socket_v1_t destroy_socket;
/** @sa get_table_share_v1_t. */
get_table_share_v1_t get_table_share;
/** @sa release_table_share_v1_t. */
release_table_share_v1_t release_table_share;
/** @sa drop_table_share_v1_t. */
drop_table_share_v1_t drop_table_share;
/** @sa open_table_v1_t. */
open_table_v1_t open_table;
/** @sa unbind_table_v1_t. */
unbind_table_v1_t unbind_table;
/** @sa rebind_table_v1_t. */
rebind_table_v1_t rebind_table;
/** @sa close_table_v1_t. */
close_table_v1_t close_table;
/** @sa create_file_v1_t. */
create_file_v1_t create_file;
/** @sa spawn_thread_v1_t. */
spawn_thread_v1_t spawn_thread;
/** @sa new_thread_v1_t. */
new_thread_v1_t new_thread;
/** @sa set_thread_id_v1_t. */
set_thread_id_v1_t set_thread_id;
/** @sa set_thread_THD_v1_t. */
set_thread_THD_v1_t set_thread_THD;
/** @sa set_thread_os_id_v1_t. */
set_thread_os_id_v1_t set_thread_os_id;
/** @sa get_thread_v1_t. */
get_thread_v1_t get_thread;
/** @sa set_thread_user_v1_t. */
set_thread_user_v1_t set_thread_user;
/** @sa set_thread_account_v1_t. */
set_thread_account_v1_t set_thread_account;
/** @sa set_thread_db_v1_t. */
set_thread_db_v1_t set_thread_db;
/** @sa set_thread_command_v1_t. */
set_thread_command_v1_t set_thread_command;
/** @sa set_connection_type_v1_t. */
set_connection_type_v1_t set_connection_type;
/** @sa set_thread_start_time_v1_t. */
set_thread_start_time_v1_t set_thread_start_time;
/** @sa set_thread_state_v1_t. */
set_thread_state_v1_t set_thread_state;
/** @sa set_thread_info_v1_t. */
set_thread_info_v1_t set_thread_info;
/** @sa set_thread_v1_t. */
set_thread_v1_t set_thread;
/** @sa delete_current_thread_v1_t. */
delete_current_thread_v1_t delete_current_thread;
/** @sa delete_thread_v1_t. */
delete_thread_v1_t delete_thread;
/** @sa get_thread_file_name_locker_v1_t. */
get_thread_file_name_locker_v1_t get_thread_file_name_locker;
/** @sa get_thread_file_stream_locker_v1_t. */
get_thread_file_stream_locker_v1_t get_thread_file_stream_locker;
/** @sa get_thread_file_descriptor_locker_v1_t. */
get_thread_file_descriptor_locker_v1_t get_thread_file_descriptor_locker;
/** @sa unlock_mutex_v1_t. */
unlock_mutex_v1_t unlock_mutex;
/** @sa unlock_rwlock_v1_t. */
unlock_rwlock_v1_t unlock_rwlock;
/** @sa signal_cond_v1_t. */
signal_cond_v1_t signal_cond;
/** @sa broadcast_cond_v1_t. */
broadcast_cond_v1_t broadcast_cond;
/** @sa start_idle_wait_v1_t. */
start_idle_wait_v1_t start_idle_wait;
/** @sa end_idle_wait_v1_t. */
end_idle_wait_v1_t end_idle_wait;
/** @sa start_mutex_wait_v1_t. */
start_mutex_wait_v1_t start_mutex_wait;
/** @sa end_mutex_wait_v1_t. */
end_mutex_wait_v1_t end_mutex_wait;
/** @sa start_rwlock_rdwait_v1_t. */
start_rwlock_rdwait_v1_t start_rwlock_rdwait;
/** @sa end_rwlock_rdwait_v1_t. */
end_rwlock_rdwait_v1_t end_rwlock_rdwait;
/** @sa start_rwlock_wrwait_v1_t. */
start_rwlock_wrwait_v1_t start_rwlock_wrwait;
/** @sa end_rwlock_wrwait_v1_t. */
end_rwlock_wrwait_v1_t end_rwlock_wrwait;
/** @sa start_cond_wait_v1_t. */
start_cond_wait_v1_t start_cond_wait;
/** @sa end_cond_wait_v1_t. */
end_cond_wait_v1_t end_cond_wait;
/** @sa start_table_io_wait_v1_t. */
start_table_io_wait_v1_t start_table_io_wait;
/** @sa end_table_io_wait_v1_t. */
end_table_io_wait_v1_t end_table_io_wait;
/** @sa start_table_lock_wait_v1_t. */
start_table_lock_wait_v1_t start_table_lock_wait;
/** @sa end_table_lock_wait_v1_t. */
end_table_lock_wait_v1_t end_table_lock_wait;
/** @sa start_file_open_wait_v1_t. */
start_file_open_wait_v1_t start_file_open_wait;
/** @sa end_file_open_wait_v1_t. */
end_file_open_wait_v1_t end_file_open_wait;
/** @sa end_file_open_wait_and_bind_to_descriptor_v1_t. */
end_file_open_wait_and_bind_to_descriptor_v1_t
end_file_open_wait_and_bind_to_descriptor;
/** @sa end_temp_file_open_wait_and_bind_to_descriptor_v1_t. */
end_temp_file_open_wait_and_bind_to_descriptor_v1_t
end_temp_file_open_wait_and_bind_to_descriptor;
/** @sa start_file_wait_v1_t. */
start_file_wait_v1_t start_file_wait;
/** @sa end_file_wait_v1_t. */
end_file_wait_v1_t end_file_wait;
/** @sa start_file_close_wait_v1_t. */
start_file_close_wait_v1_t start_file_close_wait;
/** @sa end_file_close_wait_v1_t. */
end_file_close_wait_v1_t end_file_close_wait;
/** @sa rename_file_close_wait_v1_t. */
end_file_rename_wait_v1_t end_file_rename_wait;
/** @sa start_stage_v1_t. */
start_stage_v1_t start_stage;
/** @sa get_current_stage_progress_v1_t. */
get_current_stage_progress_v1_t get_current_stage_progress;
/** @sa end_stage_v1_t. */
end_stage_v1_t end_stage;
/** @sa get_thread_statement_locker_v1_t. */
get_thread_statement_locker_v1_t get_thread_statement_locker;
/** @sa refine_statement_v1_t. */
refine_statement_v1_t refine_statement;
/** @sa start_statement_v1_t. */
start_statement_v1_t start_statement;
/** @sa set_statement_text_v1_t. */
set_statement_text_v1_t set_statement_text;
/** @sa set_statement_lock_time_t. */
set_statement_lock_time_t set_statement_lock_time;
/** @sa set_statement_rows_sent_t. */
set_statement_rows_sent_t set_statement_rows_sent;
/** @sa set_statement_rows_examined_t. */
set_statement_rows_examined_t set_statement_rows_examined;
/** @sa inc_statement_created_tmp_disk_tables. */
inc_statement_created_tmp_disk_tables_t inc_statement_created_tmp_disk_tables;
/** @sa inc_statement_created_tmp_tables. */
inc_statement_created_tmp_tables_t inc_statement_created_tmp_tables;
/** @sa inc_statement_select_full_join. */
inc_statement_select_full_join_t inc_statement_select_full_join;
/** @sa inc_statement_select_full_range_join. */
inc_statement_select_full_range_join_t inc_statement_select_full_range_join;
/** @sa inc_statement_select_range. */
inc_statement_select_range_t inc_statement_select_range;
/** @sa inc_statement_select_range_check. */
inc_statement_select_range_check_t inc_statement_select_range_check;
/** @sa inc_statement_select_scan. */
inc_statement_select_scan_t inc_statement_select_scan;
/** @sa inc_statement_sort_merge_passes. */
inc_statement_sort_merge_passes_t inc_statement_sort_merge_passes;
/** @sa inc_statement_sort_range. */
inc_statement_sort_range_t inc_statement_sort_range;
/** @sa inc_statement_sort_rows. */
inc_statement_sort_rows_t inc_statement_sort_rows;
/** @sa inc_statement_sort_scan. */
inc_statement_sort_scan_t inc_statement_sort_scan;
/** @sa set_statement_no_index_used. */
set_statement_no_index_used_t set_statement_no_index_used;
/** @sa set_statement_no_good_index_used. */
set_statement_no_good_index_used_t set_statement_no_good_index_used;
/** @sa end_statement_v1_t. */
end_statement_v1_t end_statement;
/** @sa get_thread_transaction_locker_v1_t. */
get_thread_transaction_locker_v1_t get_thread_transaction_locker;
/** @sa start_transaction_v1_t. */
start_transaction_v1_t start_transaction;
/** @sa set_transaction_xid_v1_t. */
set_transaction_xid_v1_t set_transaction_xid;
/** @sa set_transaction_xa_state_v1_t. */
set_transaction_xa_state_v1_t set_transaction_xa_state;
/** @sa set_transaction_gtid_v1_t. */
set_transaction_gtid_v1_t set_transaction_gtid;
/** @sa set_transaction_trxid_v1_t. */
set_transaction_trxid_v1_t set_transaction_trxid;
/** @sa inc_transaction_savepoints_v1_t. */
inc_transaction_savepoints_v1_t inc_transaction_savepoints;
/** @sa inc_transaction_rollback_to_savepoint_v1_t. */
inc_transaction_rollback_to_savepoint_v1_t inc_transaction_rollback_to_savepoint;
/** @sa inc_transaction_release_savepoint_v1_t. */
inc_transaction_release_savepoint_v1_t inc_transaction_release_savepoint;
/** @sa end_transaction_v1_t. */
end_transaction_v1_t end_transaction;
/** @sa start_socket_wait_v1_t. */
start_socket_wait_v1_t start_socket_wait;
/** @sa end_socket_wait_v1_t. */
end_socket_wait_v1_t end_socket_wait;
/** @sa set_socket_state_v1_t. */
set_socket_state_v1_t set_socket_state;
/** @sa set_socket_info_v1_t. */
set_socket_info_v1_t set_socket_info;
/** @sa set_socket_thread_owner_v1_t. */
set_socket_thread_owner_v1_t set_socket_thread_owner;
/** @sa create_prepared_stmt_v1_t. */
create_prepared_stmt_v1_t create_prepared_stmt;
/** @sa destroy_prepared_stmt_v1_t. */
destroy_prepared_stmt_v1_t destroy_prepared_stmt;
/** @sa reprepare_prepared_stmt_v1_t. */
reprepare_prepared_stmt_v1_t reprepare_prepared_stmt;
/** @sa execute_prepared_stmt_v1_t. */
execute_prepared_stmt_v1_t execute_prepared_stmt;
/** @sa set_prepared_stmt_text_v1_t. */
set_prepared_stmt_text_v1_t set_prepared_stmt_text;
/** @sa digest_start_v1_t. */
digest_start_v1_t digest_start;
/** @sa digest_end_v1_t. */
digest_end_v1_t digest_end;
/** @sa set_thread_connect_attrs_v1_t. */
set_thread_connect_attrs_v1_t set_thread_connect_attrs;
/** @sa start_sp_v1_t. */
start_sp_v1_t start_sp;
/** @sa start_sp_v1_t. */
end_sp_v1_t end_sp;
/** @sa drop_sp_v1_t. */
drop_sp_v1_t drop_sp;
/** @sa get_sp_share_v1_t. */
get_sp_share_v1_t get_sp_share;
/** @sa release_sp_share_v1_t. */
release_sp_share_v1_t release_sp_share;
/** @sa register_memory_v1_t. */
register_memory_v1_t register_memory;
/** @sa memory_alloc_v1_t. */
memory_alloc_v1_t memory_alloc;
/** @sa memory_realloc_v1_t. */
memory_realloc_v1_t memory_realloc;
/** @sa memory_claim_v1_t. */
memory_claim_v1_t memory_claim;
/** @sa memory_free_v1_t. */
memory_free_v1_t memory_free;
unlock_table_v1_t unlock_table;
create_metadata_lock_v1_t create_metadata_lock;
set_metadata_lock_status_v1_t set_metadata_lock_status;
destroy_metadata_lock_v1_t destroy_metadata_lock;
start_metadata_wait_v1_t start_metadata_wait;
end_metadata_wait_v1_t end_metadata_wait;
set_thread_peer_port_v1_t set_thread_peer_port;
};
/** @} (end of group Group_PSI_v1) */
#endif /* HAVE_PSI_1 */
#ifdef USE_PSI_2
#define HAVE_PSI_2
#endif
#ifdef HAVE_PSI_2
/**
@defgroup Group_PSI_v2 Application Binary Interface, version 2
@ingroup Instrumentation_interface
@{
*/
/**
Performance Schema Interface, version 2.
This is a placeholder, this interface is not defined yet.
@since PSI_VERSION_2
*/
struct PSI_v2
{
/** Placeholder */
int placeholder;
/* ... extended interface ... */
};
/** Placeholder */
struct PSI_mutex_info_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_rwlock_info_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_cond_info_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_thread_info_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_file_info_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_stage_info_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_statement_info_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_transaction_info_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_idle_locker_state_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_mutex_locker_state_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_rwlock_locker_state_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_cond_locker_state_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_file_locker_state_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_statement_locker_state_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_transaction_locker_state_v2
{
/** Placeholder */
int placeholder;
};
/** Placeholder */
struct PSI_socket_locker_state_v2
{
/** Placeholder */
int placeholder;
};
struct PSI_metadata_locker_state_v2
{
int placeholder;
};
/** @} (end of group Group_PSI_v2) */
#endif /* HAVE_PSI_2 */
/**
@typedef PSI
The instrumentation interface for the current version.
@sa PSI_CURRENT_VERSION
*/
/**
@typedef PSI_mutex_info
The mutex information structure for the current version.
*/
/**
@typedef PSI_rwlock_info
The rwlock information structure for the current version.
*/
/**
@typedef PSI_cond_info
The cond information structure for the current version.
*/
/**
@typedef PSI_thread_info
The thread information structure for the current version.
*/
/**
@typedef PSI_file_info
The file information structure for the current version.
*/
/* Export the required version */
#ifdef USE_PSI_1
typedef struct PSI_v1 PSI;
typedef struct PSI_mutex_info_v1 PSI_mutex_info;
typedef struct PSI_rwlock_info_v1 PSI_rwlock_info;
typedef struct PSI_cond_info_v1 PSI_cond_info;
typedef struct PSI_thread_info_v1 PSI_thread_info;
typedef struct PSI_file_info_v1 PSI_file_info;
typedef struct PSI_stage_info_v1 PSI_stage_info;
typedef struct PSI_statement_info_v1 PSI_statement_info;
typedef struct PSI_transaction_info_v1 PSI_transaction_info;
typedef struct PSI_socket_info_v1 PSI_socket_info;
typedef struct PSI_idle_locker_state_v1 PSI_idle_locker_state;
typedef struct PSI_mutex_locker_state_v1 PSI_mutex_locker_state;
typedef struct PSI_rwlock_locker_state_v1 PSI_rwlock_locker_state;
typedef struct PSI_cond_locker_state_v1 PSI_cond_locker_state;
typedef struct PSI_file_locker_state_v1 PSI_file_locker_state;
typedef struct PSI_statement_locker_state_v1 PSI_statement_locker_state;
typedef struct PSI_transaction_locker_state_v1 PSI_transaction_locker_state;
typedef struct PSI_socket_locker_state_v1 PSI_socket_locker_state;
typedef struct PSI_sp_locker_state_v1 PSI_sp_locker_state;
typedef struct PSI_metadata_locker_state_v1 PSI_metadata_locker_state;
#endif
#ifdef USE_PSI_2
typedef struct PSI_v2 PSI;
typedef struct PSI_mutex_info_v2 PSI_mutex_info;
typedef struct PSI_rwlock_info_v2 PSI_rwlock_info;
typedef struct PSI_cond_info_v2 PSI_cond_info;
typedef struct PSI_thread_info_v2 PSI_thread_info;
typedef struct PSI_file_info_v2 PSI_file_info;
typedef struct PSI_stage_info_v2 PSI_stage_info;
typedef struct PSI_statement_info_v2 PSI_statement_info;
typedef struct PSI_transaction_info_v2 PSI_transaction_info;
typedef struct PSI_socket_info_v2 PSI_socket_info;
typedef struct PSI_idle_locker_state_v2 PSI_idle_locker_state;
typedef struct PSI_mutex_locker_state_v2 PSI_mutex_locker_state;
typedef struct PSI_rwlock_locker_state_v2 PSI_rwlock_locker_state;
typedef struct PSI_cond_locker_state_v2 PSI_cond_locker_state;
typedef struct PSI_file_locker_state_v2 PSI_file_locker_state;
typedef struct PSI_statement_locker_state_v2 PSI_statement_locker_state;
typedef struct PSI_transaction_locker_state_v2 PSI_transaction_locker_state;
typedef struct PSI_socket_locker_state_v2 PSI_socket_locker_state;
typedef struct PSI_sp_locker_state_v2 PSI_sp_locker_state;
typedef struct PSI_metadata_locker_state_v2 PSI_metadata_locker_state;
#endif
#ifndef HAVE_PSI_INTERFACE
/**
Dummy structure, used to declare PSI_server when no instrumentation
is available.
The content does not matter, since PSI_server will be NULL.
*/
struct PSI_none
{
int opaque;
};
typedef struct PSI_none PSI;
/**
Stage instrument information.
@since PSI_VERSION_1
This structure is used to register an instrumented stage.
*/
struct PSI_stage_info_none
{
/** Unused stage key. */
unsigned int m_key;
/** The name of the stage instrument. */
const char *m_name;
/** Unused stage flags. */
int m_flags;
};
/**
The stage instrumentation has to co exist with the legacy
THD::set_proc_info instrumentation.
To avoid duplication of the instrumentation in the server,
the common PSI_stage_info structure is used,
so we export it here, even when not building
with HAVE_PSI_INTERFACE.
*/
typedef struct PSI_stage_info_none PSI_stage_info;
typedef struct PSI_stage_info_none PSI_statement_info;
typedef struct PSI_stage_info_none PSI_sp_locker_state;
typedef struct PSI_stage_info_none PSI_metadata_locker_state;
typedef struct PSI_stage_info_none PSI_metadata_locker;
#endif /* HAVE_PSI_INTERFACE */
extern MYSQL_PLUGIN_IMPORT PSI *PSI_server;
/*
Allow to override PSI_XXX_CALL at compile time
with more efficient implementations, if available.
If nothing better is available,
make a dynamic call using the PSI_server function pointer.
*/
#define PSI_DYNAMIC_CALL(M) PSI_server->M
/** @} */
C_MODE_END
#endif /* MYSQL_PERFORMANCE_SCHEMA_INTERFACE_H */
PK ! Y:؟ ؟ mysql/psi/mysql_file.hnu [ /* Copyright (c) 2008, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_FILE_H
#define MYSQL_FILE_H
/* For strlen() */
#include
/* For MY_STAT */
#include
/* For my_chsize */
#include
/**
@file mysql/psi/mysql_file.h
Instrumentation helpers for mysys file io.
This header file provides the necessary declarations
to use the mysys file API with the performance schema instrumentation.
In some compilers (SunStudio), 'static inline' functions, when declared
but not used, are not optimized away (because they are unused) by default,
so that including a static inline function from a header file does
create unwanted dependencies, causing unresolved symbols at link time.
Other compilers, like gcc, optimize these dependencies by default.
Since the instrumented APIs declared here are wrapper on top
of mysys file io APIs, including mysql/psi/mysql_file.h assumes that
the dependency on my_sys already exists.
*/
#include "mysql/psi/psi.h"
#ifndef PSI_FILE_CALL
#define PSI_FILE_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
/**
@defgroup File_instrumentation File Instrumentation
@ingroup Instrumentation_interface
@{
*/
/**
@def mysql_file_register(P1, P2, P3)
File registration.
*/
#define mysql_file_register(P1, P2, P3) \
inline_mysql_file_register(P1, P2, P3)
/**
@def mysql_file_fgets(P1, P2, F)
Instrumented fgets.
@c mysql_file_fgets is a replacement for @c fgets.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fgets(P1, P2, F) \
inline_mysql_file_fgets(__FILE__, __LINE__, P1, P2, F)
#else
#define mysql_file_fgets(P1, P2, F) \
inline_mysql_file_fgets(P1, P2, F)
#endif
/**
@def mysql_file_fgetc(F)
Instrumented fgetc.
@c mysql_file_fgetc is a replacement for @c fgetc.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fgetc(F) inline_mysql_file_fgetc(__FILE__, __LINE__, F)
#else
#define mysql_file_fgetc(F) inline_mysql_file_fgetc(F)
#endif
/**
@def mysql_file_fputs(P1, F)
Instrumented fputs.
@c mysql_file_fputs is a replacement for @c fputs.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fputs(P1, F) \
inline_mysql_file_fputs(__FILE__, __LINE__, P1, F)
#else
#define mysql_file_fputs(P1, F)\
inline_mysql_file_fputs(P1, F)
#endif
/**
@def mysql_file_fputc(P1, F)
Instrumented fputc.
@c mysql_file_fputc is a replacement for @c fputc.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fputc(P1, F) \
inline_mysql_file_fputc(__FILE__, __LINE__, P1, F)
#else
#define mysql_file_fputc(P1, F) \
inline_mysql_file_fputc(P1, F)
#endif
/**
@def mysql_file_fprintf
Instrumented fprintf.
@c mysql_file_fprintf is a replacement for @c fprintf.
*/
#define mysql_file_fprintf inline_mysql_file_fprintf
/**
@def mysql_file_vfprintf(F, P1, P2)
Instrumented vfprintf.
@c mysql_file_vfprintf is a replacement for @c vfprintf.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_vfprintf(F, P1, P2) \
inline_mysql_file_vfprintf(__FILE__, __LINE__, F, P1, P2)
#else
#define mysql_file_vfprintf(F, P1, P2) \
inline_mysql_file_vfprintf(F, P1, P2)
#endif
/**
@def mysql_file_fflush(F, P1, P2)
Instrumented fflush.
@c mysql_file_fflush is a replacement for @c fflush.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fflush(F) \
inline_mysql_file_fflush(__FILE__, __LINE__, F)
#else
#define mysql_file_fflush(F) \
inline_mysql_file_fflush(F)
#endif
/**
@def mysql_file_feof(F)
Instrumented feof.
@c mysql_file_feof is a replacement for @c feof.
*/
#define mysql_file_feof(F) inline_mysql_file_feof(F)
/**
@def mysql_file_fstat(FN, S, FL)
Instrumented fstat.
@c mysql_file_fstat is a replacement for @c my_fstat.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fstat(FN, S, FL) \
inline_mysql_file_fstat(__FILE__, __LINE__, FN, S, FL)
#else
#define mysql_file_fstat(FN, S, FL) \
inline_mysql_file_fstat(FN, S, FL)
#endif
/**
@def mysql_file_stat(K, FN, S, FL)
Instrumented stat.
@c mysql_file_stat is a replacement for @c my_stat.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_stat(K, FN, S, FL) \
inline_mysql_file_stat(K, __FILE__, __LINE__, FN, S, FL)
#else
#define mysql_file_stat(K, FN, S, FL) \
inline_mysql_file_stat(FN, S, FL)
#endif
/**
@def mysql_file_chsize(F, P1, P2, P3)
Instrumented chsize.
@c mysql_file_chsize is a replacement for @c my_chsize.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_chsize(F, P1, P2, P3) \
inline_mysql_file_chsize(__FILE__, __LINE__, F, P1, P2, P3)
#else
#define mysql_file_chsize(F, P1, P2, P3) \
inline_mysql_file_chsize(F, P1, P2, P3)
#endif
/**
@def mysql_file_fopen(K, N, F1, F2)
Instrumented fopen.
@c mysql_file_fopen is a replacement for @c my_fopen.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fopen(K, N, F1, F2) \
inline_mysql_file_fopen(K, __FILE__, __LINE__, N, F1, F2)
#else
#define mysql_file_fopen(K, N, F1, F2) \
inline_mysql_file_fopen(N, F1, F2)
#endif
/**
@def mysql_file_fclose(FD, FL)
Instrumented fclose.
@c mysql_file_fclose is a replacement for @c my_fclose.
Without the instrumentation, this call will have the same behavior as the
undocumented and possibly platform specific my_fclose(NULL, ...) behavior.
With the instrumentation, mysql_fclose(NULL, ...) will safely return 0,
which is an extension compared to my_fclose and is therefore compliant.
mysql_fclose is on purpose *not* implementing
@code assert(file != NULL) @endcode,
since doing so could introduce regressions.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fclose(FD, FL) \
inline_mysql_file_fclose(__FILE__, __LINE__, FD, FL)
#else
#define mysql_file_fclose(FD, FL) \
inline_mysql_file_fclose(FD, FL)
#endif
/**
@def mysql_file_fread(FD, P1, P2, P3)
Instrumented fread.
@c mysql_file_fread is a replacement for @c my_fread.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fread(FD, P1, P2, P3) \
inline_mysql_file_fread(__FILE__, __LINE__, FD, P1, P2, P3)
#else
#define mysql_file_fread(FD, P1, P2, P3) \
inline_mysql_file_fread(FD, P1, P2, P3)
#endif
/**
@def mysql_file_fwrite(FD, P1, P2, P3)
Instrumented fwrite.
@c mysql_file_fwrite is a replacement for @c my_fwrite.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fwrite(FD, P1, P2, P3) \
inline_mysql_file_fwrite(__FILE__, __LINE__, FD, P1, P2, P3)
#else
#define mysql_file_fwrite(FD, P1, P2, P3) \
inline_mysql_file_fwrite(FD, P1, P2, P3)
#endif
/**
@def mysql_file_fseek(FD, P, W, F)
Instrumented fseek.
@c mysql_file_fseek is a replacement for @c my_fseek.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_fseek(FD, P, W, F) \
inline_mysql_file_fseek(__FILE__, __LINE__, FD, P, W, F)
#else
#define mysql_file_fseek(FD, P, W, F) \
inline_mysql_file_fseek(FD, P, W, F)
#endif
/**
@def mysql_file_ftell(FD, F)
Instrumented ftell.
@c mysql_file_ftell is a replacement for @c my_ftell.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_ftell(FD, F) \
inline_mysql_file_ftell(__FILE__, __LINE__, FD, F)
#else
#define mysql_file_ftell(FD, F) \
inline_mysql_file_ftell(FD, F)
#endif
/**
@def mysql_file_create(K, N, F1, F2, F3)
Instrumented create.
@c mysql_file_create is a replacement for @c my_create.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_create(K, N, F1, F2, F3) \
inline_mysql_file_create(K, __FILE__, __LINE__, N, F1, F2, F3)
#else
#define mysql_file_create(K, N, F1, F2, F3) \
inline_mysql_file_create(N, F1, F2, F3)
#endif
/**
@def mysql_file_create_temp(K, T, D, P, M, F)
Instrumented create_temp_file.
@c mysql_file_create_temp is a replacement for @c create_temp_file.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_create_temp(K, T, D, P, M, F) \
inline_mysql_file_create_temp(K, __FILE__, __LINE__, T, D, P, M, F)
#else
#define mysql_file_create_temp(K, T, D, P, M, F) \
inline_mysql_file_create_temp(T, D, P, M, F)
#endif
/**
@def mysql_file_open(K, N, F1, F2)
Instrumented open.
@c mysql_file_open is a replacement for @c my_open.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_open(K, N, F1, F2) \
inline_mysql_file_open(K, __FILE__, __LINE__, N, F1, F2)
#else
#define mysql_file_open(K, N, F1, F2) \
inline_mysql_file_open(N, F1, F2)
#endif
/**
@def mysql_file_close(FD, F)
Instrumented close.
@c mysql_file_close is a replacement for @c my_close.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_close(FD, F) \
inline_mysql_file_close(__FILE__, __LINE__, FD, F)
#else
#define mysql_file_close(FD, F) \
inline_mysql_file_close(FD, F)
#endif
/**
@def mysql_file_read(FD, B, S, F)
Instrumented read.
@c mysql_read is a replacement for @c my_read.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_read(FD, B, S, F) \
inline_mysql_file_read(__FILE__, __LINE__, FD, B, S, F)
#else
#define mysql_file_read(FD, B, S, F) \
inline_mysql_file_read(FD, B, S, F)
#endif
/**
@def mysql_file_write(FD, B, S, F)
Instrumented write.
@c mysql_file_write is a replacement for @c my_write.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_write(FD, B, S, F) \
inline_mysql_file_write(__FILE__, __LINE__, FD, B, S, F)
#else
#define mysql_file_write(FD, B, S, F) \
inline_mysql_file_write(FD, B, S, F)
#endif
/**
@def mysql_file_pread(FD, B, S, O, F)
Instrumented pread.
@c mysql_pread is a replacement for @c my_pread.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_pread(FD, B, S, O, F) \
inline_mysql_file_pread(__FILE__, __LINE__, FD, B, S, O, F)
#else
#define mysql_file_pread(FD, B, S, O, F) \
inline_mysql_file_pread(FD, B, S, O, F)
#endif
/**
@def mysql_file_pwrite(FD, B, S, O, F)
Instrumented pwrite.
@c mysql_file_pwrite is a replacement for @c my_pwrite.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_pwrite(FD, B, S, O, F) \
inline_mysql_file_pwrite(__FILE__, __LINE__, FD, B, S, O, F)
#else
#define mysql_file_pwrite(FD, B, S, O, F) \
inline_mysql_file_pwrite(FD, B, S, O, F)
#endif
/**
@def mysql_file_seek(FD, P, W, F)
Instrumented seek.
@c mysql_file_seek is a replacement for @c my_seek.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_seek(FD, P, W, F) \
inline_mysql_file_seek(__FILE__, __LINE__, FD, P, W, F)
#else
#define mysql_file_seek(FD, P, W, F) \
inline_mysql_file_seek(FD, P, W, F)
#endif
/**
@def mysql_file_tell(FD, F)
Instrumented tell.
@c mysql_file_tell is a replacement for @c my_tell.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_tell(FD, F) \
inline_mysql_file_tell(__FILE__, __LINE__, FD, F)
#else
#define mysql_file_tell(FD, F) \
inline_mysql_file_tell(FD, F)
#endif
/**
@def mysql_file_delete(K, P1, P2)
Instrumented delete.
@c mysql_file_delete is a replacement for @c my_delete.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_delete(K, P1, P2) \
inline_mysql_file_delete(K, __FILE__, __LINE__, P1, P2)
#else
#define mysql_file_delete(K, P1, P2) \
inline_mysql_file_delete(P1, P2)
#endif
/**
@def mysql_file_rename(K, P1, P2, P3)
Instrumented rename.
@c mysql_file_rename is a replacement for @c my_rename.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_rename(K, P1, P2, P3) \
inline_mysql_file_rename(K, __FILE__, __LINE__, P1, P2, P3)
#else
#define mysql_file_rename(K, P1, P2, P3) \
inline_mysql_file_rename(P1, P2, P3)
#endif
/**
@def mysql_file_create_with_symlink(K, P1, P2, P3, P4, P5)
Instrumented create with symbolic link.
@c mysql_file_create_with_symlink is a replacement
for @c my_create_with_symlink.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_create_with_symlink(K, P1, P2, P3, P4, P5) \
inline_mysql_file_create_with_symlink(K, __FILE__, __LINE__, \
P1, P2, P3, P4, P5)
#else
#define mysql_file_create_with_symlink(K, P1, P2, P3, P4, P5) \
inline_mysql_file_create_with_symlink(P1, P2, P3, P4, P5)
#endif
/**
@def mysql_file_delete_with_symlink(K, P1, P2, P3)
Instrumented delete with symbolic link.
@c mysql_file_delete_with_symlink is a replacement
for @c my_handler_delete_with_symlink.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_delete_with_symlink(K, P1, P2, P3) \
inline_mysql_file_delete_with_symlink(K, __FILE__, __LINE__, P1, P2, P3)
#else
#define mysql_file_delete_with_symlink(K, P1, P2, P3) \
inline_mysql_file_delete_with_symlink(P1, P2, P3)
#endif
/**
@def mysql_file_rename_with_symlink(K, P1, P2, P3)
Instrumented rename with symbolic link.
@c mysql_file_rename_with_symlink is a replacement
for @c my_rename_with_symlink.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_rename_with_symlink(K, P1, P2, P3) \
inline_mysql_file_rename_with_symlink(K, __FILE__, __LINE__, P1, P2, P3)
#else
#define mysql_file_rename_with_symlink(K, P1, P2, P3) \
inline_mysql_file_rename_with_symlink(P1, P2, P3)
#endif
/**
@def mysql_file_sync(P1, P2)
Instrumented file sync.
@c mysql_file_sync is a replacement for @c my_sync.
*/
#ifdef HAVE_PSI_FILE_INTERFACE
#define mysql_file_sync(P1, P2) \
inline_mysql_file_sync(__FILE__, __LINE__, P1, P2)
#else
#define mysql_file_sync(P1, P2) \
inline_mysql_file_sync(P1, P2)
#endif
/**
An instrumented FILE structure.
@sa MYSQL_FILE
*/
struct st_mysql_file
{
/** The real file. */
FILE *m_file;
/**
The instrumentation hook.
Note that this hook is not conditionally defined,
for binary compatibility of the @c MYSQL_FILE interface.
*/
struct PSI_file *m_psi;
};
/**
Type of an instrumented file.
@c MYSQL_FILE is a drop-in replacement for @c FILE.
@sa mysql_file_open
*/
typedef struct st_mysql_file MYSQL_FILE;
static inline void inline_mysql_file_register(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *category,
PSI_file_info *info,
int count
#else
const char *category __attribute__ ((unused)),
void *info __attribute__ ((unused)),
int count __attribute__ ((unused))
#endif
)
{
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_FILE_CALL(register_file)(category, info, count);
#endif
}
static inline char *
inline_mysql_file_fgets(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
char *str, int size, MYSQL_FILE *file)
{
char *result;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker) (&state, file->m_psi, PSI_FILE_READ);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) size, src_file, src_line);
result= fgets(str, size, file->m_file);
PSI_FILE_CALL(end_file_wait)(locker, result ? strlen(result) : 0);
return result;
}
}
#endif
result= fgets(str, size, file->m_file);
return result;
}
static inline int
inline_mysql_file_fgetc(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_FILE *file)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi, PSI_FILE_READ);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 1, src_file, src_line);
result= fgetc(file->m_file);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 1);
return result;
}
}
#endif
result= fgetc(file->m_file);
return result;
}
static inline int
inline_mysql_file_fputs(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
const char *str, MYSQL_FILE *file)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes;
locker= PSI_FILE_CALL(get_thread_file_stream_locker) (&state, file->m_psi, PSI_FILE_WRITE);
if (likely(locker != NULL))
{
bytes= str ? strlen(str) : 0;
PSI_FILE_CALL(start_file_wait)(locker, bytes, src_file, src_line);
result= fputs(str, file->m_file);
PSI_FILE_CALL(end_file_wait)(locker, bytes);
return result;
}
}
#endif
result= fputs(str, file->m_file);
return result;
}
static inline int
inline_mysql_file_fputc(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
char c, MYSQL_FILE *file)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker) (&state, file->m_psi, PSI_FILE_WRITE);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 1, src_file, src_line);
result= fputc(c, file->m_file);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 1);
return result;
}
}
#endif
result= fputc(c, file->m_file);
return result;
}
static inline int
inline_mysql_file_fprintf(MYSQL_FILE *file, const char *format, ...)
{
/*
TODO: figure out how to pass src_file and src_line from the caller.
*/
int result;
va_list args;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker) (&state, file->m_psi, PSI_FILE_WRITE);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, __FILE__, __LINE__);
va_start(args, format);
result= vfprintf(file->m_file, format, args);
va_end(args);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) result);
return result;
}
}
#endif
va_start(args, format);
result= vfprintf(file->m_file, format, args);
va_end(args);
return result;
}
static inline int
inline_mysql_file_vfprintf(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_FILE *file, const char *format, va_list args)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker) (&state, file->m_psi, PSI_FILE_WRITE);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= vfprintf(file->m_file, format, args);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) result);
return result;
}
}
#endif
result= vfprintf(file->m_file, format, args);
return result;
}
static inline int
inline_mysql_file_fflush(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_FILE *file)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi, PSI_FILE_FLUSH);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= fflush(file->m_file);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
}
#endif
result= fflush(file->m_file);
return result;
}
static inline int inline_mysql_file_feof(MYSQL_FILE *file)
{
/* Not instrumented, there is no wait involved */
return feof(file->m_file);
}
static inline int
inline_mysql_file_fstat(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
int filenr, MY_STAT *stat_area, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, filenr, PSI_FILE_FSTAT);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_fstat(filenr, stat_area, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_fstat(filenr, stat_area, flags);
return result;
}
static inline MY_STAT *
inline_mysql_file_stat(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *path, MY_STAT *stat_area, myf flags)
{
MY_STAT *result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_STAT, path, NULL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
result= my_stat(path, stat_area, flags);
PSI_FILE_CALL(end_file_open_wait)(locker, result);
return result;
}
#endif
result= my_stat(path, stat_area, flags);
return result;
}
static inline int
inline_mysql_file_chsize(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, my_off_t newlength, int filler, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_CHSIZE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) newlength, src_file,
src_line);
result= my_chsize(file, newlength, filler, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) newlength);
return result;
}
#endif
result= my_chsize(file, newlength, filler, flags);
return result;
}
static inline MYSQL_FILE*
inline_mysql_file_fopen(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *filename, int flags, myf myFlags)
{
MYSQL_FILE *that;
that= (MYSQL_FILE*) my_malloc(PSI_NOT_INSTRUMENTED,
sizeof(MYSQL_FILE), MYF(MY_WME));
if (likely(that != NULL))
{
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_STREAM_OPEN,
filename, that);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
that->m_file= my_fopen(filename, flags, myFlags);
that->m_psi= PSI_FILE_CALL(end_file_open_wait)(locker, that->m_file);
if (unlikely(that->m_file == NULL))
{
my_free(that);
return NULL;
}
return that;
}
#endif
that->m_psi= NULL;
that->m_file= my_fopen(filename, flags, myFlags);
if (unlikely(that->m_file == NULL))
{
my_free(that);
return NULL;
}
}
return that;
}
static inline int
inline_mysql_file_fclose(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_FILE *file, myf flags)
{
int result= 0;
if (likely(file != NULL))
{
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,
PSI_FILE_STREAM_CLOSE);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_fclose(file->m_file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
my_free(file);
return result;
}
}
#endif
result= my_fclose(file->m_file, flags);
my_free(file);
}
return result;
}
static inline size_t
inline_mysql_file_fread(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_FILE *file, uchar *buffer, size_t count, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_read;
locker= PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi, PSI_FILE_READ);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_fread(file->m_file, buffer, count, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_read= (result == 0) ? count : 0;
else
bytes_read= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_read);
return result;
}
}
#endif
result= my_fread(file->m_file, buffer, count, flags);
return result;
}
static inline size_t
inline_mysql_file_fwrite(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_FILE *file, const uchar *buffer, size_t count, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_written;
locker= PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi, PSI_FILE_WRITE);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_fwrite(file->m_file, buffer, count, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_written= (result == 0) ? count : 0;
else
bytes_written= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_written);
return result;
}
}
#endif
result= my_fwrite(file->m_file, buffer, count, flags);
return result;
}
static inline my_off_t
inline_mysql_file_fseek(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_FILE *file, my_off_t pos, int whence, myf flags)
{
my_off_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi, PSI_FILE_SEEK);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_fseek(file->m_file, pos, whence, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
}
#endif
result= my_fseek(file->m_file, pos, whence, flags);
return result;
}
static inline my_off_t
inline_mysql_file_ftell(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_FILE *file, myf flags)
{
my_off_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
if (psi_likely(file->m_psi))
{
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi, PSI_FILE_TELL);
if (likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_ftell(file->m_file, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
}
#endif
result= my_ftell(file->m_file, flags);
return result;
}
static inline File
inline_mysql_file_create(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *filename, mode_t create_flags, int access_flags, myf myFlags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_CREATE, filename,
NULL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_create(filename, create_flags, access_flags, myFlags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_create(filename, create_flags, access_flags, myFlags);
return file;
}
static inline File
inline_mysql_file_create_temp(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
char *to, const char *dir, const char *pfx, int mode, myf myFlags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)
(&state, key, PSI_FILE_CREATE, NULL, NULL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
/* The file name is generated by create_temp_file(). */
file= create_temp_file(to, dir, pfx, mode, myFlags);
PSI_FILE_CALL(end_temp_file_open_wait_and_bind_to_descriptor)(locker, file, (const char*)to);
return file;
}
#endif
file= create_temp_file(to, dir, pfx, mode, myFlags);
return file;
}
static inline File
inline_mysql_file_open(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *filename, int flags, myf myFlags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_OPEN, filename,
NULL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_open(filename, flags, myFlags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_open(filename, flags, myFlags);
return file;
}
static inline int
inline_mysql_file_close(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_CLOSE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_close(file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_close(file, flags);
return result;
}
static inline size_t
inline_mysql_file_read(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, uchar *buffer, size_t count, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_read;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_READ);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_read(file, buffer, count, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_read= (result == 0) ? count : 0;
else
bytes_read= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_read);
return result;
}
#endif
result= my_read(file, buffer, count, flags);
return result;
}
static inline size_t
inline_mysql_file_write(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, const uchar *buffer, size_t count, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_written;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_WRITE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_write(file, buffer, count, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_written= (result == 0) ? count : 0;
else
bytes_written= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_written);
return result;
}
#endif
result= my_write(file, buffer, count, flags);
return result;
}
static inline size_t
inline_mysql_file_pread(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, uchar *buffer, size_t count, my_off_t offset, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_read;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_READ);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_pread(file, buffer, count, offset, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_read= (result == 0) ? count : 0;
else
bytes_read= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_read);
return result;
}
#endif
result= my_pread(file, buffer, count, offset, flags);
return result;
}
static inline size_t
inline_mysql_file_pwrite(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, const uchar *buffer, size_t count, my_off_t offset, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_written;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_WRITE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_pwrite(file, buffer, count, offset, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_written= (result == 0) ? count : 0;
else
bytes_written= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_written);
return result;
}
#endif
result= my_pwrite(file, buffer, count, offset, flags);
return result;
}
static inline my_off_t
inline_mysql_file_seek(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, my_off_t pos, int whence, myf flags)
{
my_off_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_SEEK);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_seek(file, pos, whence, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_seek(file, pos, whence, flags);
return result;
}
static inline my_off_t
inline_mysql_file_tell(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, myf flags)
{
my_off_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_TELL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_tell(file, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_tell(file, flags);
return result;
}
static inline int
inline_mysql_file_delete(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *name, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_DELETE, name, NULL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_delete(name, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_delete(name, flags);
return result;
}
static inline int
inline_mysql_file_rename(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *from, const char *to, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)
(&state, key, PSI_FILE_RENAME, from, NULL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_rename(from, to, flags);
PSI_FILE_CALL(end_file_rename_wait)(locker, from, to, result);
return result;
}
#endif
result= my_rename(from, to, flags);
return result;
}
static inline File
inline_mysql_file_create_with_symlink(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *linkname, const char *filename, mode_t create_flags,
int access_flags, myf flags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_CREATE, filename,
NULL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_create_with_symlink(linkname, filename, create_flags, access_flags,
flags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_create_with_symlink(linkname, filename, create_flags, access_flags,
flags);
return file;
}
static inline int
inline_mysql_file_delete_with_symlink(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *name, const char *ext, myf flags)
{
int result;
char buf[FN_REFLEN];
char *fullname= fn_format(buf, name, "", ext, MY_UNPACK_FILENAME | MY_APPEND_EXT);
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_DELETE, fullname,
NULL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_handler_delete_with_symlink(fullname, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_handler_delete_with_symlink(fullname, flags);
return result;
}
static inline int
inline_mysql_file_rename_with_symlink(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *from, const char *to, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)
(&state, key, PSI_FILE_RENAME, from, NULL);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_rename_with_symlink(from, to, flags);
PSI_FILE_CALL(end_file_rename_wait)(locker, from, to, result);
return result;
}
#endif
result= my_rename_with_symlink(from, to, flags);
return result;
}
static inline int
inline_mysql_file_sync(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File fd, myf flags)
{
int result= 0;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, fd, PSI_FILE_SYNC);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_sync(fd, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_sync(fd, flags);
return result;
}
/** @} (end of group File_instrumentation) */
#endif
PK ! ۺը mysql/psi/mysql_sp.hnu [ /* Copyright (c) 2013, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
#ifndef MYSQL_SP_H
#define MYSQL_SP_H
/**
@file mysql/psi/mysql_sp.h
Instrumentation helpers for stored programs.
*/
#include "mysql/psi/psi.h"
#ifndef PSI_SP_CALL
#define PSI_SP_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
#ifdef HAVE_PSI_SP_INTERFACE
#define MYSQL_START_SP(STATE, SP_SHARE) \
inline_mysql_start_sp(STATE, SP_SHARE)
#else
#define MYSQL_START_SP(STATE, SP_SHARE) \
NULL
#endif
#ifdef HAVE_PSI_SP_INTERFACE
#define MYSQL_END_SP(LOCKER) \
inline_mysql_end_sp(LOCKER)
#else
#define MYSQL_END_SP(LOCKER) \
do {} while (0)
#endif
#ifdef HAVE_PSI_SP_INTERFACE
#define MYSQL_DROP_SP(OT, SN, SNL, ON, ONL) \
inline_mysql_drop_sp(OT, SN, SNL, ON, ONL)
#else
#define MYSQL_DROP_SP(OT, SN, SNL, ON, ONL) \
do {} while (0)
#endif
#ifdef HAVE_PSI_SP_INTERFACE
#define MYSQL_GET_SP_SHARE(OT, SN, SNL, ON, ONL) \
inline_mysql_get_sp_share(OT, SN, SNL, ON, ONL)
#else
#define MYSQL_GET_SP_SHARE(OT, SN, SNL, ON, ONL) \
NULL
#endif
#ifdef HAVE_PSI_SP_INTERFACE
static inline struct PSI_sp_locker*
inline_mysql_start_sp(PSI_sp_locker_state *state, PSI_sp_share *sp_share)
{
return PSI_SP_CALL(start_sp)(state, sp_share);
}
static inline void inline_mysql_end_sp(PSI_sp_locker *locker)
{
if (likely(locker != NULL))
PSI_SP_CALL(end_sp)(locker);
}
static inline void
inline_mysql_drop_sp(uint sp_type,
const char* schema_name, uint shcema_name_length,
const char* object_name, uint object_name_length)
{
PSI_SP_CALL(drop_sp)(sp_type,
schema_name, shcema_name_length,
object_name, object_name_length);
}
static inline PSI_sp_share*
inline_mysql_get_sp_share(uint sp_type,
const char* schema_name, uint shcema_name_length,
const char* object_name, uint object_name_length)
{
return PSI_SP_CALL(get_sp_share)(sp_type,
schema_name, shcema_name_length,
object_name, object_name_length);
}
#endif
#endif
PK ! S5u mysql/psi/psi_base.hnu [ /* Copyright (c) 2008, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
Without limiting anything contained in the foregoing, this file,
which is part of C Driver for MySQL (Connector/C), is also subject to the
Universal FOSS Exception, version 1.0, a copy of which can be found at
http://oss.oracle.com/licenses/universal-foss-exception.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_PSI_BASE_H
#define MYSQL_PSI_BASE_H
#ifdef EMBEDDED_LIBRARY
#define DISABLE_ALL_PSI
#endif /* EMBEDDED_LIBRARY */
#ifdef __cplusplus
extern "C" {
#endif
/**
@file mysql/psi/psi_base.h
Performance schema instrumentation interface.
@defgroup Instrumentation_interface Instrumentation Interface
@ingroup Performance_schema
@{
*/
#define PSI_INSTRUMENT_ME 0
#define PSI_INSTRUMENT_MEM ((PSI_memory_key)0)
#define PSI_NOT_INSTRUMENTED 0
/**
Global flag.
This flag indicate that an instrumentation point is a global variable,
or a singleton.
*/
#define PSI_FLAG_GLOBAL (1 << 0)
/**
Mutable flag.
This flag indicate that an instrumentation point is a general placeholder,
that can mutate into a more specific instrumentation point.
*/
#define PSI_FLAG_MUTABLE (1 << 1)
#define PSI_FLAG_THREAD (1 << 2)
/**
Stage progress flag.
This flag apply to the stage instruments only.
It indicates the instrumentation provides progress data.
*/
#define PSI_FLAG_STAGE_PROGRESS (1 << 3)
/**
Shared Exclusive flag.
Indicates that rwlock support the shared exclusive state.
*/
#define PSI_RWLOCK_FLAG_SX (1 << 4)
/**
Transferable flag.
This flag indicate that an instrumented object can
be created by a thread and destroyed by another thread.
*/
#define PSI_FLAG_TRANSFER (1 << 5)
/**
Volatility flag.
This flag indicate that an instrumented object
has a volatility (life cycle) comparable
to the volatility of a session.
*/
#define PSI_FLAG_VOLATILITY_SESSION (1 << 6)
/**
System thread flag.
Indicates that the instrumented object exists on a system thread.
*/
#define PSI_FLAG_THREAD_SYSTEM (1 << 9)
#ifdef HAVE_PSI_INTERFACE
/**
@def PSI_VERSION_1
Performance Schema Interface number for version 1.
This version is supported.
*/
#define PSI_VERSION_1 1
/**
@def PSI_VERSION_2
Performance Schema Interface number for version 2.
This version is not implemented, it's a placeholder.
*/
#define PSI_VERSION_2 2
/**
@def PSI_CURRENT_VERSION
Performance Schema Interface number for the most recent version.
The most current version is @c PSI_VERSION_1
*/
#define PSI_CURRENT_VERSION 1
/**
@def USE_PSI_1
Define USE_PSI_1 to use the interface version 1.
*/
/**
@def USE_PSI_2
Define USE_PSI_2 to use the interface version 2.
*/
/**
@def HAVE_PSI_1
Define HAVE_PSI_1 if the interface version 1 needs to be compiled in.
*/
/**
@def HAVE_PSI_2
Define HAVE_PSI_2 if the interface version 2 needs to be compiled in.
*/
#ifndef USE_PSI_2
#ifndef USE_PSI_1
#define USE_PSI_1
#endif
#endif
#ifdef USE_PSI_1
#define HAVE_PSI_1
#endif
#ifdef USE_PSI_2
#define HAVE_PSI_2
#endif
/*
Allow to override PSI_XXX_CALL at compile time
with more efficient implementations, if available.
If nothing better is available,
make a dynamic call using the PSI_server function pointer.
*/
#define PSI_DYNAMIC_CALL(M) PSI_server->M
#endif /* HAVE_PSI_INTERFACE */
/** @} */
/**
Instrumented memory key.
To instrument memory, a memory key must be obtained using @c register_memory.
Using a zero key always disable the instrumentation.
*/
typedef unsigned int PSI_memory_key;
#ifdef __cplusplus
}
#endif
#endif /* MYSQL_PSI_BASE_H */
PK ! [6^1 1 mysql/psi/mysql_table.hnu [ /* Copyright (c) 2010, 2023, Oracle and/or its affiliates. All rights reserved.
Copyright (c) 2017, 2019, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_TABLE_H
#define MYSQL_TABLE_H
/**
@file mysql/psi/mysql_table.h
Instrumentation helpers for table io.
*/
#include "mysql/psi/psi.h"
#ifndef PSI_TABLE_CALL
#define PSI_TABLE_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
/**
@defgroup Table_instrumentation Table Instrumentation
@ingroup Instrumentation_interface
@{
*/
#ifdef HAVE_PSI_TABLE_INTERFACE
#define MYSQL_UNBIND_TABLE(handler) (handler)->unbind_psi()
#define PSI_CALL_unbind_table PSI_TABLE_CALL(unbind_table)
#define PSI_CALL_rebind_table PSI_TABLE_CALL(rebind_table)
#define PSI_CALL_open_table PSI_TABLE_CALL(open_table)
#define PSI_CALL_close_table PSI_TABLE_CALL(close_table)
#define PSI_CALL_get_table_share PSI_TABLE_CALL(get_table_share)
#define PSI_CALL_release_table_share PSI_TABLE_CALL(release_table_share)
#define PSI_CALL_drop_table_share PSI_TABLE_CALL(drop_table_share)
#else
#define MYSQL_UNBIND_TABLE(handler) do { } while(0)
#define PSI_CALL_unbind_table(A1) do { } while(0)
#define PSI_CALL_rebind_table(A1,A2,A3) NULL
#define PSI_CALL_close_table(A1,A2) do { } while(0)
#define PSI_CALL_open_table(A1,A2) NULL
#define PSI_CALL_get_table_share(A1,A2) NULL
#define PSI_CALL_release_table_share(A1) do { } while(0)
#define PSI_CALL_drop_table_share(A1,A2,A3,A4,A5) do { } while(0)
#endif
/**
@def MYSQL_TABLE_WAIT_VARIABLES
Instrumentation helper for table waits.
This instrumentation declares local variables.
Do not use a ';' after this macro
@param LOCKER the locker
@param STATE the locker state
@sa MYSQL_START_TABLE_IO_WAIT.
@sa MYSQL_END_TABLE_IO_WAIT.
@sa MYSQL_START_TABLE_LOCK_WAIT.
@sa MYSQL_END_TABLE_LOCK_WAIT.
*/
#ifdef HAVE_PSI_TABLE_INTERFACE
#define MYSQL_TABLE_WAIT_VARIABLES(LOCKER, STATE) \
struct PSI_table_locker* LOCKER; \
PSI_table_locker_state STATE;
#else
#define MYSQL_TABLE_WAIT_VARIABLES(LOCKER, STATE)
#endif
/**
@def MYSQL_START_TABLE_LOCK_WAIT
Instrumentation helper for table lock waits.
This instrumentation marks the start of a wait event.
@param LOCKER the locker
@param STATE the locker state
@param PSI the instrumented table
@param OP the table operation to be performed
@param FLAGS per table operation flags.
@sa MYSQL_END_TABLE_LOCK_WAIT.
*/
#ifdef HAVE_PSI_TABLE_INTERFACE
#define MYSQL_START_TABLE_LOCK_WAIT(LOCKER, STATE, PSI, OP, FLAGS) \
LOCKER= inline_mysql_start_table_lock_wait(STATE, PSI, \
OP, FLAGS, __FILE__, __LINE__)
#else
#define MYSQL_START_TABLE_LOCK_WAIT(LOCKER, STATE, PSI, OP, FLAGS) \
do {} while (0)
#endif
/**
@def MYSQL_END_TABLE_LOCK_WAIT
Instrumentation helper for table lock waits.
This instrumentation marks the end of a wait event.
@param LOCKER the locker
@sa MYSQL_START_TABLE_LOCK_WAIT.
*/
#ifdef HAVE_PSI_TABLE_INTERFACE
#define MYSQL_END_TABLE_LOCK_WAIT(LOCKER) \
inline_mysql_end_table_lock_wait(LOCKER)
#else
#define MYSQL_END_TABLE_LOCK_WAIT(LOCKER) \
do {} while (0)
#endif
#ifdef HAVE_PSI_TABLE_INTERFACE
#define MYSQL_UNLOCK_TABLE(T) \
inline_mysql_unlock_table(T)
#else
#define MYSQL_UNLOCK_TABLE(T) \
do {} while (0)
#endif
#ifdef HAVE_PSI_TABLE_INTERFACE
/**
Instrumentation calls for MYSQL_START_TABLE_LOCK_WAIT.
@sa MYSQL_END_TABLE_LOCK_WAIT.
*/
static inline struct PSI_table_locker *
inline_mysql_start_table_lock_wait(PSI_table_locker_state *state,
struct PSI_table *psi,
enum PSI_table_lock_operation op,
ulong flags, const char *src_file, uint src_line)
{
if (psi_likely(psi != NULL))
{
struct PSI_table_locker *locker;
locker= PSI_TABLE_CALL(start_table_lock_wait)
(state, psi, op, flags, src_file, src_line);
return locker;
}
return NULL;
}
/**
Instrumentation calls for MYSQL_END_TABLE_LOCK_WAIT.
@sa MYSQL_START_TABLE_LOCK_WAIT.
*/
static inline void
inline_mysql_end_table_lock_wait(struct PSI_table_locker *locker)
{
if (psi_likely(locker != NULL))
PSI_TABLE_CALL(end_table_lock_wait)(locker);
}
static inline void
inline_mysql_unlock_table(struct PSI_table *table)
{
if (table != NULL)
PSI_TABLE_CALL(unlock_table)(table);
}
#endif
/** @} (end of group Table_instrumentation) */
#endif
PK ! mysql/psi/mysql_statement.hnu [ /* Copyright (c) 2010, 2023, Oracle and/or its affiliates.
Copyright (c) 2017, 2019, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_STATEMENT_H
#define MYSQL_STATEMENT_H
/**
@file mysql/psi/mysql_statement.h
Instrumentation helpers for statements.
*/
#include "mysql/psi/psi.h"
class Diagnostics_area;
typedef const struct charset_info_st CHARSET_INFO;
#ifndef PSI_STATEMENT_CALL
#define PSI_STATEMENT_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
#ifndef PSI_DIGEST_CALL
#define PSI_DIGEST_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
/**
@defgroup Statement_instrumentation Statement Instrumentation
@ingroup Instrumentation_interface
@{
*/
/**
@def mysql_statement_register(P1, P2, P3)
Statement registration.
*/
#ifdef HAVE_PSI_STATEMENT_INTERFACE
#define mysql_statement_register(P1, P2, P3) \
inline_mysql_statement_register(P1, P2, P3)
#else
#define mysql_statement_register(P1, P2, P3) \
do {} while (0)
#endif
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
#define MYSQL_DIGEST_START(LOCKER) \
inline_mysql_digest_start(LOCKER)
#else
#define MYSQL_DIGEST_START(LOCKER) \
NULL
#endif
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
#define MYSQL_DIGEST_END(LOCKER, DIGEST) \
inline_mysql_digest_end(LOCKER, DIGEST)
#else
#define MYSQL_DIGEST_END(LOCKER, DIGEST) \
do {} while (0)
#endif
#ifdef HAVE_PSI_STATEMENT_INTERFACE
#define MYSQL_START_STATEMENT(STATE, K, DB, DB_LEN, CS, SPS) \
inline_mysql_start_statement(STATE, K, DB, DB_LEN, CS, SPS, __FILE__, __LINE__)
#else
#define MYSQL_START_STATEMENT(STATE, K, DB, DB_LEN, CS, SPS) \
NULL
#endif
#ifdef HAVE_PSI_STATEMENT_INTERFACE
#define MYSQL_REFINE_STATEMENT(LOCKER, K) \
inline_mysql_refine_statement(LOCKER, K)
#else
#define MYSQL_REFINE_STATEMENT(LOCKER, K) \
NULL
#endif
#ifdef HAVE_PSI_STATEMENT_INTERFACE
#define MYSQL_SET_STATEMENT_TEXT(LOCKER, P1, P2) \
inline_mysql_set_statement_text(LOCKER, P1, P2)
#else
#define MYSQL_SET_STATEMENT_TEXT(LOCKER, P1, P2) \
do {} while (0)
#endif
#ifdef HAVE_PSI_STATEMENT_INTERFACE
#define MYSQL_SET_STATEMENT_LOCK_TIME(LOCKER, P1) \
inline_mysql_set_statement_lock_time(LOCKER, P1)
#else
#define MYSQL_SET_STATEMENT_LOCK_TIME(LOCKER, P1) \
do {} while (0)
#endif
#ifdef HAVE_PSI_STATEMENT_INTERFACE
#define MYSQL_SET_STATEMENT_ROWS_SENT(LOCKER, P1) \
inline_mysql_set_statement_rows_sent(LOCKER, P1)
#else
#define MYSQL_SET_STATEMENT_ROWS_SENT(LOCKER, P1) \
do {} while (0)
#endif
#ifdef HAVE_PSI_STATEMENT_INTERFACE
#define MYSQL_SET_STATEMENT_ROWS_EXAMINED(LOCKER, P1) \
inline_mysql_set_statement_rows_examined(LOCKER, P1)
#else
#define MYSQL_SET_STATEMENT_ROWS_EXAMINED(LOCKER, P1) \
do {} while (0)
#endif
#ifdef HAVE_PSI_STATEMENT_INTERFACE
#define MYSQL_END_STATEMENT(LOCKER, DA) \
inline_mysql_end_statement(LOCKER, DA)
#else
#define MYSQL_END_STATEMENT(LOCKER, DA) \
do {} while (0)
#endif
#ifdef HAVE_PSI_STATEMENT_INTERFACE
static inline void inline_mysql_statement_register(
const char *category, PSI_statement_info *info, int count)
{
PSI_STATEMENT_CALL(register_statement)(category, info, count);
}
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
static inline struct PSI_digest_locker *
inline_mysql_digest_start(PSI_statement_locker *locker)
{
PSI_digest_locker* digest_locker= NULL;
if (psi_likely(locker != NULL))
digest_locker= PSI_DIGEST_CALL(digest_start)(locker);
return digest_locker;
}
#endif
#ifdef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
static inline void
inline_mysql_digest_end(PSI_digest_locker *locker, const sql_digest_storage *digest)
{
if (psi_likely(locker != NULL))
PSI_DIGEST_CALL(digest_end)(locker, digest);
}
#endif
static inline struct PSI_statement_locker *
inline_mysql_start_statement(PSI_statement_locker_state *state,
PSI_statement_key key,
const char *db, size_t db_len,
CHARSET_INFO *charset,
PSI_sp_share *sp_share,
const char *src_file, uint src_line)
{
PSI_statement_locker *locker;
locker= PSI_STATEMENT_CALL(get_thread_statement_locker)(state, key, charset,
sp_share);
if (psi_likely(locker != NULL))
PSI_STATEMENT_CALL(start_statement)(locker, db, (uint)db_len, src_file, src_line);
return locker;
}
static inline struct PSI_statement_locker *
inline_mysql_refine_statement(PSI_statement_locker *locker,
PSI_statement_key key)
{
if (psi_likely(locker != NULL))
{
locker= PSI_STATEMENT_CALL(refine_statement)(locker, key);
}
return locker;
}
static inline void
inline_mysql_set_statement_text(PSI_statement_locker *locker,
const char *text, uint text_len)
{
if (psi_likely(locker != NULL))
{
PSI_STATEMENT_CALL(set_statement_text)(locker, text, text_len);
}
}
static inline void
inline_mysql_set_statement_lock_time(PSI_statement_locker *locker,
ulonglong count)
{
if (psi_likely(locker != NULL))
{
PSI_STATEMENT_CALL(set_statement_lock_time)(locker, count);
}
}
static inline void
inline_mysql_set_statement_rows_sent(PSI_statement_locker *locker,
ulonglong count)
{
if (psi_likely(locker != NULL))
{
PSI_STATEMENT_CALL(set_statement_rows_sent)(locker, count);
}
}
static inline void
inline_mysql_set_statement_rows_examined(PSI_statement_locker *locker,
ulonglong count)
{
if (psi_likely(locker != NULL))
{
PSI_STATEMENT_CALL(set_statement_rows_examined)(locker, count);
}
}
static inline void
inline_mysql_end_statement(struct PSI_statement_locker *locker,
Diagnostics_area *stmt_da)
{
PSI_STAGE_CALL(end_stage)();
if (psi_likely(locker != NULL))
PSI_STATEMENT_CALL(end_statement)(locker, stmt_da);
}
#endif
/** @} (end of group Statement_instrumentation) */
#endif
PK ! (Ĕ mysql/psi/mysql_mdl.hnu [ /* Copyright (c) 2012, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
#ifndef MYSQL_MDL_H
#define MYSQL_MDL_H
/**
@file mysql/psi/mysql_mdl.h
Instrumentation helpers for metadata locks.
*/
#include "mysql/psi/psi.h"
#ifdef HAVE_PSI_METADATA_INTERFACE
#ifndef PSI_METADATA_CALL
#define PSI_METADATA_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
#define PSI_CALL_start_metadata_wait(A,B,C,D) PSI_METADATA_CALL(start_metadata_wait)(A,B,C,D)
#define PSI_CALL_end_metadata_wait(A,B) PSI_METADATA_CALL(end_metadata_wait)(A,B)
#define PSI_CALL_create_metadata_lock(A,B,C,D,E,F,G) PSI_METADATA_CALL(create_metadata_lock)(A,B,C,D,E,F,G)
#define PSI_CALL_set_metadata_lock_status(A,B) PSI_METADATA_CALL(set_metadata_lock_status)(A,B)
#define PSI_CALL_destroy_metadata_lock(A) PSI_METADATA_CALL(destroy_metadata_lock)(A)
#else
#define PSI_CALL_start_metadata_wait(A,B,C,D) 0
#define PSI_CALL_end_metadata_wait(A,B) do { } while(0)
#define PSI_CALL_create_metadata_lock(A,B,C,D,E,F,G) 0
#define PSI_CALL_set_metadata_lock_status(A,B) do {} while(0)
#define PSI_CALL_destroy_metadata_lock(A) do {} while(0)
#endif
/**
@defgroup Thread_instrumentation Metadata Instrumentation
@ingroup Instrumentation_interface
@{
*/
/**
@def mysql_mdl_create(K, M, A)
Instrumented metadata lock creation.
@param I Metadata lock identity
@param K Metadata key
@param T Metadata lock type
@param D Metadata lock duration
@param S Metadata lock status
@param F request source file
@param L request source line
*/
#ifdef HAVE_PSI_METADATA_INTERFACE
#define mysql_mdl_create(I, K, T, D, S, F, L) \
inline_mysql_mdl_create(I, K, T, D, S, F, L)
#else
#define mysql_mdl_create(I, K, T, D, S, F, L) NULL
#endif
#ifdef HAVE_PSI_METADATA_INTERFACE
#define mysql_mdl_set_status(L, S) \
inline_mysql_mdl_set_status(L, S)
#else
#define mysql_mdl_set_status(L, S) \
do {} while (0)
#endif
/**
@def mysql_mdl_destroy(M)
Instrumented metadata lock destruction.
@param M Metadata lock
*/
#ifdef HAVE_PSI_METADATA_INTERFACE
#define mysql_mdl_destroy(M) \
inline_mysql_mdl_destroy(M, __FILE__, __LINE__)
#else
#define mysql_mdl_destroy(M) \
do {} while (0)
#endif
#ifdef HAVE_PSI_METADATA_INTERFACE
static inline PSI_metadata_lock *
inline_mysql_mdl_create(void *identity,
const MDL_key *mdl_key,
enum_mdl_type mdl_type,
enum_mdl_duration mdl_duration,
MDL_ticket::enum_psi_status mdl_status,
const char *src_file, uint src_line)
{
PSI_metadata_lock *result;
/* static_cast: Fit a round C++ enum peg into a square C int hole ... */
result= PSI_METADATA_CALL(create_metadata_lock)
(identity,
mdl_key,
static_cast (mdl_type),
static_cast (mdl_duration),
static_cast (mdl_status),
src_file, src_line);
return result;
}
static inline void inline_mysql_mdl_set_status(
PSI_metadata_lock *psi,
MDL_ticket::enum_psi_status mdl_status)
{
if (psi != NULL)
PSI_METADATA_CALL(set_metadata_lock_status)(psi, mdl_status);
}
static inline void inline_mysql_mdl_destroy(
PSI_metadata_lock *psi,
const char *src_file, uint src_line)
{
if (psi != NULL)
PSI_METADATA_CALL(destroy_metadata_lock)(psi);
}
#endif /* HAVE_PSI_METADATA_INTERFACE */
/** @} (end of group Metadata_instrumentation) */
#endif
PK ! ˁ mysql/psi/psi_abi_v0.hnu [ /* Copyright (c) 2011, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file mysql/psi/psi_abi_v0.h
ABI check for mysql/psi/psi.h, when compiling without instrumentation.
This file is only used to automate detection of changes between versions.
Do not include this file, include mysql/psi/psi.h instead.
*/
#define MY_GLOBAL_INCLUDED
#include "mysql/psi/psi.h"
PK ! S?7
7
mysql/psi/mysql_memory.hnu [ /* Copyright (c) 2012, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
#ifndef MYSQL_MEMORY_H
#define MYSQL_MEMORY_H
/**
@file mysql/psi/mysql_memory.h
Instrumentation helpers for memory allocation.
*/
#include "mysql/psi/psi.h"
#ifdef HAVE_PSI_MEMORY_INTERFACE
#define PSI_CALL_memory_alloc(A1,A2,A3) PSI_MEMORY_CALL(memory_alloc)(A1,A2,A3)
#define PSI_CALL_memory_free(A1,A2,A3) PSI_MEMORY_CALL(memory_free)(A1,A2,A3)
#define PSI_CALL_memory_realloc(A1,A2,A3,A4) PSI_MEMORY_CALL(memory_realloc)(A1,A2,A3,A4)
#define PSI_CALL_register_memory(A1,A2,A3) PSI_MEMORY_CALL(register_memory)(A1,A2,A3)
#else
#define PSI_CALL_memory_alloc(A1,A2,A3) 0
#define PSI_CALL_memory_free(A1,A2,A3) do { } while(0)
#define PSI_CALL_memory_realloc(A1,A2,A3,A4) 0
#define PSI_CALL_register_memory(A1,A2,A3) do { } while(0)
#endif
#ifndef PSI_MEMORY_CALL
#define PSI_MEMORY_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
/**
@defgroup Memory_instrumentation Memory Instrumentation
@ingroup Instrumentation_interface
@{
*/
/**
@def mysql_memory_register(P1, P2, P3)
Memory registration.
*/
#define mysql_memory_register(P1, P2, P3) \
inline_mysql_memory_register(P1, P2, P3)
static inline void inline_mysql_memory_register(
#ifdef HAVE_PSI_MEMORY_INTERFACE
const char *category,
PSI_memory_info *info,
int count)
#else
const char *category __attribute__((unused)),
void *info __attribute__((unused)),
int count __attribute__((unused)))
#endif
{
PSI_CALL_register_memory(category, info, count);
}
/** @} (end of group Memory_instrumentation) */
#endif
PK ! JS mysql/psi/mysql_socket.hnu [ /* Copyright (c) 2010, 2023, Oracle and/or its affiliates.
Copyright (c) 2017, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
02110-1335 USA
*/
#ifndef MYSQL_SOCKET_H
#define MYSQL_SOCKET_H
/* For MY_STAT */
#include
/* For my_chsize */
#include
/* For socket api */
#ifdef _WIN32
#include
#include
#include
#define SOCKBUF_T char
#else
#include
#define SOCKBUF_T void
#endif
/**
@file mysql/psi/mysql_socket.h
[...]
*/
#include "mysql/psi/psi.h"
#ifndef PSI_SOCKET_CALL
#define PSI_SOCKET_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
/**
@defgroup Socket_instrumentation Socket Instrumentation
@ingroup Instrumentation_interface
@{
*/
/**
@def mysql_socket_register(P1, P2, P3)
Socket registration.
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_register(P1, P2, P3) \
inline_mysql_socket_register(P1, P2, P3)
#else
#define mysql_socket_register(P1, P2, P3) \
do {} while (0)
#endif
/** An instrumented socket. */
struct st_mysql_socket
{
/** The real socket descriptor. */
my_socket fd;
/** Is this a Unix-domain socket? */
char is_unix_domain_socket;
/** Is this a socket opened for the extra port? */
char is_extra_port;
/** Address family of the socket. (See sa_family from struct sockaddr). */
unsigned short address_family;
/**
The instrumentation hook.
Note that this hook is not conditionally defined,
for binary compatibility of the @c MYSQL_SOCKET interface.
*/
struct PSI_socket *m_psi;
};
/**
An instrumented socket.
@c MYSQL_SOCKET is a replacement for @c my_socket.
*/
typedef struct st_mysql_socket MYSQL_SOCKET;
/**
@def MYSQL_INVALID_SOCKET
MYSQL_SOCKET initial value.
*/
//MYSQL_SOCKET MYSQL_INVALID_SOCKET= {INVALID_SOCKET, NULL};
#define MYSQL_INVALID_SOCKET mysql_socket_invalid()
/**
MYSQL_SOCKET helper. Initialize instrumented socket.
@sa mysql_socket_getfd
@sa mysql_socket_setfd
*/
static inline MYSQL_SOCKET
mysql_socket_invalid()
{
MYSQL_SOCKET mysql_socket= {INVALID_SOCKET, 0, 0, 0, NULL};
return mysql_socket;
}
/**
Set socket descriptor and address.
@param socket nstrumented socket
@param addr unformatted socket address
@param addr_len length of socket address
*/
static inline void
mysql_socket_set_address(
#ifdef HAVE_PSI_SOCKET_INTERFACE
MYSQL_SOCKET socket,
const struct sockaddr *addr,
socklen_t addr_len
#else
MYSQL_SOCKET socket __attribute__ ((unused)),
const struct sockaddr *addr __attribute__ ((unused)),
socklen_t addr_len __attribute__ ((unused))
#endif
)
{
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (socket.m_psi != NULL)
PSI_SOCKET_CALL(set_socket_info)(socket.m_psi, NULL, addr, addr_len);
#endif
}
/**
Set socket descriptor and address.
@param socket instrumented socket
*/
static inline void
mysql_socket_set_thread_owner(
#ifdef HAVE_PSI_SOCKET_INTERFACE
MYSQL_SOCKET socket
#else
MYSQL_SOCKET socket __attribute__ ((unused))
#endif
)
{
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (socket.m_psi != NULL)
PSI_SOCKET_CALL(set_socket_thread_owner)(socket.m_psi);
#endif
}
/**
MYSQL_SOCKET helper. Get socket descriptor.
@param mysql_socket Instrumented socket
@sa mysql_socket_getfd
*/
static inline my_socket
mysql_socket_getfd(MYSQL_SOCKET mysql_socket)
{
return mysql_socket.fd;
}
/**
MYSQL_SOCKET helper. Set socket descriptor.
@param mysql_socket Instrumented socket
@param fd Socket descriptor
@sa mysql_socket_setfd
*/
static inline void
mysql_socket_setfd(MYSQL_SOCKET *mysql_socket, my_socket fd)
{
if (likely(mysql_socket != NULL))
mysql_socket->fd= fd;
}
/**
@def MYSQL_SOCKET_WAIT_VARIABLES
Instrumentation helper for socket waits.
This instrumentation declares local variables.
Do not use a ';' after this macro
@param LOCKER locker
@param STATE locker state
@sa MYSQL_START_SOCKET_WAIT.
@sa MYSQL_END_SOCKET_WAIT.
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define MYSQL_SOCKET_WAIT_VARIABLES(LOCKER, STATE) \
struct PSI_socket_locker* LOCKER; \
PSI_socket_locker_state STATE;
#else
#define MYSQL_SOCKET_WAIT_VARIABLES(LOCKER, STATE)
#endif
/**
@def MYSQL_START_SOCKET_WAIT
Instrumentation helper for socket waits.
This instrumentation marks the start of a wait event.
@param LOCKER locker
@param STATE locker state
@param SOCKET instrumented socket
@param OP The socket operation to be performed
@param COUNT bytes to be written/read
@sa MYSQL_END_SOCKET_WAIT.
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define MYSQL_START_SOCKET_WAIT(LOCKER, STATE, SOCKET, OP, COUNT) \
LOCKER= inline_mysql_start_socket_wait(STATE, SOCKET, OP, COUNT,\
__FILE__, __LINE__)
#else
#define MYSQL_START_SOCKET_WAIT(LOCKER, STATE, SOCKET, OP, COUNT) \
do {} while (0)
#endif
/**
@def MYSQL_END_SOCKET_WAIT
Instrumentation helper for socket waits.
This instrumentation marks the end of a wait event.
@param LOCKER locker
@param COUNT actual bytes written/read, or -1
@sa MYSQL_START_SOCKET_WAIT.
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define MYSQL_END_SOCKET_WAIT(LOCKER, COUNT) \
inline_mysql_end_socket_wait(LOCKER, COUNT)
#else
#define MYSQL_END_SOCKET_WAIT(LOCKER, COUNT) \
do {} while (0)
#endif
/**
@def MYSQL_SOCKET_SET_STATE
Set the state (IDLE, ACTIVE) of an instrumented socket.
@param SOCKET the instrumented socket
@param STATE the new state
@sa PSI_socket_state
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define MYSQL_SOCKET_SET_STATE(SOCKET, STATE) \
inline_mysql_socket_set_state(SOCKET, STATE)
#else
#define MYSQL_SOCKET_SET_STATE(SOCKET, STATE) \
do {} while (0)
#endif
#ifdef HAVE_PSI_SOCKET_INTERFACE
/**
Instrumentation calls for MYSQL_START_SOCKET_WAIT.
@sa MYSQL_START_SOCKET_WAIT.
*/
static inline struct PSI_socket_locker*
inline_mysql_start_socket_wait(PSI_socket_locker_state *state,
MYSQL_SOCKET mysql_socket,
enum PSI_socket_operation op,
size_t byte_count,
const char *src_file, uint src_line)
{
struct PSI_socket_locker *locker;
if (psi_likely(mysql_socket.m_psi != NULL))
{
locker= PSI_SOCKET_CALL(start_socket_wait)
(state, mysql_socket.m_psi, op, byte_count, src_file, src_line);
}
else
locker= NULL;
return locker;
}
/**
Instrumentation calls for MYSQL_END_SOCKET_WAIT.
@sa MYSQL_END_SOCKET_WAIT.
*/
static inline void
inline_mysql_end_socket_wait(struct PSI_socket_locker *locker, size_t byte_count)
{
if (psi_likely(locker != NULL))
PSI_SOCKET_CALL(end_socket_wait)(locker, byte_count);
}
/**
Set the state (IDLE, ACTIVE) of an instrumented socket.
@param socket the instrumented socket
@param state the new state
@sa PSI_socket_state
*/
static inline void
inline_mysql_socket_set_state(MYSQL_SOCKET socket, enum PSI_socket_state state)
{
if (socket.m_psi != NULL)
PSI_SOCKET_CALL(set_socket_state)(socket.m_psi, state);
}
#endif /* HAVE_PSI_SOCKET_INTERFACE */
/**
@def mysql_socket_fd(K, F)
Create a socket.
@c mysql_socket_fd is a replacement for @c socket.
@param K PSI_socket_key for this instrumented socket
@param F File descriptor
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_fd(K, F) \
inline_mysql_socket_fd(K, F)
#else
#define mysql_socket_fd(K, F) \
inline_mysql_socket_fd(F)
#endif
/**
@def mysql_socket_socket(K, D, T, P)
Create a socket.
@c mysql_socket_socket is a replacement for @c socket.
@param K PSI_socket_key for this instrumented socket
@param D Socket domain
@param T Protocol type
@param P Transport protocol
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_socket(K, D, T, P) \
inline_mysql_socket_socket(K, D, T, P)
#else
#define mysql_socket_socket(K, D, T, P) \
inline_mysql_socket_socket(D, T, P)
#endif
/**
@def mysql_socket_bind(FD, AP, L)
Bind a socket to a local port number and IP address
@c mysql_socket_bind is a replacement for @c bind.
@param FD Instrumented socket descriptor returned by socket()
@param AP Pointer to local port number and IP address in sockaddr structure
@param L Length of sockaddr structure
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_bind(FD, AP, L) \
inline_mysql_socket_bind(__FILE__, __LINE__, FD, AP, L)
#else
#define mysql_socket_bind(FD, AP, L) \
inline_mysql_socket_bind(FD, AP, L)
#endif
/**
@def mysql_socket_getsockname(FD, AP, LP)
Return port number and IP address of the local host
@c mysql_socket_getsockname is a replacement for @c getsockname.
@param FD Instrumented socket descriptor returned by socket()
@param AP Pointer to returned address of local host in @c sockaddr structure
@param LP Pointer to length of @c sockaddr structure
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_getsockname(FD, AP, LP) \
inline_mysql_socket_getsockname(__FILE__, __LINE__, FD, AP, LP)
#else
#define mysql_socket_getsockname(FD, AP, LP) \
inline_mysql_socket_getsockname(FD, AP, LP)
#endif
/**
@def mysql_socket_connect(FD, AP, L)
Establish a connection to a remote host.
@c mysql_socket_connect is a replacement for @c connect.
@param FD Instrumented socket descriptor returned by socket()
@param AP Pointer to target address in sockaddr structure
@param L Length of sockaddr structure
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_connect(FD, AP, L) \
inline_mysql_socket_connect(__FILE__, __LINE__, FD, AP, L)
#else
#define mysql_socket_connect(FD, AP, L) \
inline_mysql_socket_connect(FD, AP, L)
#endif
/**
@def mysql_socket_getpeername(FD, AP, LP)
Get port number and IP address of remote host that a socket is connected to.
@c mysql_socket_getpeername is a replacement for @c getpeername.
@param FD Instrumented socket descriptor returned by socket() or accept()
@param AP Pointer to returned address of remote host in sockaddr structure
@param LP Pointer to length of sockaddr structure
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_getpeername(FD, AP, LP) \
inline_mysql_socket_getpeername(__FILE__, __LINE__, FD, AP, LP)
#else
#define mysql_socket_getpeername(FD, AP, LP) \
inline_mysql_socket_getpeername(FD, AP, LP)
#endif
/**
@def mysql_socket_send(FD, B, N, FL)
Send data from the buffer, B, to a connected socket.
@c mysql_socket_send is a replacement for @c send.
@param FD Instrumented socket descriptor returned by socket() or accept()
@param B Buffer to send
@param N Number of bytes to send
@param FL Control flags
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_send(FD, B, N, FL) \
inline_mysql_socket_send(__FILE__, __LINE__, FD, B, N, FL)
#else
#define mysql_socket_send(FD, B, N, FL) \
inline_mysql_socket_send(FD, B, N, FL)
#endif
/**
@def mysql_socket_recv(FD, B, N, FL)
Receive data from a connected socket.
@c mysql_socket_recv is a replacement for @c recv.
@param FD Instrumented socket descriptor returned by socket() or accept()
@param B Buffer to receive to
@param N Maximum bytes to receive
@param FL Control flags
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_recv(FD, B, N, FL) \
inline_mysql_socket_recv(__FILE__, __LINE__, FD, B, N, FL)
#else
#define mysql_socket_recv(FD, B, N, FL) \
inline_mysql_socket_recv(FD, B, N, FL)
#endif
/**
@def mysql_socket_sendto(FD, B, N, FL, AP, L)
Send data to a socket at the specified address.
@c mysql_socket_sendto is a replacement for @c sendto.
@param FD Instrumented socket descriptor returned by socket()
@param B Buffer to send
@param N Number of bytes to send
@param FL Control flags
@param AP Pointer to destination sockaddr structure
@param L Size of sockaddr structure
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_sendto(FD, B, N, FL, AP, L) \
inline_mysql_socket_sendto(__FILE__, __LINE__, FD, B, N, FL, AP, L)
#else
#define mysql_socket_sendto(FD, B, N, FL, AP, L) \
inline_mysql_socket_sendto(FD, B, N, FL, AP, L)
#endif
/**
@def mysql_socket_recvfrom(FD, B, N, FL, AP, L)
Receive data from a socket and return source address information
@c mysql_socket_recvfrom is a replacement for @c recvfrom.
@param FD Instrumented socket descriptor returned by socket()
@param B Buffer to receive to
@param N Maximum bytes to receive
@param FL Control flags
@param AP Pointer to source address in sockaddr_storage structure
@param LP Size of sockaddr_storage structure
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_recvfrom(FD, B, N, FL, AP, LP) \
inline_mysql_socket_recvfrom(__FILE__, __LINE__, FD, B, N, FL, AP, LP)
#else
#define mysql_socket_recvfrom(FD, B, N, FL, AP, LP) \
inline_mysql_socket_recvfrom(FD, B, N, FL, AP, LP)
#endif
/**
@def mysql_socket_getsockopt(FD, LV, ON, OP, OL)
Get a socket option for the specified socket.
@c mysql_socket_getsockopt is a replacement for @c getsockopt.
@param FD Instrumented socket descriptor returned by socket()
@param LV Protocol level
@param ON Option to query
@param OP Buffer which will contain the value for the requested option
@param OL Pointer to length of OP
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_getsockopt(FD, LV, ON, OP, OL) \
inline_mysql_socket_getsockopt(__FILE__, __LINE__, FD, LV, ON, OP, OL)
#else
#define mysql_socket_getsockopt(FD, LV, ON, OP, OL) \
inline_mysql_socket_getsockopt(FD, LV, ON, OP, OL)
#endif
/**
@def mysql_socket_setsockopt(FD, LV, ON, OP, OL)
Set a socket option for the specified socket.
@c mysql_socket_setsockopt is a replacement for @c setsockopt.
@param FD Instrumented socket descriptor returned by socket()
@param LV Protocol level
@param ON Option to modify
@param OP Buffer containing the value for the specified option
@param OL Pointer to length of OP
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_setsockopt(FD, LV, ON, OP, OL) \
inline_mysql_socket_setsockopt(__FILE__, __LINE__, FD, LV, ON, OP, OL)
#else
#define mysql_socket_setsockopt(FD, LV, ON, OP, OL) \
inline_mysql_socket_setsockopt(FD, LV, ON, OP, OL)
#endif
/**
@def mysql_sock_set_nonblocking
Set socket to non-blocking.
@param FD instrumented socket descriptor
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_sock_set_nonblocking(FD) \
inline_mysql_sock_set_nonblocking(__FILE__, __LINE__, FD)
#else
#define mysql_sock_set_nonblocking(FD) \
inline_mysql_sock_set_nonblocking(FD)
#endif
/**
@def mysql_socket_listen(FD, N)
Set socket state to listen for an incoming connection.
@c mysql_socket_listen is a replacement for @c listen.
@param FD Instrumented socket descriptor, bound and connected
@param N Maximum number of pending connections allowed.
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_listen(FD, N) \
inline_mysql_socket_listen(__FILE__, __LINE__, FD, N)
#else
#define mysql_socket_listen(FD, N) \
inline_mysql_socket_listen(FD, N)
#endif
/**
@def mysql_socket_accept(K, FD, AP, LP)
Accept a connection from any remote host; TCP only.
@c mysql_socket_accept is a replacement for @c accept.
@param K PSI_socket_key for this instrumented socket
@param FD Instrumented socket descriptor, bound and placed in a listen state
@param AP Pointer to sockaddr structure with returned IP address and port of connected host
@param LP Pointer to length of valid information in AP
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_accept(K, FD, AP, LP) \
inline_mysql_socket_accept(__FILE__, __LINE__, K, FD, AP, LP)
#else
#define mysql_socket_accept(K, FD, AP, LP) \
inline_mysql_socket_accept(FD, AP, LP)
#endif
/**
@def mysql_socket_close(FD)
Close a socket and sever any connections.
@c mysql_socket_close is a replacement for @c close.
@param FD Instrumented socket descriptor returned by socket() or accept()
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_close(FD) \
inline_mysql_socket_close(__FILE__, __LINE__, FD)
#else
#define mysql_socket_close(FD) \
inline_mysql_socket_close(FD)
#endif
/**
@def mysql_socket_shutdown(FD, H)
Disable receives and/or sends on a socket.
@c mysql_socket_shutdown is a replacement for @c shutdown.
@param FD Instrumented socket descriptor returned by socket() or accept()
@param H Specifies which operations to shutdown
*/
#ifdef HAVE_PSI_SOCKET_INTERFACE
#define mysql_socket_shutdown(FD, H) \
inline_mysql_socket_shutdown(__FILE__, __LINE__, FD, H)
#else
#define mysql_socket_shutdown(FD, H) \
inline_mysql_socket_shutdown(FD, H)
#endif
#ifdef HAVE_PSI_SOCKET_INTERFACE
static inline void inline_mysql_socket_register(
const char *category,
PSI_socket_info *info,
int count)
{
PSI_SOCKET_CALL(register_socket)(category, info, count);
}
#endif
/** mysql_socket_fd */
static inline MYSQL_SOCKET
inline_mysql_socket_fd
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
PSI_socket_key key,
#endif
int fd)
{
MYSQL_SOCKET mysql_socket= MYSQL_INVALID_SOCKET;
mysql_socket.fd= fd;
DBUG_ASSERT(mysql_socket.fd != INVALID_SOCKET);
#ifdef HAVE_PSI_SOCKET_INTERFACE
mysql_socket.m_psi= PSI_SOCKET_CALL(init_socket)
(key, (const my_socket*)&mysql_socket.fd, NULL, 0);
#endif
/**
Currently systemd socket activation is the user of this
function. Its API (man sd_listen_fds) says FD_CLOSE_EXEC
is already called. If there becomes another user, we
can call it again without detriment.
If needed later:
#if defined(HAVE_FCNTL) && defined(FD_CLOEXEC)
(void) fcntl(mysql_socket.fd, F_SETFD, FD_CLOEXEC);
#endif
*/
return mysql_socket;
}
/** mysql_socket_socket */
static inline MYSQL_SOCKET
inline_mysql_socket_socket
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
PSI_socket_key key,
#endif
int domain, int type, int protocol)
{
MYSQL_SOCKET mysql_socket= MYSQL_INVALID_SOCKET;
mysql_socket.fd= socket(domain, type | SOCK_CLOEXEC, protocol);
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (likely(mysql_socket.fd != INVALID_SOCKET))
{
mysql_socket.m_psi= PSI_SOCKET_CALL(init_socket)
(key, (const my_socket*)&mysql_socket.fd, NULL, 0);
}
#endif
/* SOCK_CLOEXEC isn't always a number - can't preprocessor compare */
#if defined(HAVE_FCNTL) && defined(FD_CLOEXEC) && !defined(HAVE_SOCK_CLOEXEC)
(void) fcntl(mysql_socket.fd, F_SETFD, FD_CLOEXEC);
#endif
return mysql_socket;
}
/** mysql_socket_bind */
static inline int
inline_mysql_socket_bind
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, const struct sockaddr *addr, size_t len)
{
int result;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker_state state;
PSI_socket_locker *locker;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_BIND, (size_t)0, src_file, src_line);
/* Instrumented code */
result= bind(mysql_socket.fd, addr, (int)len);
/* Instrumentation end */
if (result == 0)
PSI_SOCKET_CALL(set_socket_info)(mysql_socket.m_psi, NULL, addr, (socklen_t)len);
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
return result;
}
#endif
/* Non instrumented code */
result= bind(mysql_socket.fd, addr, (int)len);
return result;
}
/** mysql_socket_getsockname */
static inline int
inline_mysql_socket_getsockname
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, struct sockaddr *addr, socklen_t *len)
{
int result;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_BIND, (size_t)0, src_file, src_line);
/* Instrumented code */
result= getsockname(mysql_socket.fd, addr, len);
/* Instrumentation end */
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
return result;
}
#endif
/* Non instrumented code */
result= getsockname(mysql_socket.fd, addr, len);
return result;
}
/** mysql_socket_connect */
static inline int
inline_mysql_socket_connect
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, const struct sockaddr *addr, socklen_t len)
{
int result;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_CONNECT, (size_t)0, src_file, src_line);
/* Instrumented code */
result= connect(mysql_socket.fd, addr, len);
/* Instrumentation end */
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
return result;
}
#endif
/* Non instrumented code */
result= connect(mysql_socket.fd, addr, len);
return result;
}
/** mysql_socket_getpeername */
static inline int
inline_mysql_socket_getpeername
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, struct sockaddr *addr, socklen_t *len)
{
int result;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_BIND, (size_t)0, src_file, src_line);
/* Instrumented code */
result= getpeername(mysql_socket.fd, addr, len);
/* Instrumentation end */
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
return result;
}
#endif
/* Non instrumented code */
result= getpeername(mysql_socket.fd, addr, len);
return result;
}
/** mysql_socket_send */
static inline ssize_t
inline_mysql_socket_send
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, const SOCKBUF_T *buf, size_t n, int flags)
{
ssize_t result;
DBUG_ASSERT(mysql_socket.fd != INVALID_SOCKET);
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_SEND, n, src_file, src_line);
/* Instrumented code */
result= send(mysql_socket.fd, buf, IF_WIN((int),) n, flags);
/* Instrumentation end */
if (locker != NULL)
{
size_t bytes_written= (result > 0) ? (size_t) result : 0;
PSI_SOCKET_CALL(end_socket_wait)(locker, bytes_written);
}
return result;
}
#endif
/* Non instrumented code */
result= send(mysql_socket.fd, buf, IF_WIN((int),) n, flags);
return result;
}
/** mysql_socket_recv */
static inline ssize_t
inline_mysql_socket_recv
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, SOCKBUF_T *buf, size_t n, int flags)
{
ssize_t result;
DBUG_ASSERT(mysql_socket.fd != INVALID_SOCKET);
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_RECV, (size_t)0, src_file, src_line);
/* Instrumented code */
result= recv(mysql_socket.fd, buf, IF_WIN((int),) n, flags);
/* Instrumentation end */
if (locker != NULL)
{
size_t bytes_read= (result > 0) ? (size_t) result : 0;
PSI_SOCKET_CALL(end_socket_wait)(locker, bytes_read);
}
return result;
}
#endif
/* Non instrumented code */
result= recv(mysql_socket.fd, buf, IF_WIN((int),) n, flags);
return result;
}
/** mysql_socket_sendto */
static inline ssize_t
inline_mysql_socket_sendto
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, const SOCKBUF_T *buf, size_t n, int flags, const struct sockaddr *addr, socklen_t addr_len)
{
ssize_t result;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_SEND, n, src_file, src_line);
/* Instrumented code */
result= sendto(mysql_socket.fd, buf, IF_WIN((int),) n, flags, addr, addr_len);
/* Instrumentation end */
if (locker != NULL)
{
size_t bytes_written = (result > 0) ? (size_t) result : 0;
PSI_SOCKET_CALL(end_socket_wait)(locker, bytes_written);
}
return result;
}
#endif
/* Non instrumented code */
result= sendto(mysql_socket.fd, buf, IF_WIN((int),) n, flags, addr, addr_len);
return result;
}
/** mysql_socket_recvfrom */
static inline ssize_t
inline_mysql_socket_recvfrom
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, SOCKBUF_T *buf, size_t n, int flags,
struct sockaddr *addr, socklen_t *addr_len)
{
ssize_t result;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_RECV, (size_t)0, src_file, src_line);
/* Instrumented code */
result= recvfrom(mysql_socket.fd, buf, IF_WIN((int),) n, flags, addr, addr_len);
/* Instrumentation end */
if (locker != NULL)
{
size_t bytes_read= (result > 0) ? (size_t) result : 0;
PSI_SOCKET_CALL(end_socket_wait)(locker, bytes_read);
}
return result;
}
#endif
/* Non instrumented code */
result= recvfrom(mysql_socket.fd, buf, IF_WIN((int),) n, flags, addr, addr_len);
return result;
}
/** mysql_socket_getsockopt */
static inline int
inline_mysql_socket_getsockopt
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, int level, int optname, SOCKBUF_T *optval, socklen_t *optlen)
{
int result;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_OPT, (size_t)0, src_file, src_line);
/* Instrumented code */
result= getsockopt(mysql_socket.fd, level, optname, optval, optlen);
/* Instrumentation end */
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
return result;
}
#endif
/* Non instrumented code */
result= getsockopt(mysql_socket.fd, level, optname, optval, optlen);
return result;
}
/** mysql_socket_setsockopt */
static inline int
inline_mysql_socket_setsockopt
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, int level, int optname, const SOCKBUF_T *optval,
socklen_t optlen)
{
int result;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_OPT, (size_t)0, src_file, src_line);
/* Instrumented code */
result= setsockopt(mysql_socket.fd, level, optname, optval, optlen);
/* Instrumentation end */
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
return result;
}
#endif
/* Non instrumented code */
result= setsockopt(mysql_socket.fd, level, optname, optval, optlen);
return result;
}
/** set_socket_nonblock */
static inline int
set_socket_nonblock(my_socket fd)
{
int ret= 0;
#ifdef _WIN32
{
u_long nonblocking= 1;
ret= ioctlsocket(fd, FIONBIO, &nonblocking);
}
#else
{
int fd_flags;
fd_flags= fcntl(fd, F_GETFL, 0);
if (fd_flags < 0)
return errno;
#if defined(O_NONBLOCK)
fd_flags |= O_NONBLOCK;
#elif defined(O_NDELAY)
fd_flags |= O_NDELAY;
#elif defined(O_FNDELAY)
fd_flags |= O_FNDELAY;
#else
#error "No definition of non-blocking flag found."
#endif /* O_NONBLOCK */
if (fcntl(fd, F_SETFL, fd_flags) == -1)
ret= errno;
}
#endif /* _WIN32 */
return ret;
}
/** mysql_socket_set_nonblocking */
static inline int
inline_mysql_sock_set_nonblocking
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket
)
{
int result= 0;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (mysql_socket.m_psi)
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_OPT,
(size_t)0, src_file, src_line);
/* Instrumented code */
result= set_socket_nonblock(mysql_socket.fd);
/* Instrumentation end */
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
return result;
}
#endif
/* Non instrumented code */
result= set_socket_nonblock(mysql_socket.fd);
return result;
}
/** mysql_socket_listen */
static inline int
inline_mysql_socket_listen
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, int backlog)
{
int result;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_CONNECT, (size_t)0, src_file, src_line);
/* Instrumented code */
result= listen(mysql_socket.fd, backlog);
/* Instrumentation end */
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
return result;
}
#endif
/* Non instrumented code */
result= listen(mysql_socket.fd, backlog);
return result;
}
/** mysql_socket_accept */
static inline MYSQL_SOCKET
inline_mysql_socket_accept
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line, PSI_socket_key key,
#endif
MYSQL_SOCKET socket_listen, struct sockaddr *addr, socklen_t *addr_len)
{
#ifdef FD_CLOEXEC
int flags __attribute__ ((unused));
#endif
MYSQL_SOCKET socket_accept;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (socket_listen.m_psi != NULL)
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, socket_listen.m_psi, PSI_SOCKET_CONNECT, (size_t)0, src_file, src_line);
/* Instrumented code */
#ifdef HAVE_ACCEPT4
socket_accept.fd= accept4(socket_listen.fd, addr, addr_len, SOCK_CLOEXEC);
#else
socket_accept.fd= accept(socket_listen.fd, addr, addr_len);
#ifdef FD_CLOEXEC
if (socket_accept.fd != INVALID_SOCKET)
{
flags= fcntl(socket_accept.fd, F_GETFD);
if (flags != -1)
{
flags |= FD_CLOEXEC;
fcntl(socket_accept.fd, F_SETFD, flags);
}
}
#endif
#endif
/* Instrumentation end */
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
}
else
#endif
{
/* Non instrumented code */
#ifdef HAVE_ACCEPT4
socket_accept.fd= accept4(socket_listen.fd, addr, addr_len, SOCK_CLOEXEC);
#else
socket_accept.fd= accept(socket_listen.fd, addr, addr_len);
#ifdef FD_CLOEXEC
if (socket_accept.fd != INVALID_SOCKET)
{
flags= fcntl(socket_accept.fd, F_GETFD);
if (flags != -1)
{
flags |= FD_CLOEXEC;
fcntl(socket_accept.fd, F_SETFD, flags);
}
}
#endif
#endif
}
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (likely(socket_accept.fd != INVALID_SOCKET))
{
/* Initialize the instrument with the new socket descriptor and address */
socket_accept.m_psi= PSI_SOCKET_CALL(init_socket)
(key, (const my_socket*)&socket_accept.fd, addr, *addr_len);
}
#endif
return socket_accept;
}
/** mysql_socket_close */
static inline int
inline_mysql_socket_close
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket)
{
int result;
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
/* Instrumentation start */
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_CLOSE, (size_t)0, src_file, src_line);
/* Instrumented code */
result= closesocket(mysql_socket.fd);
/* Instrumentation end */
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
/* Remove the instrumentation for this socket. */
if (mysql_socket.m_psi != NULL)
PSI_SOCKET_CALL(destroy_socket)(mysql_socket.m_psi);
return result;
}
#endif
/* Non instrumented code */
result= closesocket(mysql_socket.fd);
return result;
}
/** mysql_socket_shutdown */
static inline int
inline_mysql_socket_shutdown
(
#ifdef HAVE_PSI_SOCKET_INTERFACE
const char *src_file, uint src_line,
#endif
MYSQL_SOCKET mysql_socket, int how)
{
int result;
#ifdef _WIN32
static LPFN_DISCONNECTEX DisconnectEx = NULL;
if (DisconnectEx == NULL)
{
DWORD dwBytesReturned;
GUID guidDisconnectEx = WSAID_DISCONNECTEX;
WSAIoctl(mysql_socket.fd, SIO_GET_EXTENSION_FUNCTION_POINTER,
&guidDisconnectEx, sizeof(GUID),
&DisconnectEx, sizeof(DisconnectEx),
&dwBytesReturned, NULL, NULL);
}
#endif
/* Instrumentation start */
#ifdef HAVE_PSI_SOCKET_INTERFACE
if (psi_likely(mysql_socket.m_psi != NULL))
{
PSI_socket_locker *locker;
PSI_socket_locker_state state;
locker= PSI_SOCKET_CALL(start_socket_wait)
(&state, mysql_socket.m_psi, PSI_SOCKET_SHUTDOWN, (size_t)0, src_file, src_line);
/* Instrumented code */
#ifdef _WIN32
if (DisconnectEx)
result= (DisconnectEx(mysql_socket.fd, (LPOVERLAPPED) NULL,
(DWORD) 0, (DWORD) 0) == TRUE) ? 0 : -1;
else
#endif
result= shutdown(mysql_socket.fd, how);
/* Instrumentation end */
if (locker != NULL)
PSI_SOCKET_CALL(end_socket_wait)(locker, (size_t)0);
return result;
}
#endif
/* Non instrumented code */
#ifdef _WIN32
if (DisconnectEx)
result= (DisconnectEx(mysql_socket.fd, (LPOVERLAPPED) NULL,
(DWORD) 0, (DWORD) 0) == TRUE) ? 0 : -1;
else
#endif
result= shutdown(mysql_socket.fd, how);
return result;
}
/** @} (end of group Socket_instrumentation) */
#endif
PK ! >e/ mysql/psi/mysql_idle.hnu [ /* Copyright (c) 2011, 2023, Oracle and/or its affiliates
Copyright (c) 2017, 2019, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_IDLE_H
#define MYSQL_IDLE_H
/**
@file mysql/psi/mysql_idle.h
Instrumentation helpers for idle waits.
*/
#include "mysql/psi/psi.h"
#ifndef PSI_IDLE_CALL
#define PSI_IDLE_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
/**
@defgroup Idle_instrumentation Idle Instrumentation
@ingroup Instrumentation_interface
@{
*/
/**
@def MYSQL_START_IDLE_WAIT
Instrumentation helper for table io_waits.
This instrumentation marks the start of a wait event.
@param LOCKER the locker
@param STATE the locker state
@sa MYSQL_END_IDLE_WAIT.
*/
#ifdef HAVE_PSI_IDLE_INTERFACE
#define MYSQL_START_IDLE_WAIT(LOCKER, STATE) \
LOCKER= inline_mysql_start_idle_wait(STATE, __FILE__, __LINE__)
#else
#define MYSQL_START_IDLE_WAIT(LOCKER, STATE) \
do {} while (0)
#endif
/**
@def MYSQL_END_IDLE_WAIT
Instrumentation helper for idle waits.
This instrumentation marks the end of a wait event.
@param LOCKER the locker
@sa MYSQL_START_IDLE_WAIT.
*/
#ifdef HAVE_PSI_IDLE_INTERFACE
#define MYSQL_END_IDLE_WAIT(LOCKER) \
inline_mysql_end_idle_wait(LOCKER)
#else
#define MYSQL_END_IDLE_WAIT(LOCKER) \
do {} while (0)
#endif
#ifdef HAVE_PSI_IDLE_INTERFACE
/**
Instrumentation calls for MYSQL_START_IDLE_WAIT.
@sa MYSQL_END_IDLE_WAIT.
*/
static inline struct PSI_idle_locker *
inline_mysql_start_idle_wait(PSI_idle_locker_state *state,
const char *src_file, uint src_line)
{
struct PSI_idle_locker *locker;
locker= PSI_IDLE_CALL(start_idle_wait)(state, src_file, src_line);
return locker;
}
/**
Instrumentation calls for MYSQL_END_IDLE_WAIT.
@sa MYSQL_START_IDLE_WAIT.
*/
static inline void
inline_mysql_end_idle_wait(struct PSI_idle_locker *locker)
{
if (psi_likely(locker != NULL))
PSI_IDLE_CALL(end_idle_wait)(locker);
}
#endif
/** @} (end of group Idle_instrumentation) */
#endif
PK ! W7 mysql/psi/psi_abi_v1.hnu [ /* Copyright (c) 2008, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file mysql/psi/psi_abi_v1.h
ABI check for mysql/psi/psi.h, when using PSI_VERSION_1.
This file is only used to automate detection of changes between versions.
Do not include this file, include mysql/psi/psi.h instead.
*/
#define USE_PSI_1
#define HAVE_PSI_INTERFACE
#define MY_GLOBAL_INCLUDED
#include "mysql/psi/psi.h"
PK ! ]e' ' mysql/psi/mysql_ps.hnu [ /* Copyright (c) 2014, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
#ifndef MYSQL_PS_H
#define MYSQL_PS_H
/**
@file mysql/psi/mysql_ps.h
Instrumentation helpers for prepared statements.
*/
#include "mysql/psi/psi.h"
#ifndef PSI_PS_CALL
#define PSI_PS_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
#ifdef HAVE_PSI_PS_INTERFACE
#define MYSQL_CREATE_PS(IDENTITY, ID, LOCKER, NAME, NAME_LENGTH) \
inline_mysql_create_prepared_stmt(IDENTITY, ID, LOCKER, NAME, NAME_LENGTH)
#define MYSQL_EXECUTE_PS(LOCKER, PREPARED_STMT) \
inline_mysql_execute_prepared_stmt(LOCKER, PREPARED_STMT)
#define MYSQL_DESTROY_PS(PREPARED_STMT) \
inline_mysql_destroy_prepared_stmt(PREPARED_STMT)
#define MYSQL_REPREPARE_PS(PREPARED_STMT) \
inline_mysql_reprepare_prepared_stmt(PREPARED_STMT)
#define MYSQL_SET_PS_TEXT(PREPARED_STMT, SQLTEXT, SQLTEXT_LENGTH) \
inline_mysql_set_prepared_stmt_text(PREPARED_STMT, SQLTEXT, SQLTEXT_LENGTH)
#else
#define MYSQL_CREATE_PS(IDENTITY, ID, LOCKER, NAME, NAME_LENGTH) \
NULL
#define MYSQL_EXECUTE_PS(LOCKER, PREPARED_STMT) \
do {} while (0)
#define MYSQL_DESTROY_PS(PREPARED_STMT) \
do {} while (0)
#define MYSQL_REPREPARE_PS(PREPARED_STMT) \
do {} while (0)
#define MYSQL_SET_PS_TEXT(PREPARED_STMT, SQLTEXT, SQLTEXT_LENGTH) \
do {} while (0)
#endif
#ifdef HAVE_PSI_PS_INTERFACE
static inline struct PSI_prepared_stmt*
inline_mysql_create_prepared_stmt(void *identity, uint stmt_id,
PSI_statement_locker *locker,
const char *stmt_name, size_t stmt_name_length)
{
if (locker == NULL)
return NULL;
return PSI_PS_CALL(create_prepared_stmt)(identity, stmt_id,
locker,
stmt_name, stmt_name_length);
}
static inline void
inline_mysql_execute_prepared_stmt(PSI_statement_locker *locker,
PSI_prepared_stmt* prepared_stmt)
{
if (prepared_stmt != NULL && locker != NULL)
PSI_PS_CALL(execute_prepared_stmt)(locker, prepared_stmt);
}
static inline void
inline_mysql_destroy_prepared_stmt(PSI_prepared_stmt *prepared_stmt)
{
if (prepared_stmt != NULL)
PSI_PS_CALL(destroy_prepared_stmt)(prepared_stmt);
}
static inline void
inline_mysql_reprepare_prepared_stmt(PSI_prepared_stmt *prepared_stmt)
{
if (prepared_stmt != NULL)
PSI_PS_CALL(reprepare_prepared_stmt)(prepared_stmt);
}
static inline void
inline_mysql_set_prepared_stmt_text(PSI_prepared_stmt *prepared_stmt,
const char *text,
uint text_len)
{
if (prepared_stmt != NULL)
{
PSI_PS_CALL(set_prepared_stmt_text)(prepared_stmt, text, text_len);
}
}
#endif
#endif
PK ! ~m@ @ mysql/psi/mysql_transaction.hnu [ /* Copyright (c) 2013, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
#ifndef MYSQL_TRANSACTION_H
#define MYSQL_TRANSACTION_H
/**
@file mysql/psi/mysql_transaction.h
Instrumentation helpers for transactions.
*/
#include "mysql/psi/psi.h"
#ifndef PSI_TRANSACTION_CALL
#define PSI_TRANSACTION_CALL(M) PSI_DYNAMIC_CALL(M)
#endif
/**
@defgroup Transaction_instrumentation Transaction Instrumentation
@ingroup Instrumentation_interface
@{
*/
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
#define MYSQL_START_TRANSACTION(STATE, XID, TRXID, ISO, RO, AC) \
inline_mysql_start_transaction(STATE, XID, TRXID, ISO, RO, AC, __FILE__, __LINE__)
#else
#define MYSQL_START_TRANSACTION(STATE, XID, TRXID, ISO, RO, AC) \
0
#endif
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
#define MYSQL_SET_TRANSACTION_GTID(LOCKER, P1, P2) \
inline_mysql_set_transaction_gtid(LOCKER, P1, P2)
#else
#define MYSQL_SET_TRANSACTION_GTID(LOCKER, P1, P2) \
do {} while (0)
#endif
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
#define MYSQL_SET_TRANSACTION_XID(LOCKER, P1, P2) \
inline_mysql_set_transaction_xid(LOCKER, P1, P2)
#else
#define MYSQL_SET_TRANSACTION_XID(LOCKER, P1, P2) \
do {} while (0)
#endif
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
#define MYSQL_SET_TRANSACTION_XA_STATE(LOCKER, P1) \
inline_mysql_set_transaction_xa_state(LOCKER, P1)
#else
#define MYSQL_SET_TRANSACTION_XA_STATE(LOCKER, P1) \
do {} while (0)
#endif
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
#define MYSQL_SET_TRANSACTION_TRXID(LOCKER, P1) \
inline_mysql_set_transaction_trxid(LOCKER, P1)
#else
#define MYSQL_SET_TRANSACTION_TRXID(LOCKER, P1) \
do {} while (0)
#endif
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
#define MYSQL_INC_TRANSACTION_SAVEPOINTS(LOCKER, P1) \
inline_mysql_inc_transaction_savepoints(LOCKER, P1)
#else
#define MYSQL_INC_TRANSACTION_SAVEPOINTS(LOCKER, P1) \
do {} while (0)
#endif
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
#define MYSQL_INC_TRANSACTION_ROLLBACK_TO_SAVEPOINT(LOCKER, P1) \
inline_mysql_inc_transaction_rollback_to_savepoint(LOCKER, P1)
#else
#define MYSQL_INC_TRANSACTION_ROLLBACK_TO_SAVEPOINT(LOCKER, P1) \
do {} while (0)
#endif
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
#define MYSQL_INC_TRANSACTION_RELEASE_SAVEPOINT(LOCKER, P1) \
inline_mysql_inc_transaction_release_savepoint(LOCKER, P1)
#else
#define MYSQL_INC_TRANSACTION_RELEASE_SAVEPOINT(LOCKER, P1) \
do {} while (0)
#endif
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
#define MYSQL_ROLLBACK_TRANSACTION(LOCKER) \
inline_mysql_rollback_transaction(LOCKER)
#else
#define MYSQL_ROLLBACK_TRANSACTION(LOCKER) \
do { } while(0)
#endif
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
#define MYSQL_COMMIT_TRANSACTION(LOCKER) \
inline_mysql_commit_transaction(LOCKER)
#else
#define MYSQL_COMMIT_TRANSACTION(LOCKER) \
do { } while(0)
#endif
#ifdef HAVE_PSI_TRANSACTION_INTERFACE
static inline struct PSI_transaction_locker *
inline_mysql_start_transaction(PSI_transaction_locker_state *state,
const void *xid,
ulonglong trxid,
int isolation_level,
my_bool read_only,
my_bool autocommit,
const char *src_file, int src_line)
{
PSI_transaction_locker *locker;
locker= PSI_TRANSACTION_CALL(get_thread_transaction_locker)(state,
xid, trxid,
isolation_level,
read_only,
autocommit);
if (likely(locker != NULL))
PSI_TRANSACTION_CALL(start_transaction)(locker, src_file, src_line);
return locker;
}
static inline void
inline_mysql_set_transaction_gtid(PSI_transaction_locker *locker,
const void *sid,
const void *gtid_spec)
{
if (likely(locker != NULL))
PSI_TRANSACTION_CALL(set_transaction_gtid)(locker, sid, gtid_spec);
}
static inline void
inline_mysql_set_transaction_xid(PSI_transaction_locker *locker,
const void *xid,
int xa_state)
{
if (likely(locker != NULL))
PSI_TRANSACTION_CALL(set_transaction_xid)(locker, xid, xa_state);
}
static inline void
inline_mysql_set_transaction_xa_state(PSI_transaction_locker *locker,
int xa_state)
{
if (likely(locker != NULL))
PSI_TRANSACTION_CALL(set_transaction_xa_state)(locker, xa_state);
}
static inline void
inline_mysql_set_transaction_trxid(PSI_transaction_locker *locker,
const ulonglong *trxid)
{
if (likely(locker != NULL))
PSI_TRANSACTION_CALL(set_transaction_trxid)(locker, trxid);
}
static inline void
inline_mysql_inc_transaction_savepoints(PSI_transaction_locker *locker,
ulong count)
{
if (likely(locker != NULL))
PSI_TRANSACTION_CALL(inc_transaction_savepoints)(locker, count);
}
static inline void
inline_mysql_inc_transaction_rollback_to_savepoint(PSI_transaction_locker *locker,
ulong count)
{
if (likely(locker != NULL))
PSI_TRANSACTION_CALL(inc_transaction_rollback_to_savepoint)(locker, count);
}
static inline void
inline_mysql_inc_transaction_release_savepoint(PSI_transaction_locker *locker,
ulong count)
{
if (likely(locker != NULL))
PSI_TRANSACTION_CALL(inc_transaction_release_savepoint)(locker, count);
}
static inline void
inline_mysql_rollback_transaction(struct PSI_transaction_locker *locker)
{
if (likely(locker != NULL))
PSI_TRANSACTION_CALL(end_transaction)(locker, false);
}
static inline void
inline_mysql_commit_transaction(struct PSI_transaction_locker *locker)
{
if (likely(locker != NULL))
PSI_TRANSACTION_CALL(end_transaction)(locker, true);
}
#endif
/** @} (end of group Transaction_instrumentation) */
#endif
PK !
L mysql/psi/psi_abi_v2.hnu [ /* Copyright (c) 2008, 2023, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file mysql/psi/psi_abi_v1.h
ABI check for mysql/psi/psi.h, when using PSI_VERSION_2.
This file is only used to automate detection of changes between versions.
Do not include this file, include mysql/psi/psi.h instead.
*/
#define USE_PSI_2
#define HAVE_PSI_INTERFACE
#define MY_GLOBAL_INCLUDED
#include "mysql/psi/psi.h"
PK ! ? mysql/service_json.hnu [ /* Copyright (C) 2018 MariaDB Corporation
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */
#ifndef MYSQL_SERVICE_JSON
#define MYSQL_SERVICE_JSON
/**
@file
json service
Exports JSON parsing methods for plugins to use.
Functions of the service:
json_type - returns the type of the JSON argument,
and the parsed value if it's scalar (not object or array)
json_get_array_item - expects JSON array as an argument,
and returns the type of the element at index `n_item`.
Returns JSV_NOTHING type if the array is shorter
than n_item and the actual length of the array in value_len.
If successful, then `value` up till `value[value_len]` contains the array
element at the desired index (n_item).
json_get_object_key - expects JSON object as an argument,
searches for a key in the object, return it's type and stores its value in `value`.
JSV_NOTHING if no such key found, the number of keys
in v_len.
json_get_object_nkey - expects JSON object as an argument.
finds n_key's key in the object, returns it's name, type and value.
JSV_NOTHING if object has less keys than n_key.
*/
#ifdef __cplusplus
extern "C" {
#endif
enum json_types
{
JSV_BAD_JSON=-1,
JSV_NOTHING=0,
JSV_OBJECT=1,
JSV_ARRAY=2,
JSV_STRING=3,
JSV_NUMBER=4,
JSV_TRUE=5,
JSV_FALSE=6,
JSV_NULL=7
};
extern struct json_service_st {
enum json_types (*json_type)(const char *js, const char *js_end,
const char **value, int *value_len);
enum json_types (*json_get_array_item)(const char *js, const char *js_end,
int n_item,
const char **value, int *value_len);
enum json_types (*json_get_object_key)(const char *js, const char *js_end,
const char *key,
const char **value, int *value_len);
enum json_types (*json_get_object_nkey)(const char *js,const char *js_end,
int nkey,
const char **keyname, const char **keyname_end,
const char **value, int *value_len);
int (*json_escape_string)(const char *str,const char *str_end,
char *json, char *json_end);
int (*json_unescape_json)(const char *json_str, const char *json_end,
char *res, char *res_end);
} *json_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define json_type json_service->json_type
#define json_get_array_item json_service->json_get_array_item
#define json_get_object_key json_service->json_get_object_key
#define json_get_object_nkey json_service->json_get_object_nkey
#define json_escape_string json_service->json_escape_string
#define json_unescape_json json_service->json_unescape_json
#else
enum json_types json_type(const char *js, const char *js_end,
const char **value, int *value_len);
enum json_types json_get_array_item(const char *js, const char *js_end,
int n_item,
const char **value, int *value_len);
enum json_types json_get_object_key(const char *js, const char *js_end,
const char *key,
const char **value, int *value_len);
enum json_types json_get_object_nkey(const char *js,const char *js_end, int nkey,
const char **keyname, const char **keyname_end,
const char **value, int *value_len);
int json_escape_string(const char *str,const char *str_end,
char *json, char *json_end);
int json_unescape_json(const char *json_str, const char *json_end,
char *res, char *res_end);
#endif /*MYSQL_DYNAMIC_PLUGIN*/
#ifdef __cplusplus
}
#endif
#endif /*MYSQL_SERVICE_JSON */
PK ! W
mysql/service_progress_report.hnu [ #ifndef MYSQL_SERVICE_PROGRESS_REPORT_INCLUDED
/* Copyright (C) 2011 Monty Program Ab
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
This service allows plugins to report progress of long running operations
to the server. The progress report is visible in SHOW PROCESSLIST,
INFORMATION_SCHEMA.PROCESSLIST, and is sent to the client
if requested.
The functions are documented at
https://mariadb.com/kb/en/progress-reporting/#how-to-add-support-for-progress-reporting-to-a-storage-engine
*/
#ifdef __cplusplus
extern "C" {
#endif
#define thd_proc_info(thd, msg) set_thd_proc_info(thd, msg, \
__func__, __FILE__, __LINE__)
extern struct progress_report_service_st {
void (*thd_progress_init_func)(MYSQL_THD thd, unsigned int max_stage);
void (*thd_progress_report_func)(MYSQL_THD thd,
unsigned long long progress,
unsigned long long max_progress);
void (*thd_progress_next_stage_func)(MYSQL_THD thd);
void (*thd_progress_end_func)(MYSQL_THD thd);
const char *(*set_thd_proc_info_func)(MYSQL_THD, const char *info,
const char *func,
const char *file,
unsigned int line);
} *progress_report_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define thd_progress_init(thd,max_stage) (progress_report_service->thd_progress_init_func((thd),(max_stage)))
#define thd_progress_report(thd, progress, max_progress) (progress_report_service->thd_progress_report_func((thd), (progress), (max_progress)))
#define thd_progress_next_stage(thd) (progress_report_service->thd_progress_next_stage_func(thd))
#define thd_progress_end(thd) (progress_report_service->thd_progress_end_func(thd))
#define set_thd_proc_info(thd,info,func,file,line) (progress_report_service->set_thd_proc_info_func((thd),(info),(func),(file),(line)))
#else
/**
Report progress for long running operations
@param thd User thread connection handle
@param progress Where we are now
@param max_progress Progress will continue up to this
*/
void thd_progress_init(MYSQL_THD thd, unsigned int max_stage);
void thd_progress_report(MYSQL_THD thd,
unsigned long long progress,
unsigned long long max_progress);
void thd_progress_next_stage(MYSQL_THD thd);
void thd_progress_end(MYSQL_THD thd);
const char *set_thd_proc_info(MYSQL_THD, const char * info, const char *func,
const char *file, unsigned int line);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_PROGRESS_REPORT_INCLUDED
#endif
PK ! 4 5 5 mysql/service_debug_sync.hnu [ #ifndef MYSQL_SERVICE_DEBUG_SYNC_INCLUDED
/* Copyright (c) 2009, 2010, Oracle and/or its affiliates.
Copyright (c) 2012, Monty Program Ab
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
== Debug Sync Facility ==
The Debug Sync Facility allows placement of synchronization points in
the server code by using the DEBUG_SYNC macro:
open_tables(...)
DEBUG_SYNC(thd, "after_open_tables");
lock_tables(...)
When activated, a sync point can
- Emit a signal and/or
- Wait for a signal
Nomenclature:
- signal: A value of a global variable that persists
until overwritten by a new signal. The global
variable can also be seen as a "signal post"
or "flag mast". Then the signal is what is
attached to the "signal post" or "flag mast".
- emit a signal: Assign the value (the signal) to the global
variable ("set a flag") and broadcast a
global condition to wake those waiting for
a signal.
- wait for a signal: Loop over waiting for the global condition until
the global value matches the wait-for signal.
By default, all sync points are inactive. They do nothing (except to
burn a couple of CPU cycles for checking if they are active).
A sync point becomes active when an action is requested for it.
To do so, put a line like this in the test case file:
SET DEBUG_SYNC= 'after_open_tables SIGNAL opened WAIT_FOR flushed';
This activates the sync point 'after_open_tables'. It requests it to
emit the signal 'opened' and wait for another thread to emit the signal
'flushed' when the thread's execution runs through the sync point.
For every sync point there can be one action per thread only. Every
thread can request multiple actions, but only one per sync point. In
other words, a thread can activate multiple sync points.
Here is an example how to activate and use the sync points:
--connection conn1
SET DEBUG_SYNC= 'after_open_tables SIGNAL opened WAIT_FOR flushed';
send INSERT INTO t1 VALUES(1);
--connection conn2
SET DEBUG_SYNC= 'now WAIT_FOR opened';
SET DEBUG_SYNC= 'after_abort_locks SIGNAL flushed';
FLUSH TABLE t1;
When conn1 runs through the INSERT statement, it hits the sync point
'after_open_tables'. It notices that it is active and executes its
action. It emits the signal 'opened' and waits for another thread to
emit the signal 'flushed'.
conn2 waits immediately at the special sync point 'now' for another
thread to emit the 'opened' signal.
A signal remains in effect until it is overwritten. If conn1 signals
'opened' before conn2 reaches 'now', conn2 will still find the 'opened'
signal. It does not wait in this case.
When conn2 reaches 'after_abort_locks', it signals 'flushed', which lets
conn1 awake.
Normally the activation of a sync point is cleared when it has been
executed. Sometimes it is necessary to keep the sync point active for
another execution. You can add an execute count to the action:
SET DEBUG_SYNC= 'name SIGNAL sig EXECUTE 3';
This sets the signal point's activation counter to 3. Each execution
decrements the counter. After the third execution the sync point
becomes inactive.
One of the primary goals of this facility is to eliminate sleeps from
the test suite. In most cases it should be possible to rewrite test
cases so that they do not need to sleep. (But this facility cannot
synchronize multiple processes.) However, to support test development,
and as a last resort, sync point waiting times out. There is a default
timeout, but it can be overridden:
SET DEBUG_SYNC= 'name WAIT_FOR sig TIMEOUT 10 EXECUTE 2';
TIMEOUT 0 is special: If the signal is not present, the wait times out
immediately.
When a wait timed out (even on TIMEOUT 0), a warning is generated so
that it shows up in the test result.
You can throw an error message and kill the query when a synchronization
point is hit a certain number of times:
SET DEBUG_SYNC= 'name HIT_LIMIT 3';
Or combine it with signal and/or wait:
SET DEBUG_SYNC= 'name SIGNAL sig EXECUTE 2 HIT_LIMIT 3';
Here the first two hits emit the signal, the third hit returns the error
message and kills the query.
For cases where you are not sure that an action is taken and thus
cleared in any case, you can force to clear (deactivate) a sync point:
SET DEBUG_SYNC= 'name CLEAR';
If you want to clear all actions and clear the global signal, use:
SET DEBUG_SYNC= 'RESET';
This is the only way to reset the global signal to an empty string.
For testing of the facility itself you can execute a sync point just
as if it had been hit:
SET DEBUG_SYNC= 'name TEST';
=== Formal Syntax ===
The string to "assign" to the DEBUG_SYNC variable can contain:
{RESET |
TEST |
CLEAR |
{{SIGNAL |
WAIT_FOR [TIMEOUT ]}
[EXECUTE ] &| HIT_LIMIT }
Here '&|' means 'and/or'. This means that one of the sections
separated by '&|' must be present or both of them.
=== Activation/Deactivation ===
The facility is an optional part of the MySQL server.
It is enabled in a debug server by default.
./configure --enable-debug-sync
The Debug Sync Facility, when compiled in, is disabled by default. It
can be enabled by a mysqld command line option:
--debug-sync-timeout[=default_wait_timeout_value_in_seconds]
'default_wait_timeout_value_in_seconds' is the default timeout for the
WAIT_FOR action. If set to zero, the facility stays disabled.
The facility is enabled by default in the test suite, but can be
disabled with:
mysql-test-run.pl ... --debug-sync-timeout=0 ...
Likewise the default wait timeout can be set:
mysql-test-run.pl ... --debug-sync-timeout=10 ...
The command line option influences the readable value of the system
variable 'debug_sync'.
* If the facility is not compiled in, the system variable does not exist.
* If --debug-sync-timeout=0 the value of the variable reads as "OFF".
* Otherwise the value reads as "ON - current signal: " followed by the
current signal string, which can be empty.
The readable variable value is the same, regardless if read as global
or session value.
Setting the 'debug-sync' system variable requires 'SUPER' privilege.
You can never read back the string that you assigned to the variable,
unless you assign the value that the variable does already have. But
that would give a parse error. A syntactically correct string is
parsed into a debug sync action and stored apart from the variable value.
=== Implementation ===
Pseudo code for a sync point:
#define DEBUG_SYNC(thd, sync_point_name)
if (unlikely(opt_debug_sync_timeout))
debug_sync(thd, STRING_WITH_LEN(sync_point_name))
The sync point performs a binary search in a sorted array of actions
for this thread.
The SET DEBUG_SYNC statement adds a requested action to the array or
overwrites an existing action for the same sync point. When it adds a
new action, the array is sorted again.
=== A typical synchronization pattern ===
There are quite a few places in MySQL, where we use a synchronization
pattern like this:
mysql_mutex_lock(&mutex);
thd->enter_cond(&condition_variable, &mutex, new_message);
#if defined(ENABLE_DEBUG_SYNC)
if (!thd->killed && !end_of_wait_condition)
DEBUG_SYNC(thd, "sync_point_name");
#endif
while (!thd->killed && !end_of_wait_condition)
mysql_cond_wait(&condition_variable, &mutex);
thd->exit_cond(old_message);
Here some explanations:
thd->enter_cond() is used to register the condition variable and the
mutex in thd->mysys_var. This is done to allow the thread to be
interrupted (killed) from its sleep. Another thread can find the
condition variable to signal and mutex to use for synchronization in
this thread's THD::mysys_var.
thd->enter_cond() requires the mutex to be acquired in advance.
thd->exit_cond() unregisters the condition variable and mutex and
releases the mutex.
If you want to have a Debug Sync point with the wait, please place it
behind enter_cond(). Only then you can safely decide, if the wait will
be taken. Also you will have THD::proc_info correct when the sync
point emits a signal. DEBUG_SYNC sets its own proc_info, but restores
the previous one before releasing its internal mutex. As soon as
another thread sees the signal, it does also see the proc_info from
before entering the sync point. In this case it will be "new_message",
which is associated with the wait that is to be synchronized.
In the example above, the wait condition is repeated before the sync
point. This is done to skip the sync point, if no wait takes place.
The sync point is before the loop (not inside the loop) to have it hit
once only. It is possible that the condition variable is signaled
multiple times without the wait condition to be true.
A bit off-topic: At some places, the loop is taken around the whole
synchronization pattern:
while (!thd->killed && !end_of_wait_condition)
{
mysql_mutex_lock(&mutex);
thd->enter_cond(&condition_variable, &mutex, new_message);
if (!thd->killed [&& !end_of_wait_condition])
{
[DEBUG_SYNC(thd, "sync_point_name");]
mysql_cond_wait(&condition_variable, &mutex);
}
thd->exit_cond(old_message);
}
Note that it is important to repeat the test for thd->killed after
enter_cond(). Otherwise the killing thread may kill this thread after
it tested thd->killed in the loop condition and before it registered
the condition variable and mutex in enter_cond(). In this case, the
killing thread does not know that this thread is going to wait on a
condition variable. It would just set THD::killed. But if we would not
test it again, we would go asleep though we are killed. If the killing
thread would kill us when we are after the second test, but still
before sleeping, we hold the mutex, which is registered in mysys_var.
The killing thread would try to acquire the mutex before signaling
the condition variable. Since the mutex is only released implicitly in
mysql_cond_wait(), the signaling happens at the right place. We
have a safe synchronization.
=== Co-work with the DBUG facility ===
When running the MySQL test suite with the --debug-dbug command line
option, the Debug Sync Facility writes trace messages to the DBUG
trace. The following shell commands proved very useful in extracting
relevant information:
egrep 'query:|debug_sync_exec:' mysql-test/var/log/mysqld.1.trace
It shows all executed SQL statements and all actions executed by
synchronization points.
Sometimes it is also useful to see, which synchronization points have
been run through (hit) with or without executing actions. Then add
"|debug_sync_point:" to the egrep pattern.
=== Further reading ===
For a discussion of other methods to synchronize threads see
http://forge.mysql.com/wiki/MySQL_Internals_Test_Synchronization
For complete syntax tests, functional tests, and examples see the test
case debug_sync.test.
See also http://forge.mysql.com/worklog/task.php?id=4259
*/
#ifndef MYSQL_ABI_CHECK
#include
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifdef MYSQL_DYNAMIC_PLUGIN
extern void (*debug_sync_service)(MYSQL_THD, const char *, size_t);
#else
#define debug_sync_service debug_sync_C_callback_ptr
extern void (*debug_sync_C_callback_ptr)(MYSQL_THD, const char *, size_t);
#endif
#ifdef ENABLED_DEBUG_SYNC
#define DEBUG_SYNC(thd, name) \
do { \
if (debug_sync_service) \
debug_sync_service(thd, STRING_WITH_LEN(name)); \
} while(0)
#define DEBUG_SYNC_C_IF_THD(thd, name) \
do { \
if (debug_sync_service && thd) \
debug_sync_service((MYSQL_THD) thd, STRING_WITH_LEN(name)); \
} while(0)
#else
#define DEBUG_SYNC(thd,name) do { } while(0)
#define DEBUG_SYNC_C_IF_THD(thd, _sync_point_name_) do { } while(0)
#endif /* defined(ENABLED_DEBUG_SYNC) */
/* compatibility macro */
#ifdef __cplusplus
#define DEBUG_SYNC_C(name) DEBUG_SYNC(nullptr, name)
#else
#define DEBUG_SYNC_C(name) DEBUG_SYNC(NULL, name)
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_DEBUG_SYNC_INCLUDED
#endif
PK ! ע mysql/service_thd_autoinc.hnu [ #ifndef MYSQL_SERVICE_THD_AUTOINC_INCLUDED
/* Copyright (C) 2013 MariaDB Foundation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
This service provides access to the auto_increment related system variables:
@@auto_increment_offset
@@auto_increment_increment
*/
#ifdef __cplusplus
extern "C" {
#endif
extern struct thd_autoinc_service_st {
void (*thd_get_autoinc_func)(const MYSQL_THD thd,
unsigned long* off, unsigned long* inc);
} *thd_autoinc_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define thd_get_autoinc(thd, off, inc) \
(thd_autoinc_service->thd_get_autoinc_func((thd), (off), (inc)))
#else
/**
Return autoincrement system variables
@param IN thd user thread connection handle
@param OUT off the value of @@SESSION.auto_increment_offset
@param OUT inc the value of @@SESSION.auto_increment_increment
*/
void thd_get_autoinc(const MYSQL_THD thd,
unsigned long* off, unsigned long* inc);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_THD_AUTOINC_INCLUDED
#endif
PK ! BChN mysql/plugin_ftparser.hnu [ /* Copyright (c) 2005 MySQL AB, 2009 Sun Microsystems, Inc.
Use is subject to license terms.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _my_plugin_ftparser_h
#define _my_plugin_ftparser_h
#include "plugin.h"
#ifdef __cplusplus
extern "C" {
#endif
/*************************************************************************
API for Full-text parser plugin. (MYSQL_FTPARSER_PLUGIN)
*/
#define MYSQL_FTPARSER_INTERFACE_VERSION 0x0100
/* Parsing modes. Set in MYSQL_FTPARSER_PARAM::mode */
enum enum_ftparser_mode
{
/*
Fast and simple mode. This mode is used for indexing, and natural
language queries.
The parser is expected to return only those words that go into the
index. Stopwords or too short/long words should not be returned. The
'boolean_info' argument of mysql_add_word() does not have to be set.
*/
MYSQL_FTPARSER_SIMPLE_MODE= 0,
/*
Parse with stopwords mode. This mode is used in boolean searches for
"phrase matching."
The parser is not allowed to ignore words in this mode. Every word
should be returned, including stopwords and words that are too short
or long. The 'boolean_info' argument of mysql_add_word() does not
have to be set.
*/
MYSQL_FTPARSER_WITH_STOPWORDS= 1,
/*
Parse in boolean mode. This mode is used to parse a boolean query string.
The parser should provide a valid MYSQL_FTPARSER_BOOLEAN_INFO
structure in the 'boolean_info' argument to mysql_add_word().
Usually that means that the parser should recognize boolean operators
in the parsing stream and set appropriate fields in
MYSQL_FTPARSER_BOOLEAN_INFO structure accordingly. As for
MYSQL_FTPARSER_WITH_STOPWORDS mode, no word should be ignored.
Instead, use FT_TOKEN_STOPWORD for the token type of such a word.
*/
MYSQL_FTPARSER_FULL_BOOLEAN_INFO= 2
};
/*
Token types for boolean mode searching (used for the type member of
MYSQL_FTPARSER_BOOLEAN_INFO struct)
FT_TOKEN_EOF: End of data.
FT_TOKEN_WORD: Regular word.
FT_TOKEN_LEFT_PAREN: Left parenthesis (start of group/sub-expression).
FT_TOKEN_RIGHT_PAREN: Right parenthesis (end of group/sub-expression).
FT_TOKEN_STOPWORD: Stopword.
*/
enum enum_ft_token_type
{
FT_TOKEN_EOF= 0,
FT_TOKEN_WORD= 1,
FT_TOKEN_LEFT_PAREN= 2,
FT_TOKEN_RIGHT_PAREN= 3,
FT_TOKEN_STOPWORD= 4
};
/*
This structure is used in boolean search mode only. It conveys
boolean-mode metadata to the MySQL search engine for every word in
the search query. A valid instance of this structure must be filled
in by the plugin parser and passed as an argument in the call to
mysql_add_word (the callback function in the MYSQL_FTPARSER_PARAM
structure) when a query is parsed in boolean mode.
type: The token type. Should be one of the enum_ft_token_type values.
yesno: Whether the word must be present for a match to occur:
>0 Must be present
<0 Must not be present
0 Neither; the word is optional but its presence increases the relevance
With the default settings of the ft_boolean_syntax system variable,
>0 corresponds to the '+' operator, <0 corresponds to the '-' operator,
and 0 means neither operator was used.
weight_adjust: A weighting factor that determines how much a match
for the word counts. Positive values increase, negative - decrease the
relative word's importance in the query.
wasign: The sign of the word's weight in the query. If it's non-negative
the match for the word will increase document relevance, if it's
negative - decrease (the word becomes a "noise word", the less of it the
better).
trunc: Corresponds to the '*' operator in the default setting of the
ft_boolean_syntax system variable.
*/
typedef struct st_mysql_ftparser_boolean_info
{
enum enum_ft_token_type type;
int yesno;
int weight_adjust;
char wasign;
char trunc;
/* These are parser state and must be removed. */
char prev;
char *quot;
} MYSQL_FTPARSER_BOOLEAN_INFO;
/*
The following flag means that buffer with a string (document, word)
may be overwritten by the caller before the end of the parsing (that is
before st_mysql_ftparser::deinit() call). If one needs the string
to survive between two successive calls of the parsing function, she
needs to save a copy of it. The flag may be set by MySQL before calling
st_mysql_ftparser::parse(), or it may be set by a plugin before calling
st_mysql_ftparser_param::mysql_parse() or
st_mysql_ftparser_param::mysql_add_word().
*/
#define MYSQL_FTFLAGS_NEED_COPY 1
/*
An argument of the full-text parser plugin. This structure is
filled in by MySQL server and passed to the parsing function of the
plugin as an in/out parameter.
mysql_parse: A pointer to the built-in parser implementation of the
server. It's set by the server and can be used by the parser plugin
to invoke the MySQL default parser. If plugin's role is to extract
textual data from .doc, .pdf or .xml content, it might extract
plaintext from the content, and then pass the text to the default
MySQL parser to be parsed.
mysql_add_word: A server callback to add a new word. When parsing
a document, the server sets this to point at a function that adds
the word to MySQL full-text index. When parsing a search query,
this function will add the new word to the list of words to search
for. The boolean_info argument can be NULL for all cases except
when mode is MYSQL_FTPARSER_FULL_BOOLEAN_INFO. A plugin can replace this
callback to post-process every parsed word before passing it to the original
mysql_add_word function.
ftparser_state: A generic pointer. The plugin can set it to point
to information to be used internally for its own purposes.
mysql_ftparam: This is set by the server. It is used by MySQL functions
called via mysql_parse() and mysql_add_word() callback. The plugin
should not modify it.
cs: Information about the character set of the document or query string.
doc: A pointer to the document or query string to be parsed.
length: Length of the document or query string, in bytes.
flags: See MYSQL_FTFLAGS_* constants above.
mode: The parsing mode. With boolean operators, with stopwords, or
nothing. See enum_ftparser_mode above.
*/
typedef struct st_mysql_ftparser_param
{
int (*mysql_parse)(struct st_mysql_ftparser_param *,
const char *doc, int doc_len);
int (*mysql_add_word)(struct st_mysql_ftparser_param *,
const char *word, int word_len,
MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info);
void *ftparser_state;
void *mysql_ftparam;
const struct charset_info_st *cs;
const char *doc;
int length;
unsigned int flags;
enum enum_ftparser_mode mode;
} MYSQL_FTPARSER_PARAM;
/*
Full-text parser descriptor.
interface_version is, e.g., MYSQL_FTPARSER_INTERFACE_VERSION.
The parsing, initialization, and deinitialization functions are
invoked per SQL statement for which the parser is used.
*/
struct st_mysql_ftparser
{
int interface_version;
int (*parse)(MYSQL_FTPARSER_PARAM *param);
int (*init)(MYSQL_FTPARSER_PARAM *param);
int (*deinit)(MYSQL_FTPARSER_PARAM *param);
};
#ifdef __cplusplus
}
#endif
#endif
PK ! ?7˒ mysql/plugin_auth.hnu [ #ifndef MYSQL_PLUGIN_AUTH_INCLUDED
/* Copyright (C) 2010 Sergei Golubchik and Monty Program Ab
Copyright (c) 2010, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
Authentication Plugin API.
This file defines the API for server authentication plugins.
*/
#define MYSQL_PLUGIN_AUTH_INCLUDED
#include
#define MYSQL_AUTHENTICATION_INTERFACE_VERSION 0x0203
#include
#ifdef __cplusplus
extern "C" {
#endif
/* defines for MYSQL_SERVER_AUTH_INFO.password_used */
#define PASSWORD_USED_NO 0
#define PASSWORD_USED_YES 1
#define PASSWORD_USED_NO_MENTION 2
/**
Provides server plugin access to authentication information
*/
typedef struct st_mysql_server_auth_info
{
/**
User name as sent by the client and shown in USER().
NULL if the client packet with the user name was not received yet.
*/
const char *user_name;
/**
Length of user_name
*/
unsigned int user_name_length;
/**
A corresponding column value from the mysql.user table for the
matching account name or the preprocessed value, if preprocess_hash
method is not NULL
*/
const char *auth_string;
/**
Length of auth_string
*/
unsigned long auth_string_length;
/**
Matching account name as found in the mysql.user table.
A plugin can override it with another name that will be
used by MySQL for authorization, and shown in CURRENT_USER()
*/
char authenticated_as[MYSQL_USERNAME_LENGTH+1];
/**
The unique user name that was used by the plugin to authenticate.
Not used by the server.
Available through the @@EXTERNAL_USER variable.
*/
char external_user[MYSQL_USERNAME_LENGTH+1];
/**
This only affects the "Authentication failed. Password used: %s"
error message. has the following values :
0 : %s will be NO.
1 : %s will be YES.
2 : there will be no %s.
Set it as appropriate or ignore at will.
*/
int password_used;
/**
Set to the name of the connected client host, if it can be resolved,
or to its IP address otherwise.
*/
const char *host_or_ip;
/**
Length of host_or_ip
*/
unsigned int host_or_ip_length;
/**
Current THD pointer (to use with various services)
*/
MYSQL_THD thd;
} MYSQL_SERVER_AUTH_INFO;
/**
Server authentication plugin descriptor
*/
struct st_mysql_auth
{
int interface_version; /**< version plugin uses */
/**
A plugin that a client must use for authentication with this server
plugin. Can be NULL to mean "any plugin".
*/
const char *client_auth_plugin;
/**
Function provided by the plugin which should perform authentication (using
the vio functions if necessary) and return 0 if successful. The plugin can
also fill the info.authenticated_as field if a different username should be
used for authorization.
*/
int (*authenticate_user)(MYSQL_PLUGIN_VIO *vio, MYSQL_SERVER_AUTH_INFO *info);
/**
Create a password hash (or digest) out of a plain-text password
Used in SET PASSWORD, GRANT, and CREATE USER to convert user specified
plain-text password into a value that will be stored in mysql.user table.
@see preprocess_hash
@param password plain-text password
@param password_length plain-text password length
@param hash the digest will be stored there
@param hash_length in: hash buffer size
out: the actual length of the hash
@return 0 for ok, 1 for error
Can be NULL, in this case one will not be able to use SET PASSWORD or
PASSWORD('...') in GRANT, CREATE USER, ALTER USER.
*/
int (*hash_password)(const char *password, size_t password_length,
char *hash, size_t *hash_length);
/**
Prepare the password hash for authentication.
Password hash is stored in the authentication_string column of the
mysql.user table in a text form. If a plugin needs to preprocess the
value somehow before the authentication (e.g. convert from hex or base64
to binary), it can do it in this method. This way the conversion
will happen only once, not for every authentication attempt.
The value written to the out buffer will be cached and later made
available to the authenticate_user() method in the
MYSQL_SERVER_AUTH_INFO::auth_string[] buffer.
@return 0 for ok, 1 for error
Can be NULL, in this case the mysql.user.authentication_string value will
be given to the authenticate_user() method as is, unconverted.
*/
int (*preprocess_hash)(const char *hash, size_t hash_length,
unsigned char *out, size_t *out_length);
};
#ifdef __cplusplus
}
#endif
#endif
PK ! mysql/plugin_data_type.hnu [ #ifndef MARIADB_PLUGIN_DATA_TYPE_INCLUDED
#define MARIADB_PLUGIN_DATA_TYPE_INCLUDED
/* Copyright (C) 2019, Alexander Barkov and MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
Data Type Plugin API.
This file defines the API for server plugins that manage data types.
*/
#ifdef __cplusplus
#include
/*
API for data type plugins. (MariaDB_DATA_TYPE_PLUGIN)
*/
#define MariaDB_DATA_TYPE_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
struct st_mariadb_data_type
{
int interface_version;
class Type_handler *type_handler;
};
/**
Data type plugin descriptor
*/
#endif /* __cplusplus */
#endif /* MARIADB_PLUGIN_DATA_TYPE_INCLUDED */
PK ! #Sx
mysql/service_logger.hnu [ /* Copyright (C) 2012 Monty Program Ab
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_SERVICE_LOGGER_INCLUDED
#define MYSQL_SERVICE_LOGGER_INCLUDED
#ifndef MYSQL_ABI_CHECK
#include
#endif
/**
@file
logger service
Log file with rotation implementation.
This service implements logging with possible rotation
of the log files. Interface intentionally tries to be similar to FILE*
related functions.
So that one can open the log with logger_open(), specifying
the limit on the logfile size and the rotations number.
Then it's possible to write messages to the log with
logger_printf or logger_vprintf functions.
As the size of the logfile grows over the specified limit,
it is renamed to 'logfile.1'. The former 'logfile.1' becomes
'logfile.2', etc. The file 'logfile.rotations' is removed.
That's how the rotation works.
The rotation can be forced with the logger_rotate() call.
Finally the log should be closed with logger_close().
@notes:
Implementation checks the size of the log file before it starts new
printf into it. So the size of the file gets over the limit when it rotates.
The access is secured with the mutex, so the log is threadsafe.
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef struct logger_handle_st LOGGER_HANDLE;
extern struct logger_service_st {
void (*logger_init_mutexes)();
LOGGER_HANDLE* (*open)(const char *path,
unsigned long long size_limit,
unsigned int rotations);
int (*close)(LOGGER_HANDLE *log);
int (*vprintf)(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
int (*printf)(LOGGER_HANDLE *log, const char *fmt, ...);
int (*write)(LOGGER_HANDLE *log, const char *buffer, size_t size);
int (*rotate)(LOGGER_HANDLE *log);
} *logger_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define logger_init_mutexes logger_service->logger_init_mutexes
#define logger_open(path, size_limit, rotations) \
(logger_service->open(path, size_limit, rotations))
#define logger_close(log) (logger_service->close(log))
#define logger_rotate(log) (logger_service->rotate(log))
#define logger_vprintf(log, fmt, argptr) (logger_service->\
vprintf(log, fmt, argptr))
#define logger_printf (*logger_service->printf)
#define logger_write(log, buffer, size) \
(logger_service->write(log, buffer, size))
#else
void logger_init_mutexes();
LOGGER_HANDLE *logger_open(const char *path,
unsigned long long size_limit,
unsigned int rotations);
int logger_close(LOGGER_HANDLE *log);
int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
int logger_rotate(LOGGER_HANDLE *log);
#endif
#ifdef __cplusplus
}
#endif
#endif /*MYSQL_SERVICE_LOGGER_INCLUDED*/
PK ! ZqP mysql/service_thd_alloc.hnu [ #ifndef MYSQL_SERVICE_THD_ALLOC_INCLUDED
/* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
This service provides functions to allocate memory in a connection local
memory pool. The memory allocated there will be automatically freed at the
end of the statement, don't use it for allocations that should live longer
than that. For short living allocations this is more efficient than
using my_malloc and friends, and automatic "garbage collection" allows not
to think about memory leaks.
The pool is best for small to medium objects, don't use it for large
allocations - they are better served with my_malloc.
*/
#ifndef MYSQL_ABI_CHECK
#include
#endif
#ifdef __cplusplus
extern "C" {
#endif
struct st_mysql_const_lex_string
{
const char *str;
size_t length;
};
typedef struct st_mysql_const_lex_string MYSQL_CONST_LEX_STRING;
struct st_mysql_lex_string
{
char *str;
size_t length;
#ifdef __cplusplus
// Allow automatic cast from LEX_STRING to LEX_CSTRING in c++.
operator struct st_mysql_const_lex_string() const
{
return {str, length};
}
#endif
};
typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
extern struct thd_alloc_service_st {
void *(*thd_alloc_func)(const MYSQL_THD, size_t);
void *(*thd_calloc_func)(const MYSQL_THD, size_t);
char *(*thd_strdup_func)(const MYSQL_THD, const char *);
char *(*thd_strmake_func)(const MYSQL_THD, const char *, size_t);
void *(*thd_memdup_func)(const MYSQL_THD, const void*, size_t);
MYSQL_CONST_LEX_STRING *(*thd_make_lex_string_func)(const MYSQL_THD,
MYSQL_CONST_LEX_STRING *,
const char *, size_t, int);
} *thd_alloc_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define thd_alloc(thd,size) (thd_alloc_service->thd_alloc_func((thd), (size)))
#define thd_calloc(thd,size) (thd_alloc_service->thd_calloc_func((thd), (size)))
#define thd_strdup(thd,str) (thd_alloc_service->thd_strdup_func((thd), (str)))
#define thd_strmake(thd,str,size) \
(thd_alloc_service->thd_strmake_func((thd), (str), (size)))
#define thd_memdup(thd,str,size) \
(thd_alloc_service->thd_memdup_func((thd), (str), (size)))
#define thd_make_lex_string(thd, lex_str, str, size, allocate_lex_string) \
(thd_alloc_service->thd_make_lex_string_func((thd), (lex_str), (str), \
(size), (allocate_lex_string)))
#else
/**
Allocate memory in the connection's local memory pool
@details
When properly used in place of @c my_malloc(), this can significantly
improve concurrency. Don't use this or related functions to allocate
large chunks of memory. Use for temporary storage only. The memory
will be freed automatically at the end of the statement; no explicit
code is required to prevent memory leaks.
@see alloc_root()
*/
void *thd_alloc(const MYSQL_THD thd, size_t size);
/**
@see thd_alloc()
*/
void *thd_calloc(const MYSQL_THD thd, size_t size);
/**
@see thd_alloc()
*/
char *thd_strdup(const MYSQL_THD thd, const char *str);
/**
@see thd_alloc()
*/
char *thd_strmake(const MYSQL_THD thd, const char *str, size_t size);
/**
@see thd_alloc()
*/
void *thd_memdup(const MYSQL_THD thd, const void* str, size_t size);
/**
Create a LEX_STRING in this connection's local memory pool
@param thd user thread connection handle
@param lex_str pointer to LEX_STRING object to be initialized
@param str initializer to be copied into lex_str
@param size length of str, in bytes
@param allocate_lex_string flag: if TRUE, allocate new LEX_STRING object,
instead of using lex_str value
@return NULL on failure, or pointer to the LEX_STRING object
@see thd_alloc()
*/
MYSQL_CONST_LEX_STRING
*thd_make_lex_string(const MYSQL_THD thd, MYSQL_CONST_LEX_STRING *lex_str,
const char *str, size_t size,
int allocate_lex_string);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_THD_ALLOC_INCLUDED
#endif
PK ! DMf mysql/service_my_print_error.hnu [ /* Copyright (c) 2016, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_SERVICE_MY_PRINT_ERROR_INCLUDED
#define MYSQL_SERVICE_MY_PRINT_ERROR_INCLUDED
/**
@file include/mysql/service_my_print_error.h
This service provides functions for plugins to report
errors to client (without client, the errors are written to the error log).
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MYSQL_ABI_CHECK
#include
#include
#endif
#define ME_ERROR_LOG 64 /* Write the message to the error log */
#define ME_ERROR_LOG_ONLY 128 /* Write the error message to error log only */
#define ME_NOTE 1024 /* Not an error, just a note */
#define ME_WARNING 2048 /* Not an error, just a warning */
#define ME_FATAL 4096 /* Fatal statement error */
extern struct my_print_error_service_st {
void (*my_error_func)(unsigned int nr, unsigned long MyFlags, ...);
void (*my_printf_error_func)(unsigned int nr, const char *fmt, unsigned long MyFlags,...);
void (*my_printv_error_func)(unsigned int error, const char *format, unsigned long MyFlags, va_list ap);
} *my_print_error_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define my_error my_print_error_service->my_error_func
#define my_printf_error my_print_error_service->my_printf_error_func
#define my_printv_error(A,B,C,D) my_print_error_service->my_printv_error_func(A,B,C,D)
#else
extern void my_error(unsigned int nr, unsigned long MyFlags, ...);
extern void my_printf_error(unsigned int my_err, const char *format, unsigned long MyFlags, ...);
extern void my_printv_error(unsigned int error, const char *format, unsigned long MyFlags,va_list ap);
#endif /* MYSQL_DYNAMIC_PLUGIN */
#ifdef __cplusplus
}
#endif
#endif
PK ! l mysql/plugin_encryption.hnu [ #ifndef MYSQL_PLUGIN_ENCRYPTION_INCLUDED
/* Copyright (C) 2014, 2015 Sergei Golubchik and MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
Encryption Plugin API.
This file defines the API for server plugins that manage encryption
keys for MariaDB on-disk data encryption.
*/
#define MYSQL_PLUGIN_ENCRYPTION_INCLUDED
#include
#ifdef __cplusplus
extern "C" {
#endif
#define MariaDB_ENCRYPTION_INTERFACE_VERSION 0x0300
/**
Encryption plugin descriptor
*/
struct st_mariadb_encryption
{
int interface_version; /**< version plugin uses */
/*********** KEY MANAGEMENT ********************************************/
/**
function returning latest key version for a given key id
@return a version or ENCRYPTION_KEY_VERSION_INVALID to indicate an error.
*/
unsigned int (*get_latest_key_version)(unsigned int key_id);
/**
function returning a key for a key version
@param version the requested key version
@param key the key will be stored there. Can be NULL -
in which case no key will be returned
@param key_length in: key buffer size
out: the actual length of the key
This method can be used to query the key length - the required
buffer size - by passing key==NULL.
If the buffer size is less than the key length the content of the
key buffer is undefined (the plugin is free to partially fill it with
the key data or leave it untouched).
@return 0 on success, or
ENCRYPTION_KEY_VERSION_INVALID, ENCRYPTION_KEY_BUFFER_TOO_SMALL
or any other non-zero number for errors
*/
unsigned int (*get_key)(unsigned int key_id, unsigned int version,
unsigned char *key, unsigned int *key_length);
/*********** ENCRYPTION ************************************************/
/*
the caller uses encryption as follows:
1. create the encryption context object of the crypt_ctx_size() bytes.
2. initialize it with crypt_ctx_init().
3. repeat crypt_ctx_update() until there are no more data to encrypt.
4. write the remaining output bytes and destroy the context object
with crypt_ctx_finish().
*/
/**
returns the size of the encryption context object in bytes
*/
unsigned int (*crypt_ctx_size)(unsigned int key_id, unsigned int key_version);
/**
initializes the encryption context object.
*/
int (*crypt_ctx_init)(void *ctx, const unsigned char* key, unsigned int klen,
const unsigned char* iv, unsigned int ivlen,
int flags, unsigned int key_id,
unsigned int key_version);
/**
processes (encrypts or decrypts) a chunk of data
writes the output to the dst buffer. note that it might write
more bytes that were in the input. or less. or none at all.
dlen points to the starting lenght of the output buffer. Upon return, it
should be set to the number of bytes written.
*/
int (*crypt_ctx_update)(void *ctx, const unsigned char* src, unsigned int slen,
unsigned char* dst, unsigned int* dlen);
/**
writes the remaining output bytes and destroys the encryption context
crypt_ctx_update might've cached part of the output in the context,
this method will flush these data out.
*/
int (*crypt_ctx_finish)(void *ctx, unsigned char* dst, unsigned int* dlen);
/**
returns the length of the encrypted data
it returns the exact length, given only the source length.
which means, this API only supports encryption algorithms where
the length of the encrypted data only depends on the length of the
input (a.k.a. compression is not supported).
*/
unsigned int (*encrypted_length)(unsigned int slen, unsigned int key_id, unsigned int key_version);
};
#ifdef __cplusplus
}
#endif
#endif
PK ! 8kG G mysql/service_my_crypt.hnu [ #ifndef MYSQL_SERVICE_MY_CRYPT_INCLUDED
#define MYSQL_SERVICE_MY_CRYPT_INCLUDED
/*
Copyright (c) 2014 Google Inc.
Copyright (c) 2014, 2015 MariaDB Corporation
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
my crypt service
AES encryption functions, and a function to generate random bytes.
Include my_config.h before this file to use CTR and GCM modes
(they only work if server was compiled with openssl).
*/
#ifdef __cplusplus
extern "C" {
#endif
/* return values from my_aes_encrypt/my_aes_decrypt functions */
#define MY_AES_OK 0
#define MY_AES_BAD_DATA -100
#define MY_AES_OPENSSL_ERROR -101
#define MY_AES_BAD_KEYSIZE -102
/* The block size for all supported algorithms */
#define MY_AES_BLOCK_SIZE 16
/* The max key length of all supported algorithms */
#define MY_AES_MAX_KEY_LENGTH 32
#define MY_AES_CTX_SIZE 1040
enum my_aes_mode {
MY_AES_ECB, MY_AES_CBC
#ifdef HAVE_EncryptAes128Ctr
, MY_AES_CTR
#endif
#ifdef HAVE_EncryptAes128Gcm
, MY_AES_GCM
#endif
};
extern struct my_crypt_service_st {
int (*my_aes_crypt_init)(void *ctx, enum my_aes_mode mode, int flags,
const unsigned char* key, unsigned int klen,
const unsigned char* iv, unsigned int ivlen);
int (*my_aes_crypt_update)(void *ctx, const unsigned char *src, unsigned int slen,
unsigned char *dst, unsigned int *dlen);
int (*my_aes_crypt_finish)(void *ctx, unsigned char *dst, unsigned int *dlen);
int (*my_aes_crypt)(enum my_aes_mode mode, int flags,
const unsigned char *src, unsigned int slen, unsigned char *dst, unsigned int *dlen,
const unsigned char *key, unsigned int klen, const unsigned char *iv, unsigned int ivlen);
unsigned int (*my_aes_get_size)(enum my_aes_mode mode, unsigned int source_length);
unsigned int (*my_aes_ctx_size)(enum my_aes_mode mode);
int (*my_random_bytes)(unsigned char* buf, int num);
} *my_crypt_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define my_aes_crypt_init(A,B,C,D,E,F,G) \
my_crypt_service->my_aes_crypt_init(A,B,C,D,E,F,G)
#define my_aes_crypt_update(A,B,C,D,E) \
my_crypt_service->my_aes_crypt_update(A,B,C,D,E)
#define my_aes_crypt_finish(A,B,C) \
my_crypt_service->my_aes_crypt_finish(A,B,C)
#define my_aes_crypt(A,B,C,D,E,F,G,H,I,J) \
my_crypt_service->my_aes_crypt(A,B,C,D,E,F,G,H,I,J)
#define my_aes_get_size(A,B)\
my_crypt_service->my_aes_get_size(A,B)
#define my_aes_ctx_size(A)\
my_crypt_service->my_aes_ctx_size(A)
#define my_random_bytes(A,B)\
my_crypt_service->my_random_bytes(A,B)
#else
int my_aes_crypt_init(void *ctx, enum my_aes_mode mode, int flags,
const unsigned char* key, unsigned int klen,
const unsigned char* iv, unsigned int ivlen);
int my_aes_crypt_update(void *ctx, const unsigned char *src, unsigned int slen,
unsigned char *dst, unsigned int *dlen);
int my_aes_crypt_finish(void *ctx, unsigned char *dst, unsigned int *dlen);
int my_aes_crypt(enum my_aes_mode mode, int flags,
const unsigned char *src, unsigned int slen, unsigned char *dst, unsigned int *dlen,
const unsigned char *key, unsigned int klen, const unsigned char *iv, unsigned int ivlen);
int my_random_bytes(unsigned char* buf, int num);
unsigned int my_aes_get_size(enum my_aes_mode mode, unsigned int source_length);
unsigned int my_aes_ctx_size(enum my_aes_mode mode);
#endif
#ifdef __cplusplus
}
#endif
#endif /* MYSQL_SERVICE_MY_CRYPT_INCLUDED */
PK ! W%ћo o mysql/service_thd_wait.hnu [ /* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_SERVICE_THD_WAIT_INCLUDED
#define MYSQL_SERVICE_THD_WAIT_INCLUDED
/**
@file include/mysql/service_thd_wait.h
This service provides functions for plugins and storage engines to report
when they are going to sleep/stall.
SYNOPSIS
thd_wait_begin() - call just before a wait begins
thd Thread object
Use NULL if the thd is NOT known.
wait_type Type of wait
1 -- short wait (e.g. for mutex)
2 -- medium wait (e.g. for disk io)
3 -- large wait (e.g. for locked row/table)
NOTES
This is used by the threadpool to have better knowledge of which
threads that currently are actively running on CPUs. When a thread
reports that it's going to sleep/stall, the threadpool scheduler is
free to start another thread in the pool most likely. The expected wait
time is simply an indication of how long the wait is expected to
become, the real wait time could be very different.
thd_wait_end() called immediately after the wait is complete
thd_wait_end() MUST be called if thd_wait_begin() was called.
Using thd_wait_...() service is optional but recommended. Using it will
improve performance as the thread pool will be more active at managing the
thread workload.
*/
#ifdef __cplusplus
extern "C" {
#endif
/*
One should only report wait events that could potentially block for a
long time. A mutex wait is too short of an event to report. The reason
is that an event which is reported leads to a new thread starts
executing a query and this has a negative impact of usage of CPU caches
and thus the expected gain of starting a new thread must be higher than
the expected cost of lost performance due to starting a new thread.
Good examples of events that should be reported are waiting for row locks
that could easily be for many milliseconds or even seconds and the same
holds true for global read locks, table locks and other meta data locks.
Another event of interest is going to sleep for an extended time.
*/
typedef enum _thd_wait_type_e {
THD_WAIT_SLEEP= 1,
THD_WAIT_DISKIO= 2,
THD_WAIT_ROW_LOCK= 3,
THD_WAIT_GLOBAL_LOCK= 4,
THD_WAIT_META_DATA_LOCK= 5,
THD_WAIT_TABLE_LOCK= 6,
THD_WAIT_USER_LOCK= 7,
THD_WAIT_BINLOG= 8,
THD_WAIT_GROUP_COMMIT= 9,
THD_WAIT_SYNC= 10,
THD_WAIT_NET= 11,
THD_WAIT_LAST= 12
} thd_wait_type;
extern struct thd_wait_service_st {
void (*thd_wait_begin_func)(MYSQL_THD, int);
void (*thd_wait_end_func)(MYSQL_THD);
} *thd_wait_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define thd_wait_begin(_THD, _WAIT_TYPE) \
thd_wait_service->thd_wait_begin_func(_THD, _WAIT_TYPE)
#define thd_wait_end(_THD) thd_wait_service->thd_wait_end_func(_THD)
#else
void thd_wait_begin(MYSQL_THD thd, int wait_type);
void thd_wait_end(MYSQL_THD thd);
#endif
#ifdef __cplusplus
}
#endif
#endif
PK !
tj mysql/service_sql.hnu [ /* Copyright (C) 2021 MariaDB Corporation
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */
#ifndef MYSQL_SERVICE_SQL
#define MYSQL_SERVICE_SQL
#ifndef MYSQL_ABI_CHECK
#include
#endif
/**
@file
SQL service
Interface for plugins to execute SQL queries on the local server.
Functions of the service are the 'server-limited' client library:
mysql_init
mysql_real_connect_local
mysql_real_connect
mysql_errno
mysql_error
mysql_real_query
mysql_affected_rows
mysql_num_rows
mysql_store_result
mysql_free_result
mysql_fetch_row
mysql_close
*/
#ifdef __cplusplus
extern "C" {
#endif
extern struct sql_service_st {
MYSQL *(STDCALL *mysql_init_func)(MYSQL *mysql);
MYSQL *(*mysql_real_connect_local_func)(MYSQL *mysql);
MYSQL *(STDCALL *mysql_real_connect_func)(MYSQL *mysql, const char *host,
const char *user, const char *passwd, const char *db, unsigned int port,
const char *unix_socket, unsigned long clientflag);
unsigned int(STDCALL *mysql_errno_func)(MYSQL *mysql);
const char *(STDCALL *mysql_error_func)(MYSQL *mysql);
int (STDCALL *mysql_real_query_func)(MYSQL *mysql, const char *q,
unsigned long length);
my_ulonglong (STDCALL *mysql_affected_rows_func)(MYSQL *mysql);
my_ulonglong (STDCALL *mysql_num_rows_func)(MYSQL_RES *res);
MYSQL_RES *(STDCALL *mysql_store_result_func)(MYSQL *mysql);
void (STDCALL *mysql_free_result_func)(MYSQL_RES *result);
MYSQL_ROW (STDCALL *mysql_fetch_row_func)(MYSQL_RES *result);
void (STDCALL *mysql_close_func)(MYSQL *mysql);
int (STDCALL *mysql_options_func)(MYSQL *mysql, enum mysql_option option,
const void *arg);
unsigned long *(STDCALL *mysql_fetch_lengths_func)(MYSQL_RES *res);
int (STDCALL *mysql_set_character_set_func)(MYSQL *mysql, const char *cs_name);
unsigned int (STDCALL *mysql_num_fields_func)(MYSQL_RES *res);
int (STDCALL *mysql_select_db_func)(MYSQL *mysql, const char *db);
MYSQL_RES *(STDCALL *mysql_use_result_func)(MYSQL *mysql);
MYSQL_FIELD *(STDCALL *mysql_fetch_fields_func)(MYSQL_RES *res);
unsigned long (STDCALL *mysql_real_escape_string_func)(MYSQL *mysql, char *to,
const char *from, unsigned long length);
my_bool (STDCALL *mysql_ssl_set_func)(MYSQL *mysql, const char *key,
const char *cert, const char *ca, const char *capath, const char *cipher);
} *sql_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define mysql_init(M) sql_service->mysql_init_func(M)
#define mysql_real_connect_local(M) sql_service->mysql_real_connect_local_func(M)
#define mysql_real_connect(M,H,U,PW,D,P,S,F) sql_service->mysql_real_connect_func(M,H,U,PW,D,P,S,F)
#define mysql_errno(M) sql_service->mysql_errno_func(M)
#define mysql_error(M) sql_service->mysql_error_func(M)
#define mysql_real_query sql_service->mysql_real_query_func
#define mysql_affected_rows(M) sql_service->mysql_affected_rows_func(M)
#define mysql_num_rows(R) sql_service->mysql_num_rows_func(R)
#define mysql_store_result(M) sql_service->mysql_store_result_func(M)
#define mysql_free_result(R) sql_service->mysql_free_result_func(R)
#define mysql_fetch_row(R) sql_service->mysql_fetch_row_func(R)
#define mysql_close(M) sql_service->mysql_close_func(M)
#define mysql_options(M,O,V) sql_service->mysql_options_func(M,O,V)
#define mysql_fetch_lengths(R) sql_service->mysql_fetch_lengths_func(R)
#define mysql_set_character_set(M,C) sql_service->mysql_set_character_set_func(M,C)
#define mysql_num_fields(R) sql_service->mysql_num_fields_func(R)
#define mysql_select_db(M,D) sql_service->mysql_select_db_func(M,D)
#define mysql_use_result(M) sql_service->mysql_use_result_func(M)
#define mysql_fetch_fields(R) sql_service->mysql_fetch_fields_func(R)
#define mysql_real_escape_string(M,T,F,L) sql_service->mysql_real_escape_string_func(M,T,F,L)
#define mysql_ssl_set(M,K,C1,C2,C3,C4) sql_service->mysql_ssl_set_func(M,K,C1,C2,C3,C4)
#else
/*
Establishes the connection to the 'local' server that started the plugin.
Like the mysql_real_connect() does for the remote server.
The established connection has no user/host associated to it,
neither it has the current db, so the queries should have
database/table name specified.
*/
MYSQL *mysql_real_connect_local(MYSQL *mysql);
/* The rest of the function declarations must be taken from the mysql.h */
#endif /*MYSQL_DYNAMIC_PLUGIN*/
#ifdef __cplusplus
}
#endif
#endif /*MYSQL_SERVICE_SQL */
PK ! ĞEQt t mysql/plugin.hnu [ /* Copyright (c) 2005, 2013, Oracle and/or its affiliates
Copyright (C) 2009, 2017, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MYSQL_PLUGIN_INCLUDED
#define MYSQL_PLUGIN_INCLUDED
/*
On Windows, exports from DLL need to be declared
Also, plugin needs to be declared as extern "C" because MSVC
unlike other compilers, uses C++ mangling for variables not only
for functions.
*/
#ifdef MYSQL_DYNAMIC_PLUGIN
#ifdef _MSC_VER
#define MYSQL_DLLEXPORT _declspec(dllexport)
#else
#define MYSQL_DLLEXPORT
#endif
#else
#define MYSQL_DLLEXPORT
#endif
#ifdef __cplusplus
#define MYSQL_PLUGIN_EXPORT extern "C" MYSQL_DLLEXPORT
#else
#define MYSQL_PLUGIN_EXPORT MYSQL_DLLEXPORT
#endif
#ifdef __cplusplus
class THD;
class Item;
#define MYSQL_THD THD*
#else
struct THD;
typedef struct THD* MYSQL_THD;
#endif
typedef char my_bool;
typedef void * MYSQL_PLUGIN;
#include
#define MYSQL_XIDDATASIZE 128
/**
struct st_mysql_xid is binary compatible with the XID structure as
in the X/Open CAE Specification, Distributed Transaction Processing:
The XA Specification, X/Open Company Ltd., 1991.
http://www.opengroup.org/bookstore/catalog/c193.htm
@see XID in sql/handler.h
*/
struct st_mysql_xid {
long formatID;
long gtrid_length;
long bqual_length;
char data[MYSQL_XIDDATASIZE]; /* Not \0-terminated */
};
typedef struct st_mysql_xid MYSQL_XID;
/*************************************************************************
Plugin API. Common for all plugin types.
*/
/* MySQL plugin interface version */
#define MYSQL_PLUGIN_INTERFACE_VERSION 0x0104
/* MariaDB plugin interface version */
#define MARIA_PLUGIN_INTERFACE_VERSION 0x010f
/*
The allowable types of plugins
*/
#define MYSQL_UDF_PLUGIN 0 /* not implemented */
#define MYSQL_STORAGE_ENGINE_PLUGIN 1
#define MYSQL_FTPARSER_PLUGIN 2 /* Full-text parser plugin */
#define MYSQL_DAEMON_PLUGIN 3
#define MYSQL_INFORMATION_SCHEMA_PLUGIN 4
#define MYSQL_AUDIT_PLUGIN 5
#define MYSQL_REPLICATION_PLUGIN 6
#define MYSQL_AUTHENTICATION_PLUGIN 7
#define MYSQL_MAX_PLUGIN_TYPE_NUM 12 /* The number of plugin types */
/* MariaDB plugin types */
#define MariaDB_PASSWORD_VALIDATION_PLUGIN 8
#define MariaDB_ENCRYPTION_PLUGIN 9
#define MariaDB_DATA_TYPE_PLUGIN 10
#define MariaDB_FUNCTION_PLUGIN 11
/* We use the following strings to define licenses for plugins */
#define PLUGIN_LICENSE_PROPRIETARY 0
#define PLUGIN_LICENSE_GPL 1
#define PLUGIN_LICENSE_BSD 2
#define PLUGIN_LICENSE_PROPRIETARY_STRING "PROPRIETARY"
#define PLUGIN_LICENSE_GPL_STRING "GPL"
#define PLUGIN_LICENSE_BSD_STRING "BSD"
/* definitions of code maturity for plugins */
#define MariaDB_PLUGIN_MATURITY_UNKNOWN 0
#define MariaDB_PLUGIN_MATURITY_EXPERIMENTAL 1
#define MariaDB_PLUGIN_MATURITY_ALPHA 2
#define MariaDB_PLUGIN_MATURITY_BETA 3
#define MariaDB_PLUGIN_MATURITY_GAMMA 4
#define MariaDB_PLUGIN_MATURITY_STABLE 5
/*
Macros for beginning and ending plugin declarations. Between
mysql_declare_plugin and mysql_declare_plugin_end there should
be a st_mysql_plugin struct for each plugin to be declared.
*/
#ifndef MYSQL_DYNAMIC_PLUGIN
#define __MYSQL_DECLARE_PLUGIN(NAME, VERSION, PSIZE, DECLS) \
int VERSION= MYSQL_PLUGIN_INTERFACE_VERSION; \
int PSIZE= sizeof(struct st_mysql_plugin); \
struct st_mysql_plugin DECLS[]= {
#define MARIA_DECLARE_PLUGIN__(NAME, VERSION, PSIZE, DECLS) \
MYSQL_PLUGIN_EXPORT int VERSION; \
int VERSION= MARIA_PLUGIN_INTERFACE_VERSION; \
MYSQL_PLUGIN_EXPORT int PSIZE; \
int PSIZE= sizeof(struct st_maria_plugin); \
MYSQL_PLUGIN_EXPORT struct st_maria_plugin DECLS[]; \
struct st_maria_plugin DECLS[]= {
#else
#define __MYSQL_DECLARE_PLUGIN(NAME, VERSION, PSIZE, DECLS) \
MYSQL_PLUGIN_EXPORT int _mysql_plugin_interface_version_; \
int _mysql_plugin_interface_version_= MYSQL_PLUGIN_INTERFACE_VERSION; \
MYSQL_PLUGIN_EXPORT int _mysql_sizeof_struct_st_plugin_; \
int _mysql_sizeof_struct_st_plugin_= sizeof(struct st_mysql_plugin); \
MYSQL_PLUGIN_EXPORT struct st_mysql_plugin _mysql_plugin_declarations_[]; \
struct st_mysql_plugin _mysql_plugin_declarations_[]= {
#define MARIA_DECLARE_PLUGIN__(NAME, VERSION, PSIZE, DECLS) \
MYSQL_PLUGIN_EXPORT int _maria_plugin_interface_version_; \
int _maria_plugin_interface_version_= MARIA_PLUGIN_INTERFACE_VERSION; \
MYSQL_PLUGIN_EXPORT int _maria_sizeof_struct_st_plugin_; \
int _maria_sizeof_struct_st_plugin_= sizeof(struct st_maria_plugin); \
MYSQL_PLUGIN_EXPORT struct st_maria_plugin _maria_plugin_declarations_[]; \
struct st_maria_plugin _maria_plugin_declarations_[]= {
#endif
#define mysql_declare_plugin(NAME) \
__MYSQL_DECLARE_PLUGIN(NAME, \
builtin_ ## NAME ## _plugin_interface_version, \
builtin_ ## NAME ## _sizeof_struct_st_plugin, \
builtin_ ## NAME ## _plugin)
#define maria_declare_plugin(NAME) \
MARIA_DECLARE_PLUGIN__(NAME, \
builtin_maria_ ## NAME ## _plugin_interface_version, \
builtin_maria_ ## NAME ## _sizeof_struct_st_plugin, \
builtin_maria_ ## NAME ## _plugin)
#define mysql_declare_plugin_end ,{0,0,0,0,0,0,0,0,0,0,0,0,0}}
#define maria_declare_plugin_end ,{0,0,0,0,0,0,0,0,0,0,0,0,0}}
/*
declarations for SHOW STATUS support in plugins
*/
enum enum_mysql_show_type
{
SHOW_UNDEF, SHOW_BOOL, SHOW_UINT, SHOW_ULONG,
SHOW_ULONGLONG, SHOW_CHAR, SHOW_CHAR_PTR,
SHOW_ARRAY, SHOW_FUNC, SHOW_DOUBLE,
SHOW_SINT, SHOW_SLONG, SHOW_SLONGLONG, SHOW_SIMPLE_FUNC,
SHOW_SIZE_T, SHOW_always_last
};
/* backward compatibility mapping. */
#define SHOW_INT SHOW_UINT
#define SHOW_LONG SHOW_ULONG
#define SHOW_LONGLONG SHOW_ULONGLONG
enum enum_var_type
{
SHOW_OPT_DEFAULT= 0, SHOW_OPT_SESSION, SHOW_OPT_GLOBAL
};
struct st_mysql_show_var {
const char *name;
void *value;
enum enum_mysql_show_type type;
};
struct system_status_var;
#define SHOW_VAR_FUNC_BUFF_SIZE (256 * sizeof(void*))
typedef int (*mysql_show_var_func)(MYSQL_THD, struct st_mysql_show_var*, void *, struct system_status_var *status_var, enum enum_var_type);
static inline
struct st_mysql_show_var SHOW_FUNC_ENTRY(const char *name,
mysql_show_var_func func_arg)
{
struct st_mysql_show_var tmp;
tmp.name= name;
tmp.value= (void*) func_arg;
tmp.type= SHOW_FUNC;
return tmp;
};
/*
Constants for plugin flags.
*/
#define PLUGIN_OPT_NO_INSTALL 1UL /* Not dynamically loadable */
#define PLUGIN_OPT_NO_UNINSTALL 2UL /* Not dynamically unloadable */
/*
declarations for server variables and command line options
*/
#define PLUGIN_VAR_BOOL 0x0001
#define PLUGIN_VAR_INT 0x0002
#define PLUGIN_VAR_LONG 0x0003
#define PLUGIN_VAR_LONGLONG 0x0004
#define PLUGIN_VAR_STR 0x0005
#define PLUGIN_VAR_ENUM 0x0006
#define PLUGIN_VAR_SET 0x0007
#define PLUGIN_VAR_DOUBLE 0x0008
#define PLUGIN_VAR_UNSIGNED 0x0080
#define PLUGIN_VAR_THDLOCAL 0x0100 /* Variable is per-connection */
#define PLUGIN_VAR_READONLY 0x0200 /* Server variable is read only */
#define PLUGIN_VAR_NOSYSVAR 0x0400 /* Not a server variable */
#define PLUGIN_VAR_NOCMDOPT 0x0800 /* Not a command line option */
#define PLUGIN_VAR_NOCMDARG 0x1000 /* No argument for cmd line */
#define PLUGIN_VAR_RQCMDARG 0x0000 /* Argument required for cmd line */
#define PLUGIN_VAR_OPCMDARG 0x2000 /* Argument optional for cmd line */
#define PLUGIN_VAR_DEPRECATED 0x4000 /* Server variable is deprecated */
#define PLUGIN_VAR_MEMALLOC 0x8000 /* String needs memory allocated */
struct st_mysql_sys_var;
struct st_mysql_value;
/*
SYNOPSIS
(*mysql_var_check_func)()
thd thread handle
var dynamic variable being altered
save pointer to temporary storage
value user provided value
RETURN
0 user provided value is OK and the update func may be called.
any other value indicates error.
This function should parse the user provided value and store in the
provided temporary storage any data as required by the update func.
There is sufficient space in the temporary storage to store a double.
Note that the update func may not be called if any other error occurs
so any memory allocated should be thread-local so that it may be freed
automatically at the end of the statement.
*/
typedef int (*mysql_var_check_func)(MYSQL_THD thd,
struct st_mysql_sys_var *var,
void *save, struct st_mysql_value *value);
/*
SYNOPSIS
(*mysql_var_update_func)()
thd thread handle
var dynamic variable being altered
var_ptr pointer to dynamic variable
save pointer to temporary storage
RETURN
NONE
This function should use the validated value stored in the temporary store
and persist it in the provided pointer to the dynamic variable.
For example, strings may require memory to be allocated.
*/
typedef void (*mysql_var_update_func)(MYSQL_THD thd,
struct st_mysql_sys_var *var,
void *var_ptr, const void *save);
/* the following declarations are for internal use only */
#define PLUGIN_VAR_MASK \
(PLUGIN_VAR_READONLY | PLUGIN_VAR_NOSYSVAR | \
PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_NOCMDARG | \
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_RQCMDARG | \
PLUGIN_VAR_DEPRECATED | PLUGIN_VAR_MEMALLOC)
#define MYSQL_PLUGIN_VAR_HEADER \
int flags; \
const char *name; \
const char *comment; \
mysql_var_check_func check; \
mysql_var_update_func update
#define MYSQL_SYSVAR_NAME(name) mysql_sysvar_ ## name
#define MYSQL_SYSVAR(name) \
((struct st_mysql_sys_var *)&(MYSQL_SYSVAR_NAME(name)))
/*
for global variables, the value pointer is the first
element after the header, the default value is the second.
for thread variables, the value offset is the first
element after the header, the default value is the second.
*/
#define DECLARE_MYSQL_SYSVAR_BASIC(name, type) struct { \
MYSQL_PLUGIN_VAR_HEADER; \
type *value; \
const type def_val; \
} MYSQL_SYSVAR_NAME(name)
#define DECLARE_MYSQL_SYSVAR_CONST_BASIC(name, type) struct { \
MYSQL_PLUGIN_VAR_HEADER; \
const type *value; \
const type def_val; \
} MYSQL_SYSVAR_NAME(name)
#define DECLARE_MYSQL_SYSVAR_SIMPLE(name, type) struct { \
MYSQL_PLUGIN_VAR_HEADER; \
type *value; type def_val; \
type min_val; type max_val; \
type blk_sz; \
} MYSQL_SYSVAR_NAME(name)
#define DECLARE_MYSQL_SYSVAR_TYPELIB(name, type) struct { \
MYSQL_PLUGIN_VAR_HEADER; \
type *value; type def_val; \
TYPELIB *typelib; \
} MYSQL_SYSVAR_NAME(name)
#define DECLARE_THDVAR_FUNC(type) \
type *(*resolve)(MYSQL_THD thd, int offset)
#define DECLARE_MYSQL_THDVAR_BASIC(name, type) struct { \
MYSQL_PLUGIN_VAR_HEADER; \
int offset; \
const type def_val; \
DECLARE_THDVAR_FUNC(type); \
} MYSQL_SYSVAR_NAME(name)
#define DECLARE_MYSQL_THDVAR_SIMPLE(name, type) struct { \
MYSQL_PLUGIN_VAR_HEADER; \
int offset; \
type def_val; type min_val; \
type max_val; type blk_sz; \
DECLARE_THDVAR_FUNC(type); \
} MYSQL_SYSVAR_NAME(name)
#define DECLARE_MYSQL_THDVAR_TYPELIB(name, type) struct { \
MYSQL_PLUGIN_VAR_HEADER; \
int offset; \
const type def_val; \
DECLARE_THDVAR_FUNC(type); \
TYPELIB *typelib; \
} MYSQL_SYSVAR_NAME(name)
/*
the following declarations are for use by plugin implementors
*/
#define MYSQL_SYSVAR_BOOL(name, varname, opt, comment, check, update, def) \
DECLARE_MYSQL_SYSVAR_BASIC(name, char) = { \
PLUGIN_VAR_BOOL | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def}
#define MYSQL_SYSVAR_STR(name, varname, opt, comment, check, update, def) \
DECLARE_MYSQL_SYSVAR_BASIC(name, char *) = { \
PLUGIN_VAR_STR | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def}
#define MYSQL_SYSVAR_CONST_STR(name, varname, opt, comment, check, update, def) \
DECLARE_MYSQL_SYSVAR_CONST_BASIC(name, char *) = { \
PLUGIN_VAR_STR | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def}
#define MYSQL_SYSVAR_INT(name, varname, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_SYSVAR_SIMPLE(name, int) = { \
PLUGIN_VAR_INT | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, min, max, blk }
#define MYSQL_SYSVAR_UINT(name, varname, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_SYSVAR_SIMPLE(name, unsigned int) = { \
PLUGIN_VAR_INT | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, min, max, blk }
#define MYSQL_SYSVAR_LONG(name, varname, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_SYSVAR_SIMPLE(name, long) = { \
PLUGIN_VAR_LONG | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, min, max, blk }
#define MYSQL_SYSVAR_ULONG(name, varname, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_SYSVAR_SIMPLE(name, unsigned long) = { \
PLUGIN_VAR_LONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, min, max, blk }
#define MYSQL_SYSVAR_LONGLONG(name, varname, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_SYSVAR_SIMPLE(name, long long) = { \
PLUGIN_VAR_LONGLONG | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, min, max, blk }
#define MYSQL_SYSVAR_ULONGLONG(name, varname, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_SYSVAR_SIMPLE(name, unsigned long long) = { \
PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, min, max, blk }
#define MYSQL_SYSVAR_UINT64_T(name, varname, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_SYSVAR_SIMPLE(name, uint64_t) = { \
PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, min, max, blk }
#ifdef _WIN64
#define MYSQL_SYSVAR_SIZE_T(name, varname, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_SYSVAR_SIMPLE(name, size_t) = { \
PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, min, max, blk }
#else
#define MYSQL_SYSVAR_SIZE_T(name, varname, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_SYSVAR_SIMPLE(name, size_t) = { \
PLUGIN_VAR_LONG | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, min, max, blk }
#endif
#define MYSQL_SYSVAR_ENUM(name, varname, opt, comment, check, update, def, typelib) \
DECLARE_MYSQL_SYSVAR_TYPELIB(name, unsigned long) = { \
PLUGIN_VAR_ENUM | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, typelib }
#define MYSQL_SYSVAR_SET(name, varname, opt, comment, check, update, def, typelib) \
DECLARE_MYSQL_SYSVAR_TYPELIB(name, unsigned long long) = { \
PLUGIN_VAR_SET | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, typelib }
#define MYSQL_SYSVAR_DOUBLE(name, varname, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_SYSVAR_SIMPLE(name, double) = { \
PLUGIN_VAR_DOUBLE | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, &varname, def, min, max, blk }
#define MYSQL_THDVAR_BOOL(name, opt, comment, check, update, def) \
DECLARE_MYSQL_THDVAR_BASIC(name, char) = { \
PLUGIN_VAR_BOOL | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, NULL}
#define MYSQL_THDVAR_STR(name, opt, comment, check, update, def) \
DECLARE_MYSQL_THDVAR_BASIC(name, char *) = { \
PLUGIN_VAR_STR | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, NULL}
#define MYSQL_THDVAR_INT(name, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_THDVAR_SIMPLE(name, int) = { \
PLUGIN_VAR_INT | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, min, max, blk, NULL }
#define MYSQL_THDVAR_UINT(name, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_THDVAR_SIMPLE(name, unsigned int) = { \
PLUGIN_VAR_INT | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, min, max, blk, NULL }
#define MYSQL_THDVAR_LONG(name, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_THDVAR_SIMPLE(name, long) = { \
PLUGIN_VAR_LONG | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, min, max, blk, NULL }
#define MYSQL_THDVAR_ULONG(name, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_THDVAR_SIMPLE(name, unsigned long) = { \
PLUGIN_VAR_LONG | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, min, max, blk, NULL }
#define MYSQL_THDVAR_LONGLONG(name, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_THDVAR_SIMPLE(name, long long) = { \
PLUGIN_VAR_LONGLONG | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, min, max, blk, NULL }
#define MYSQL_THDVAR_ULONGLONG(name, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_THDVAR_SIMPLE(name, unsigned long long) = { \
PLUGIN_VAR_LONGLONG | PLUGIN_VAR_THDLOCAL | PLUGIN_VAR_UNSIGNED | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, min, max, blk, NULL }
#define MYSQL_THDVAR_ENUM(name, opt, comment, check, update, def, typelib) \
DECLARE_MYSQL_THDVAR_TYPELIB(name, unsigned long) = { \
PLUGIN_VAR_ENUM | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, NULL, typelib }
#define MYSQL_THDVAR_SET(name, opt, comment, check, update, def, typelib) \
DECLARE_MYSQL_THDVAR_TYPELIB(name, unsigned long long) = { \
PLUGIN_VAR_SET | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, NULL, typelib }
#define MYSQL_THDVAR_DOUBLE(name, opt, comment, check, update, def, min, max, blk) \
DECLARE_MYSQL_THDVAR_SIMPLE(name, double) = { \
PLUGIN_VAR_DOUBLE | PLUGIN_VAR_THDLOCAL | ((opt) & PLUGIN_VAR_MASK), \
#name, comment, check, update, -1, def, min, max, blk, NULL }
/* accessor macros */
#define SYSVAR(name) \
(*(MYSQL_SYSVAR_NAME(name).value))
/* when thd == null, result points to global value */
#define THDVAR(thd, name) \
(*(MYSQL_SYSVAR_NAME(name).resolve(thd, MYSQL_SYSVAR_NAME(name).offset)))
/*
Plugin description structure.
*/
struct st_mysql_plugin
{
int type; /* the plugin type (a MYSQL_XXX_PLUGIN value) */
void *info; /* pointer to type-specific plugin descriptor */
const char *name; /* plugin name */
const char *author; /* plugin author (for I_S.PLUGINS) */
const char *descr; /* general descriptive text (for I_S.PLUGINS) */
int license; /* the plugin license (PLUGIN_LICENSE_XXX) */
/*
The function to invoke when plugin is loaded. Plugin
initialisation done here should defer any ALTER TABLE queries to
after the ddl recovery is done, in the signal_ddl_recovery_done()
callback called by ha_signal_ddl_recovery_done().
*/
int (*init)(void *);
int (*deinit)(void *);/* the function to invoke when plugin is unloaded */
unsigned int version; /* plugin version (for I_S.PLUGINS) */
struct st_mysql_show_var *status_vars;
struct st_mysql_sys_var **system_vars;
void * __reserved1; /* reserved for dependency checking */
unsigned long flags; /* flags for plugin */
};
/*
MariaDB extension for plugins declaration structure.
It also copy current MySQL plugin fields to have more independency
in plugins extension
*/
struct st_maria_plugin
{
int type; /* the plugin type (a MYSQL_XXX_PLUGIN value) */
void *info; /* pointer to type-specific plugin descriptor */
const char *name; /* plugin name */
const char *author; /* plugin author (for SHOW PLUGINS) */
const char *descr; /* general descriptive text (for SHOW PLUGINS ) */
int license; /* the plugin license (PLUGIN_LICENSE_XXX) */
/*
The function to invoke when plugin is loaded. Plugin
initialisation done here should defer any ALTER TABLE queries to
after the ddl recovery is done, in the signal_ddl_recovery_done()
callback called by ha_signal_ddl_recovery_done().
*/
int (*init)(void *);
int (*deinit)(void *);/* the function to invoke when plugin is unloaded */
unsigned int version; /* plugin version (for SHOW PLUGINS) */
struct st_mysql_show_var *status_vars;
struct st_mysql_sys_var **system_vars;
const char *version_info; /* plugin version string */
unsigned int maturity; /* MariaDB_PLUGIN_MATURITY_XXX */
};
/*************************************************************************
API for Full-text parser plugin. (MYSQL_FTPARSER_PLUGIN)
*/
#include "plugin_ftparser.h"
/*************************************************************************
API for Storage Engine plugin. (MYSQL_DAEMON_PLUGIN)
*/
/* handlertons of different MySQL releases are incompatible */
#define MYSQL_DAEMON_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
/*
Here we define only the descriptor structure, that is referred from
st_mysql_plugin.
*/
struct st_mysql_daemon
{
int interface_version;
};
/*************************************************************************
API for I_S plugin. (MYSQL_INFORMATION_SCHEMA_PLUGIN)
*/
/* handlertons of different MySQL releases are incompatible */
#define MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
/*
Here we define only the descriptor structure, that is referred from
st_mysql_plugin.
*/
struct st_mysql_information_schema
{
int interface_version;
};
/*************************************************************************
API for Storage Engine plugin. (MYSQL_STORAGE_ENGINE_PLUGIN)
*/
/* handlertons of different MySQL releases are incompatible */
#define MYSQL_HANDLERTON_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
/*
The real API is in the sql/handler.h
Here we define only the descriptor structure, that is referred from
st_mysql_plugin.
*/
struct st_mysql_storage_engine
{
int interface_version;
};
struct handlerton;
/*
API for Replication plugin. (MYSQL_REPLICATION_PLUGIN)
*/
#define MYSQL_REPLICATION_INTERFACE_VERSION 0x0200
/**
Replication plugin descriptor
*/
struct Mysql_replication {
int interface_version;
};
/*************************************************************************
st_mysql_value struct for reading values from mysqld.
Used by server variables framework to parse user-provided values.
Will be used for arguments when implementing UDFs.
Note that val_str() returns a string in temporary memory
that will be freed at the end of statement. Copy the string
if you need it to persist.
*/
#define MYSQL_VALUE_TYPE_STRING 0
#define MYSQL_VALUE_TYPE_REAL 1
#define MYSQL_VALUE_TYPE_INT 2
struct st_mysql_value
{
int (*value_type)(struct st_mysql_value *);
const char *(*val_str)(struct st_mysql_value *, char *buffer, int *length);
int (*val_real)(struct st_mysql_value *, double *realbuf);
int (*val_int)(struct st_mysql_value *, long long *intbuf);
int (*is_unsigned)(struct st_mysql_value *);
};
/*************************************************************************
Miscellaneous functions for plugin implementors
*/
#ifdef __cplusplus
extern "C" {
#endif
int thd_in_lock_tables(const MYSQL_THD thd);
int thd_tablespace_op(const MYSQL_THD thd);
long long thd_test_options(const MYSQL_THD thd, long long test_options);
int thd_sql_command(const MYSQL_THD thd);
struct DDL_options_st;
struct DDL_options_st *thd_ddl_options(const MYSQL_THD thd);
void thd_storage_lock_wait(MYSQL_THD thd, long long value);
int thd_tx_isolation(const MYSQL_THD thd);
int thd_tx_is_read_only(const MYSQL_THD thd);
/**
Create a temporary file.
@details
The temporary file is created in a location specified by the mysql
server configuration (--tmpdir option). The caller does not need to
delete the file, it will be deleted automatically.
@param prefix prefix for temporary file name
@retval -1 error
@retval >= 0 a file handle that can be passed to dup or my_close
*/
int mysql_tmpfile(const char *prefix);
/**
Return the thread id of a user thread
@param thd user thread connection handle
@return thread id
*/
unsigned long thd_get_thread_id(const MYSQL_THD thd);
/**
Get the XID for this connection's transaction
@param thd user thread connection handle
@param xid location where identifier is stored
*/
void thd_get_xid(const MYSQL_THD thd, MYSQL_XID *xid);
/**
Invalidate the query cache for a given table.
@param thd user thread connection handle
@param key databasename\\0tablename\\0
@param key_length length of key in bytes, including the NUL bytes
@param using_trx flag: TRUE if using transactions, FALSE otherwise
*/
void mysql_query_cache_invalidate4(MYSQL_THD thd,
const char *key, unsigned int key_length,
int using_trx);
/**
Provide a handler data getter to simplify coding
*/
void *thd_get_ha_data(const MYSQL_THD thd, const struct handlerton *hton);
/**
Provide a handler data setter to simplify coding
@details
Set ha_data pointer (storage engine per-connection information).
To avoid unclean deactivation (uninstall) of storage engine plugin
in the middle of transaction, additional storage engine plugin
lock is acquired.
If ha_data is not null and storage engine plugin was not locked
by thd_set_ha_data() in this connection before, storage engine
plugin gets locked.
If ha_data is null and storage engine plugin was locked by
thd_set_ha_data() in this connection before, storage engine
plugin lock gets released.
If handlerton::close_connection() didn't reset ha_data, server does
it immediately after calling handlerton::close_connection().
*/
void thd_set_ha_data(MYSQL_THD thd, const struct handlerton *hton,
const void *ha_data);
/**
Signal that the first part of handler commit is finished, and that the
committed transaction is now visible and has fixed commit ordering with
respect to other transactions. The commit need _not_ be durable yet, and
typically will not be when this call makes sense.
This call is optional, if the storage engine does not call it the upper
layer will after the handler commit() method is done. However, the storage
engine may choose to call it itself to increase the possibility for group
commit.
In-order parallel replication uses this to apply different transaction in
parallel, but delay the commits of later transactions until earlier
transactions have committed first, thus achieving increased performance on
multi-core systems while still preserving full transaction consistency.
The storage engine can call this from within the commit() method, typically
after the commit record has been written to the transaction log, but before
the log has been fsync()'ed. This will allow the next replicated transaction
to proceed to commit before the first one has done fsync() or similar. Thus,
it becomes possible for multiple sequential replicated transactions to share
a single fsync() inside the engine in group commit.
Note that this method should _not_ be called from within the commit_ordered()
method, or any other place in the storage engine. When commit_ordered() is
used (typically when binlog is enabled), the transaction coordinator takes
care of this and makes group commit in the storage engine possible without
any other action needed on the part of the storage engine. This function
thd_wakeup_subsequent_commits() is only needed when no transaction
coordinator is used, meaning a single storage engine and no binary log.
*/
void thd_wakeup_subsequent_commits(MYSQL_THD thd, int wakeup_error);
#ifdef __cplusplus
}
#endif
#endif
PK ! mysql/service_sha2.hnu [ #ifndef MYSQL_SERVICE_SHA2_INCLUDED
/* Copyright (c) 2017, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
my sha2 service
Functions to calculate SHA2 hash from a memory buffer
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MYSQL_ABI_CHECK
#include
#endif
extern struct my_sha2_service_st {
void (*my_sha224_type)(unsigned char*, const char*, size_t);
void (*my_sha224_multi_type)(unsigned char*, ...);
size_t (*my_sha224_context_size_type)();
void (*my_sha224_init_type)(void *);
void (*my_sha224_input_type)(void *, const unsigned char *, size_t);
void (*my_sha224_result_type)(void *, unsigned char *);
void (*my_sha256_type)(unsigned char*, const char*, size_t);
void (*my_sha256_multi_type)(unsigned char*, ...);
size_t (*my_sha256_context_size_type)();
void (*my_sha256_init_type)(void *);
void (*my_sha256_input_type)(void *, const unsigned char *, size_t);
void (*my_sha256_result_type)(void *, unsigned char *);
void (*my_sha384_type)(unsigned char*, const char*, size_t);
void (*my_sha384_multi_type)(unsigned char*, ...);
size_t (*my_sha384_context_size_type)();
void (*my_sha384_init_type)(void *);
void (*my_sha384_input_type)(void *, const unsigned char *, size_t);
void (*my_sha384_result_type)(void *, unsigned char *);
void (*my_sha512_type)(unsigned char*, const char*, size_t);
void (*my_sha512_multi_type)(unsigned char*, ...);
size_t (*my_sha512_context_size_type)();
void (*my_sha512_init_type)(void *);
void (*my_sha512_input_type)(void *, const unsigned char *, size_t);
void (*my_sha512_result_type)(void *, unsigned char *);
} *my_sha2_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define my_sha224(A,B,C) my_sha2_service->my_sha224_type(A,B,C)
#define my_sha224_multi my_sha2_service->my_sha224_multi_type
#define my_sha224_context_size() my_sha2_service->my_sha224_context_size_type()
#define my_sha224_init(A) my_sha2_service->my_sha224_init_type(A)
#define my_sha224_input(A,B,C) my_sha2_service->my_sha224_input_type(A,B,C)
#define my_sha224_result(A,B) my_sha2_service->my_sha224_result_type(A,B)
#define my_sha256(A,B,C) my_sha2_service->my_sha256_type(A,B,C)
#define my_sha256_multi my_sha2_service->my_sha256_multi_type
#define my_sha256_context_size() my_sha2_service->my_sha256_context_size_type()
#define my_sha256_init(A) my_sha2_service->my_sha256_init_type(A)
#define my_sha256_input(A,B,C) my_sha2_service->my_sha256_input_type(A,B,C)
#define my_sha256_result(A,B) my_sha2_service->my_sha256_result_type(A,B)
#define my_sha384(A,B,C) my_sha2_service->my_sha384_type(A,B,C)
#define my_sha384_multi my_sha2_service->my_sha384_multi_type
#define my_sha384_context_size() my_sha2_service->my_sha384_context_size_type()
#define my_sha384_init(A) my_sha2_service->my_sha384_init_type(A)
#define my_sha384_input(A,B,C) my_sha2_service->my_sha384_input_type(A,B,C)
#define my_sha384_result(A,B) my_sha2_service->my_sha384_result_type(A,B)
#define my_sha512(A,B,C) my_sha2_service->my_sha512_type(A,B,C)
#define my_sha512_multi my_sha2_service->my_sha512_multi_type
#define my_sha512_context_size() my_sha2_service->my_sha512_context_size_type()
#define my_sha512_init(A) my_sha2_service->my_sha512_init_type(A)
#define my_sha512_input(A,B,C) my_sha2_service->my_sha512_input_type(A,B,C)
#define my_sha512_result(A,B) my_sha2_service->my_sha512_result_type(A,B)
#else
void my_sha224(unsigned char*, const char*, size_t);
void my_sha224_multi(unsigned char*, ...);
size_t my_sha224_context_size();
void my_sha224_init(void *context);
void my_sha224_input(void *context, const unsigned char *buf, size_t len);
void my_sha224_result(void *context, unsigned char *digest);
void my_sha256(unsigned char*, const char*, size_t);
void my_sha256_multi(unsigned char*, ...);
size_t my_sha256_context_size();
void my_sha256_init(void *context);
void my_sha256_input(void *context, const unsigned char *buf, size_t len);
void my_sha256_result(void *context, unsigned char *digest);
void my_sha384(unsigned char*, const char*, size_t);
void my_sha384_multi(unsigned char*, ...);
size_t my_sha384_context_size();
void my_sha384_init(void *context);
void my_sha384_input(void *context, const unsigned char *buf, size_t len);
void my_sha384_result(void *context, unsigned char *digest);
void my_sha512(unsigned char*, const char*, size_t);
void my_sha512_multi(unsigned char*, ...);
size_t my_sha512_context_size();
void my_sha512_init(void *context);
void my_sha512_input(void *context, const unsigned char *buf, size_t len);
void my_sha512_result(void *context, unsigned char *digest);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_SHA2_INCLUDED
#endif
PK ! ɈDn n mysql/service_thd_rnd.hnu [ #ifndef MYSQL_SERVICE_THD_RND_INCLUDED
/* Copyright (C) 2017 MariaDB Corporation
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
This service provides access to the thd-local random number generator.
It's preferable over the global one, because concurrent threads
can generate random numbers without fighting each other over the access
to the shared rnd state.
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MYSQL_ABI_CHECK
#include
#endif
extern struct thd_rnd_service_st {
double (*thd_rnd_ptr)(MYSQL_THD thd);
void (*thd_c_r_p_ptr)(MYSQL_THD thd, char *to, size_t length);
} *thd_rnd_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define thd_rnd(A) thd_rnd_service->thd_rnd_ptr(A)
#define thd_create_random_password(A,B,C) thd_rnd_service->thd_c_r_p_ptr(A,B,C)
#else
double thd_rnd(MYSQL_THD thd);
/**
Generate string of printable random characters of requested length.
@param to[out] Buffer for generation; must be at least length+1 bytes
long; result string is always null-terminated
@param length[in] How many random characters to put in buffer
*/
void thd_create_random_password(MYSQL_THD thd, char *to, size_t length);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_THD_RND_INCLUDED
#endif
PK ! W:
mysql/auth_dialog_client.hnu [ #ifndef MYSQL_AUTH_DIALOG_CLIENT_INCLUDED
/* Copyright (C) 2010 Sergei Golubchik and Monty Program Ab
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
Definitions needed to use Dialog client authentication plugin
*/
struct st_mysql;
#define MYSQL_AUTH_DIALOG_CLIENT_INCLUDED
/**
type of the mysql_authentication_dialog_ask function
@param mysql mysql
@param type type of the input
1 - ordinary string input
2 - password string
@param prompt prompt
@param buf a buffer to store the use input
@param buf_len the length of the buffer
@retval a pointer to the user input string.
It may be equal to 'buf' or to 'mysql->password'.
In all other cases it is assumed to be an allocated
string, and the "dialog" plugin will free() it.
*/
typedef char *(*mysql_authentication_dialog_ask_t)(struct st_mysql *mysql,
int type, const char *prompt, char *buf, int buf_len);
/**
first byte of the question string is the question "type".
It can be an "ordinary" or a "password" question.
The last bit set marks a last question in the authentication exchange.
*/
#define ORDINARY_QUESTION "\2"
#define LAST_QUESTION "\3"
#define PASSWORD_QUESTION "\4"
#define LAST_PASSWORD "\5"
#endif
PK ! [ mysql/client_plugin.hnu [ #ifndef MYSQL_CLIENT_PLUGIN_INCLUDED
/* Copyright (C) 2010 Sergei Golubchik and Monty Program Ab
Copyright (c) 2010, 2011, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
MySQL Client Plugin API
This file defines the API for plugins that work on the client side
*/
#define MYSQL_CLIENT_PLUGIN_INCLUDED
/*
On Windows, exports from DLL need to be declared
Also, plugin needs to be declared as extern "C" because MSVC
unlike other compilers, uses C++ mangling for variables not only
for functions.
*/
#undef MYSQL_PLUGIN_EXPORT
#if defined(_MSC_VER)
#define MYSQL_PLUGIN_EXPORT_C __declspec(dllexport)
#else /*_MSC_VER */
#define MYSQL_PLUGIN_EXPORT_C
#endif
#ifdef __cplusplus
#define MYSQL_PLUGIN_EXPORT extern "C" MYSQL_PLUGIN_EXPORT_C
#define C_MODE_START extern "C" {
#define C_MODE_END }
#else
#define MYSQL_PLUGIN_EXPORT MYSQL_PLUGIN_EXPORT_C
#define C_MODE_START
#define C_MODE_END
#endif
#ifndef MYSQL_ABI_CHECK
#include
#include
#endif
/* known plugin types */
#define MYSQL_CLIENT_reserved1 0
#define MYSQL_CLIENT_reserved2 1
#define MYSQL_CLIENT_AUTHENTICATION_PLUGIN 2
#define MYSQL_CLIENT_AUTHENTICATION_PLUGIN_INTERFACE_VERSION 0x0101
#define MYSQL_CLIENT_MAX_PLUGINS 3
#define mysql_declare_client_plugin(X) \
C_MODE_START MYSQL_PLUGIN_EXPORT_C \
struct st_mysql_client_plugin_ ## X \
_mysql_client_plugin_declaration_ = { \
MYSQL_CLIENT_ ## X ## _PLUGIN, \
MYSQL_CLIENT_ ## X ## _PLUGIN_INTERFACE_VERSION,
#define mysql_end_client_plugin }; C_MODE_END
/* generic plugin header structure */
#define MYSQL_CLIENT_PLUGIN_HEADER \
int type; \
unsigned int interface_version; \
const char *name; \
const char *author; \
const char *desc; \
unsigned int version[3]; \
const char *license; \
void *mysql_api; \
int (*init)(char *, size_t, int, va_list); \
int (*deinit)(); \
int (*options)(const char *option, const void *);
struct st_mysql_client_plugin
{
MYSQL_CLIENT_PLUGIN_HEADER
};
struct st_mysql;
/******** authentication plugin specific declarations *********/
#include
struct st_mysql_client_plugin_AUTHENTICATION
{
MYSQL_CLIENT_PLUGIN_HEADER
int (*authenticate_user)(MYSQL_PLUGIN_VIO *vio, struct st_mysql *mysql);
int (*hash_password_bin)(struct st_mysql *mysql, unsigned char *hash, size_t *hash_length);
};
#include
/******** using plugins ************/
/**
loads a plugin and initializes it
@param mysql MYSQL structure.
@param name a name of the plugin to load
@param type type of plugin that should be loaded, -1 to disable type check
@param argc number of arguments to pass to the plugin initialization
function
@param ... arguments for the plugin initialization function
@retval
a pointer to the loaded plugin, or NULL in case of a failure
*/
struct st_mysql_client_plugin *
mysql_load_plugin(struct st_mysql *mysql, const char *name, int type,
int argc, ...);
/**
loads a plugin and initializes it, taking va_list as an argument
This is the same as mysql_load_plugin, but take va_list instead of
a list of arguments.
@param mysql MYSQL structure.
@param name a name of the plugin to load
@param type type of plugin that should be loaded, -1 to disable type check
@param argc number of arguments to pass to the plugin initialization
function
@param args arguments for the plugin initialization function
@retval
a pointer to the loaded plugin, or NULL in case of a failure
*/
struct st_mysql_client_plugin *
mysql_load_plugin_v(struct st_mysql *mysql, const char *name, int type,
int argc, va_list args);
/**
finds an already loaded plugin by name, or loads it, if necessary
@param mysql MYSQL structure.
@param name a name of the plugin to load
@param type type of plugin that should be loaded
@retval
a pointer to the plugin, or NULL in case of a failure
*/
struct st_mysql_client_plugin *
mysql_client_find_plugin(struct st_mysql *mysql, const char *name, int type);
/**
adds a plugin structure to the list of loaded plugins
This is useful if an application has the necessary functionality
(for example, a special load data handler) statically linked into
the application binary. It can use this function to register the plugin
directly, avoiding the need to factor it out into a shared object.
@param mysql MYSQL structure. It is only used for error reporting
@param plugin an st_mysql_client_plugin structure to register
@retval
a pointer to the plugin, or NULL in case of a failure
*/
struct st_mysql_client_plugin *
mysql_client_register_plugin(struct st_mysql *mysql,
struct st_mysql_client_plugin *plugin);
/**
set plugin options
Can be used to set extra options and affect behavior for a plugin.
This function may be called multiple times to set several options
@param plugin an st_mysql_client_plugin structure
@param option a string which specifies the option to set
@param value value for the option.
@retval 0 on success, 1 in case of failure
**/
int mysql_plugin_options(struct st_mysql_client_plugin *plugin,
const char *option, const void *value);
#endif
PK ! 6T T " mysql/plugin_password_validation.hnu [ #ifndef MYSQL_PLUGIN_PASSWORD_VALIDATION_INCLUDED
/* Copyright (C) 2014 Sergei Golubchik and MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
Password Validation Plugin API.
This file defines the API for server password validation plugins.
*/
#define MYSQL_PLUGIN_PASSWORD_VALIDATION_INCLUDED
#include
#ifdef __cplusplus
extern "C" {
#endif
#define MariaDB_PASSWORD_VALIDATION_INTERFACE_VERSION 0x0101
/**
Password validation plugin descriptor
*/
struct st_mariadb_password_validation
{
int interface_version; /**< version plugin uses */
/**
Function provided by the plugin which should perform password validation
and return 0 if the password has passed the validation.
*/
int (*validate_password)(const MYSQL_CONST_LEX_STRING *username,
const MYSQL_CONST_LEX_STRING *password,
const MYSQL_CONST_LEX_STRING *hostname);
};
#ifdef __cplusplus
}
#endif
#endif
PK ! Q8`
`
! mysql/service_thd_error_context.hnu [ #ifndef MYSQL_SERVICE_THD_STMT_DA_INCLUDED
/* Copyright (C) 2013 MariaDB Foundation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
This service provides access to the statement diagnostics area:
- error message
- error number
- row for warning (e.g. for multi-row INSERT statements)
*/
#ifdef __cplusplus
extern "C" {
#endif
extern struct thd_error_context_service_st {
const char *(*thd_get_error_message_func)(const MYSQL_THD thd);
unsigned int (*thd_get_error_number_func)(const MYSQL_THD thd);
unsigned long (*thd_get_error_row_func)(const MYSQL_THD thd);
void (*thd_inc_error_row_func)(MYSQL_THD thd);
char *(*thd_get_error_context_description_func)(MYSQL_THD thd,
char *buffer,
unsigned int length,
unsigned int max_query_length);
} *thd_error_context_service;
#ifdef MYSQL_DYNAMIC_PLUGIN
#define thd_get_error_message(thd) \
(thd_error_context_service->thd_get_error_message_func((thd)))
#define thd_get_error_number(thd) \
(thd_error_context_service->thd_get_error_number_func((thd)))
#define thd_get_error_row(thd) \
(thd_error_context_service->thd_get_error_row_func((thd)))
#define thd_inc_error_row(thd) \
(thd_error_context_service->thd_inc_error_row_func((thd)))
#define thd_get_error_context_description(thd, buffer, length, max_query_len) \
(thd_error_context_service->thd_get_error_context_description_func((thd), \
(buffer), \
(length), \
(max_query_len)))
#else
/**
Return error message
@param thd user thread connection handle
@return error text
*/
const char *thd_get_error_message(const MYSQL_THD thd);
/**
Return error number
@param thd user thread connection handle
@return error number
*/
unsigned int thd_get_error_number(const MYSQL_THD thd);
/**
Return the current row number (i.e. in a multiple INSERT statement)
@param thd user thread connection handle
@return row number
*/
unsigned long thd_get_error_row(const MYSQL_THD thd);
/**
Increment the current row number
@param thd user thread connection handle
*/
void thd_inc_error_row(MYSQL_THD thd);
/**
Return a text description of a thread, its security context (user,host)
and the current query.
*/
char *thd_get_error_context_description(MYSQL_THD thd,
char *buffer, unsigned int length,
unsigned int max_query_length);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_THD_STMT_DA_INCLUDED
#endif
PK ! d
f f mysql/service_thd_specifics.hnu [ #ifndef MYSQL_SERVICE_THD_SPECIFICS_INCLUDED
/* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
THD specific for plugin(s)
This API provides pthread_getspecific like functionality to plugin authors.
This is a functional alternative to the declarative MYSQL_THDVAR
A plugin should at init call thd_key_create that create a key that
will have storage in each THD. The key should be used by all threads
and can be used concurrently from all threads.
A plugin should at deinit call thd_key_delete.
Alternatively, a plugin can use thd_key_create_from_var(K,V) to create
a key that corresponds to a named MYSQL_THDVAR variable.
This API is also safe when using pool-of-threads in which case
pthread_getspecific is not, because the actual OS thread may change.
@note
Normally one should prefer MYSQL_THDVAR declarative API.
The benefits are:
- It supports typed variables (int, char*, enum, etc), not only void*.
- The memory allocated for MYSQL_THDVAR is free'd automatically
(if PLUGIN_VAR_MEMALLOC is specified).
- Continuous loading and unloading of the same plugin does not allocate
memory for same variables over and over again.
An example of using MYSQL_THDVAR for a thd local storage:
MYSQL_THDVAR_STR(my_tls,
PLUGIN_VAR_MEMALLOC | PLUGIN_VAR_NOSYSVAR | PLUGIN_VAR_NOCMDOPT,
"thd local storage example", 0, 0, 0);
*/
#ifdef __cplusplus
extern "C" {
#endif
typedef int MYSQL_THD_KEY_T;
extern struct thd_specifics_service_st {
int (*thd_key_create_func)(MYSQL_THD_KEY_T *key);
void (*thd_key_delete_func)(MYSQL_THD_KEY_T *key);
void *(*thd_getspecific_func)(MYSQL_THD thd, MYSQL_THD_KEY_T key);
int (*thd_setspecific_func)(MYSQL_THD thd, MYSQL_THD_KEY_T key, void *value);
} *thd_specifics_service;
#define thd_key_create_from_var(K, V) do { *(K)= MYSQL_SYSVAR_NAME(V).offset; } while(0)
#ifdef MYSQL_DYNAMIC_PLUGIN
#define thd_key_create(K) (thd_specifics_service->thd_key_create_func(K))
#define thd_key_delete(K) (thd_specifics_service->thd_key_delete_func(K))
#define thd_getspecific(T, K) (thd_specifics_service->thd_getspecific_func(T, K))
#define thd_setspecific(T, K, V) (thd_specifics_service->thd_setspecific_func(T, K, V))
#else
/**
* create THD specific storage
* @return 0 on success
* else errno is returned
*/
int thd_key_create(MYSQL_THD_KEY_T *key);
/**
* delete THD specific storage
*/
void thd_key_delete(MYSQL_THD_KEY_T *key);
/**
* get/set thd specific storage
* - first time this is called from a thread it will return 0
* - this call is thread-safe in that different threads may call this
* simultaneously if operating on different THDs.
* - this call acquires no mutexes and is implemented as an array lookup
*/
void* thd_getspecific(MYSQL_THD thd, MYSQL_THD_KEY_T key);
int thd_setspecific(MYSQL_THD thd, MYSQL_THD_KEY_T key, void *value);
#endif
#ifdef __cplusplus
}
#endif
#define MYSQL_SERVICE_THD_SPECIFICS_INCLUDED
#endif
PK ! H^ mysql/plugin_auth_common.hnu [ #ifndef MYSQL_PLUGIN_AUTH_COMMON_INCLUDED
/* Copyright (C) 2010 Sergei Golubchik and Monty Program Ab
Copyright (c) 2010, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifdef _WIN32
#include
#endif
/**
@file
This file defines constants and data structures that are the same for
both client- and server-side authentication plugins.
*/
#define MYSQL_PLUGIN_AUTH_COMMON_INCLUDED
/** the max allowed length for a user name */
#define MYSQL_USERNAME_LENGTH 512
/**
return values of the plugin authenticate_user() method.
*/
/**
Authentication failed, plugin internal error.
An error occurred in the authentication plugin itself.
These errors are reported in table performance_schema.host_cache,
column COUNT_AUTH_PLUGIN_ERRORS.
*/
#define CR_AUTH_PLUGIN_ERROR 3
/**
Authentication failed, client server handshake.
An error occurred during the client server handshake.
These errors are reported in table performance_schema.host_cache,
column COUNT_HANDSHAKE_ERRORS.
*/
#define CR_AUTH_HANDSHAKE 2
/**
Authentication failed, user credentials.
For example, wrong passwords.
These errors are reported in table performance_schema.host_cache,
column COUNT_AUTHENTICATION_ERRORS.
*/
#define CR_AUTH_USER_CREDENTIALS 1
/**
Authentication failed. Additionally, all other CR_xxx values
(libmysql error code) can be used too.
The client plugin may set the error code and the error message directly
in the MYSQL structure and return CR_ERROR. If a CR_xxx specific error
code was returned, an error message in the MYSQL structure will be
overwritten. If CR_ERROR is returned without setting the error in MYSQL,
CR_UNKNOWN_ERROR will be user.
*/
#define CR_ERROR 0
/**
Authentication (client part) was successful. It does not mean that the
authentication as a whole was successful, usually it only means
that the client was able to send the user name and the password to the
server. If CR_OK is returned, the libmysql reads the next packet expecting
it to be one of OK, ERROR, or CHANGE_PLUGIN packets.
*/
#define CR_OK -1
/**
Authentication was successful.
It means that the client has done its part successfully and also that
a plugin has read the last packet (one of OK, ERROR, CHANGE_PLUGIN).
In this case, libmysql will not read a packet from the server,
but it will use the data at mysql->net.read_pos.
A plugin may return this value if the number of roundtrips in the
authentication protocol is not known in advance, and the client plugin
needs to read one packet more to determine if the authentication is finished
or not.
Server plugins should not return this value.
*/
#define CR_OK_HANDSHAKE_COMPLETE -2
typedef struct st_plugin_vio_info
{
enum { MYSQL_VIO_INVALID, MYSQL_VIO_TCP, MYSQL_VIO_SOCKET,
MYSQL_VIO_PIPE, MYSQL_VIO_MEMORY } protocol;
int socket; /**< it's set, if the protocol is SOCKET or TCP */
#ifdef _WIN32
HANDLE handle; /**< it's set, if the protocol is PIPE or MEMORY */
#endif
int tls;
} MYSQL_PLUGIN_VIO_INFO;
/**
Provides plugin access to communication channel
*/
typedef struct st_plugin_vio
{
/**
Plugin provides a pointer reference and this function sets it to the
contents of any incoming packet. Returns the packet length, or -1 if
the plugin should terminate.
*/
int (*read_packet)(struct st_plugin_vio *vio,
unsigned char **buf);
/**
Plugin provides a buffer with data and the length and this
function sends it as a packet. Returns 0 on success, 1 on failure.
*/
int (*write_packet)(struct st_plugin_vio *vio,
const unsigned char *packet,
int packet_len);
/**
Fills in a st_plugin_vio_info structure, providing the information
about the connection.
*/
void (*info)(struct st_plugin_vio *vio, struct st_plugin_vio_info *info);
} MYSQL_PLUGIN_VIO;
#endif
PK ! ̯N7 N7 mysql/service_wsrep.hnu [ #ifndef MYSQL_SERVICE_WSREP_INCLUDED
#define MYSQL_SERVICE_WSREP_INCLUDED
enum Wsrep_service_key_type
{
WSREP_SERVICE_KEY_SHARED,
WSREP_SERVICE_KEY_REFERENCE,
WSREP_SERVICE_KEY_UPDATE,
WSREP_SERVICE_KEY_EXCLUSIVE
};
#if (defined (MYSQL_DYNAMIC_PLUGIN) && defined(MYSQL_SERVICE_WSREP_DYNAMIC_INCLUDED)) || (!defined(MYSQL_DYNAMIC_PLUGIN) && defined(MYSQL_SERVICE_WSREP_STATIC_INCLUDED))
#else
/* Copyright (c) 2015, 2020, MariaDB Corporation Ab
2018 Codership Oy
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
wsrep service
Interface to WSREP functionality in the server.
For engines that want to support galera.
*/
#include
#ifdef __cplusplus
#endif
struct xid_t;
struct wsrep_ws_handle;
struct wsrep_buf;
/* Must match to definition in sql/mysqld.h */
typedef int64 query_id_t;
extern struct wsrep_service_st {
my_bool (*get_wsrep_recovery_func)();
bool (*wsrep_consistency_check_func)(MYSQL_THD thd);
int (*wsrep_is_wsrep_xid_func)(const void *xid);
long long (*wsrep_xid_seqno_func)(const struct xid_t *xid);
const unsigned char* (*wsrep_xid_uuid_func)(const struct xid_t *xid);
my_bool (*wsrep_on_func)(const MYSQL_THD thd);
bool (*wsrep_prepare_key_for_innodb_func)(MYSQL_THD thd, const unsigned char*, size_t, const unsigned char*, size_t, struct wsrep_buf*, size_t*);
void (*wsrep_thd_LOCK_func)(const MYSQL_THD thd);
int (*wsrep_thd_TRYLOCK_func)(const MYSQL_THD thd);
void (*wsrep_thd_UNLOCK_func)(const MYSQL_THD thd);
const char * (*wsrep_thd_query_func)(const MYSQL_THD thd);
int (*wsrep_thd_retry_counter_func)(const MYSQL_THD thd);
bool (*wsrep_thd_ignore_table_func)(MYSQL_THD thd);
long long (*wsrep_thd_trx_seqno_func)(const MYSQL_THD thd);
my_bool (*wsrep_thd_is_aborting_func)(const MYSQL_THD thd);
void (*wsrep_set_data_home_dir_func)(const char *data_dir);
my_bool (*wsrep_thd_is_BF_func)(const MYSQL_THD thd, my_bool sync);
my_bool (*wsrep_thd_is_local_func)(const MYSQL_THD thd);
void (*wsrep_thd_self_abort_func)(MYSQL_THD thd);
int (*wsrep_thd_append_key_func)(MYSQL_THD thd, const struct wsrep_key* key,
int n_keys, enum Wsrep_service_key_type);
int (*wsrep_thd_append_table_key_func)(MYSQL_THD thd, const char* db,
const char* table, enum Wsrep_service_key_type);
my_bool (*wsrep_thd_is_local_transaction)(const MYSQL_THD thd);
const char* (*wsrep_thd_client_state_str_func)(const MYSQL_THD thd);
const char* (*wsrep_thd_client_mode_str_func)(const MYSQL_THD thd);
const char* (*wsrep_thd_transaction_state_str_func)(const MYSQL_THD thd);
query_id_t (*wsrep_thd_transaction_id_func)(const MYSQL_THD thd);
my_bool (*wsrep_thd_bf_abort_func)(MYSQL_THD bf_thd,
MYSQL_THD victim_thd,
my_bool signal);
my_bool (*wsrep_thd_order_before_func)(const MYSQL_THD left, const MYSQL_THD right);
void (*wsrep_handle_SR_rollback_func)(MYSQL_THD BF_thd, MYSQL_THD victim_thd);
my_bool (*wsrep_thd_skip_locking_func)(const MYSQL_THD thd);
const char* (*wsrep_get_sr_table_name_func)();
my_bool (*wsrep_get_debug_func)();
void (*wsrep_commit_ordered_func)(MYSQL_THD thd);
my_bool (*wsrep_thd_is_applying_func)(const MYSQL_THD thd);
ulong (*wsrep_OSU_method_get_func)(const MYSQL_THD thd);
my_bool (*wsrep_thd_has_ignored_error_func)(const MYSQL_THD thd);
void (*wsrep_thd_set_ignored_error_func)(MYSQL_THD thd, my_bool val);
void (*wsrep_report_bf_lock_wait_func)(const MYSQL_THD thd,
unsigned long long trx_id);
void (*wsrep_thd_kill_LOCK_func)(const MYSQL_THD thd);
void (*wsrep_thd_kill_UNLOCK_func)(const MYSQL_THD thd);
void (*wsrep_thd_set_wsrep_PA_unsafe_func)(MYSQL_THD thd);
uint32 (*wsrep_get_domain_id_func)();
} *wsrep_service;
#define MYSQL_SERVICE_WSREP_INCLUDED
#endif
#ifdef MYSQL_DYNAMIC_PLUGIN
#define MYSQL_SERVICE_WSREP_DYNAMIC_INCLUDED
#define get_wsrep_recovery() wsrep_service->get_wsrep_recovery_func()
#define wsrep_consistency_check(T) wsrep_service->wsrep_consistency_check_func(T)
#define wsrep_is_wsrep_xid(X) wsrep_service->wsrep_is_wsrep_xid_func(X)
#define wsrep_xid_seqno(X) wsrep_service->wsrep_xid_seqno_func(X)
#define wsrep_xid_uuid(X) wsrep_service->wsrep_xid_uuid_func(X)
#define wsrep_on(thd) (thd) && WSREP_ON && wsrep_service->wsrep_on_func(thd)
#define wsrep_prepare_key_for_innodb(A,B,C,D,E,F,G) wsrep_service->wsrep_prepare_key_for_innodb_func(A,B,C,D,E,F,G)
#define wsrep_thd_LOCK(T) wsrep_service->wsrep_thd_LOCK_func(T)
#define wsrep_thd_TRYLOCK(T) wsrep_service->wsrep_thd_TRYLOCK_func(T)
#define wsrep_thd_UNLOCK(T) wsrep_service->wsrep_thd_UNLOCK_func(T)
#define wsrep_thd_kill_LOCK(T) wsrep_service->wsrep_thd_kill_LOCK_func(T)
#define wsrep_thd_kill_UNLOCK(T) wsrep_service->wsrep_thd_kill_UNLOCK_func(T)
#define wsrep_thd_query(T) wsrep_service->wsrep_thd_query_func(T)
#define wsrep_thd_retry_counter(T) wsrep_service->wsrep_thd_retry_counter_func(T)
#define wsrep_thd_ignore_table(T) wsrep_service->wsrep_thd_ignore_table_func(T)
#define wsrep_thd_trx_seqno(T) wsrep_service->wsrep_thd_trx_seqno_func(T)
#define wsrep_set_data_home_dir(A) wsrep_service->wsrep_set_data_home_dir_func(A)
#define wsrep_thd_is_BF(T,S) wsrep_service->wsrep_thd_is_BF_func(T,S)
#define wsrep_thd_is_aborting(T) wsrep_service->wsrep_thd_is_aborting_func(T)
#define wsrep_thd_is_local(T) wsrep_service->wsrep_thd_is_local_func(T)
#define wsrep_thd_self_abort(T) wsrep_service->wsrep_thd_self_abort_func(T)
#define wsrep_thd_append_key(T,W,N,K) wsrep_service->wsrep_thd_append_key_func(T,W,N,K)
#define wsrep_thd_append_table_key(T,D,B,K) wsrep_service->wsrep_thd_append_table_key_func(T,D,B,K)
#define wsrep_thd_is_local_transaction(T) wsrep_service->wsrep_thd_is_local_transaction_func(T)
#define wsrep_thd_client_state_str(T) wsrep_service->wsrep_thd_client_state_str_func(T)
#define wsrep_thd_client_mode_str(T) wsrep_service->wsrep_thd_client_mode_str_func(T)
#define wsrep_thd_transaction_state_str(T) wsrep_service->wsrep_thd_transaction_state_str_func(T)
#define wsrep_thd_transaction_id(T) wsrep_service->wsrep_thd_transaction_id_func(T)
#define wsrep_thd_bf_abort(T,T2,S) wsrep_service->wsrep_thd_bf_abort_func(T,T2,S)
#define wsrep_thd_order_before(L,R) wsrep_service->wsrep_thd_order_before_func(L,R)
#define wsrep_handle_SR_rollback(B,V) wsrep_service->wsrep_handle_SR_rollback_func(B,V)
#define wsrep_thd_skip_locking(T) wsrep_service->wsrep_thd_skip_locking_func(T)
#define wsrep_get_sr_table_name() wsrep_service->wsrep_get_sr_table_name_func()
#define wsrep_get_debug() wsrep_service->wsrep_get_debug_func()
#define wsrep_commit_ordered(T) wsrep_service->wsrep_commit_ordered_func(T)
#define wsrep_thd_is_applying(T) wsrep_service->wsrep_thd_is_applying_func(T)
#define wsrep_OSU_method_get(T) wsrep_service->wsrep_OSU_method_get_func(T)
#define wsrep_thd_has_ignored_error(T) wsrep_service->wsrep_thd_has_ignored_error_func(T)
#define wsrep_thd_set_ignored_error(T,V) wsrep_service->wsrep_thd_set_ignored_error_func(T,V)
#define wsrep_report_bf_lock_wait(T,I) wsrep_service->wsrep_report_bf_lock_wait(T,I)
#define wsrep_thd_set_PA_unsafe(T) wsrep_service->wsrep_thd_set_PA_unsafe_func(T)
#define wsrep_get_domain_id(T) wsrep_service->wsrep_get_domain_id_func(T)
#else
#define MYSQL_SERVICE_WSREP_STATIC_INCLUDED
extern ulong wsrep_debug;
extern my_bool wsrep_log_conflicts;
extern my_bool wsrep_certify_nonPK;
extern my_bool wsrep_load_data_splitting;
extern my_bool wsrep_drupal_282555_workaround;
extern my_bool wsrep_recovery;
extern long wsrep_protocol_version;
extern "C" bool wsrep_consistency_check(MYSQL_THD thd);
bool wsrep_prepare_key_for_innodb(MYSQL_THD thd, const unsigned char* cache_key, size_t cache_key_len, const unsigned char* row_id, size_t row_id_len, struct wsrep_buf* key, size_t* key_len);
extern "C" const char *wsrep_thd_query(const MYSQL_THD thd);
extern "C" int wsrep_is_wsrep_xid(const void* xid);
extern "C" long long wsrep_xid_seqno(const struct xid_t* xid);
const unsigned char* wsrep_xid_uuid(const struct xid_t* xid);
extern "C" long long wsrep_thd_trx_seqno(const MYSQL_THD thd);
my_bool get_wsrep_recovery();
bool wsrep_thd_ignore_table(MYSQL_THD thd);
void wsrep_set_data_home_dir(const char *data_dir);
/* from mysql wsrep-lib */
#include "my_global.h"
#include "my_pthread.h"
/* Return true if wsrep is enabled for a thd. This means that
wsrep is enabled globally and the thd has wsrep on */
extern "C" my_bool wsrep_on(const MYSQL_THD thd);
/* Lock thd wsrep lock */
extern "C" void wsrep_thd_LOCK(const MYSQL_THD thd);
/* Try thd wsrep lock. Return non-zero if lock could not be taken. */
extern "C" int wsrep_thd_TRYLOCK(const MYSQL_THD thd);
/* Unlock thd wsrep lock */
extern "C" void wsrep_thd_UNLOCK(const MYSQL_THD thd);
extern "C" void wsrep_thd_kill_LOCK(const MYSQL_THD thd);
extern "C" void wsrep_thd_kill_UNLOCK(const MYSQL_THD thd);
/* Return thd client state string */
extern "C" const char* wsrep_thd_client_state_str(const MYSQL_THD thd);
/* Return thd client mode string */
extern "C" const char* wsrep_thd_client_mode_str(const MYSQL_THD thd);
/* Return thd transaction state string */
extern "C" const char* wsrep_thd_transaction_state_str(const MYSQL_THD thd);
/* Return current transaction id */
extern "C" query_id_t wsrep_thd_transaction_id(const MYSQL_THD thd);
/* Mark thd own transaction as aborted */
extern "C" void wsrep_thd_self_abort(MYSQL_THD thd);
/* Return true if thd is in replicating mode */
extern "C" my_bool wsrep_thd_is_local(const MYSQL_THD thd);
/* Return true if thd is in high priority mode */
/* todo: rename to is_high_priority() */
extern "C" my_bool wsrep_thd_is_applying(const MYSQL_THD thd);
/* Return true if thd is in TOI mode */
extern "C" my_bool wsrep_thd_is_toi(const MYSQL_THD thd);
/* Return true if thd is in replicating TOI mode */
extern "C" my_bool wsrep_thd_is_local_toi(const MYSQL_THD thd);
/* Return true if thd is in RSU mode */
extern "C" my_bool wsrep_thd_is_in_rsu(const MYSQL_THD thd);
/* Return true if thd is in BF mode, either high_priority or TOI */
extern "C" my_bool wsrep_thd_is_BF(const MYSQL_THD thd, my_bool sync);
/* Return true if thd is streaming in progress */
extern "C" my_bool wsrep_thd_is_SR(const MYSQL_THD thd);
extern "C" void wsrep_handle_SR_rollback(MYSQL_THD BF_thd, MYSQL_THD victim_thd);
/* Return thd retry counter */
extern "C" int wsrep_thd_retry_counter(const MYSQL_THD thd);
/* BF abort victim_thd */
extern "C" my_bool wsrep_thd_bf_abort(MYSQL_THD bf_thd,
MYSQL_THD victim_thd,
my_bool signal);
/* Return true if left thd is ordered before right thd */
extern "C" my_bool wsrep_thd_order_before(const MYSQL_THD left, const MYSQL_THD right);
/* Return true if thd should skip locking. This means that the thd
is operating on shared resource inside commit order critical section. */
extern "C" my_bool wsrep_thd_skip_locking(const MYSQL_THD thd);
/* Return true if thd is aborting */
extern "C" my_bool wsrep_thd_is_aborting(const MYSQL_THD thd);
struct wsrep_key;
struct wsrep_key_array;
extern "C" int wsrep_thd_append_key(MYSQL_THD thd,
const struct wsrep_key* key,
int n_keys,
enum Wsrep_service_key_type);
extern "C" int wsrep_thd_append_table_key(MYSQL_THD thd,
const char* db,
const char* table,
enum Wsrep_service_key_type);
extern "C" my_bool wsrep_thd_is_local_transaction(const MYSQL_THD thd);
extern const char* wsrep_sr_table_name_full;
extern "C" const char* wsrep_get_sr_table_name();
extern "C" my_bool wsrep_get_debug();
extern "C" void wsrep_commit_ordered(MYSQL_THD thd);
extern "C" my_bool wsrep_thd_is_applying(const MYSQL_THD thd);
extern "C" ulong wsrep_OSU_method_get(const MYSQL_THD thd);
extern "C" my_bool wsrep_thd_has_ignored_error(const MYSQL_THD thd);
extern "C" void wsrep_thd_set_ignored_error(MYSQL_THD thd, my_bool val);
extern "C" void wsrep_report_bf_lock_wait(const THD *thd,
unsigned long long trx_id);
/* declare parallel applying unsafety for the THD */
extern "C" void wsrep_thd_set_PA_unsafe(MYSQL_THD thd);
extern "C" uint32 wsrep_get_domain_id();
#endif
#endif /* MYSQL_SERVICE_WSREP_INCLUDED */
PK ! T mysql/plugin_function.hnu [ #ifndef MARIADB_PLUGIN_FUNCTION_INCLUDED
#define MARIADB_PLUGIN_FUNCTION_INCLUDED
/* Copyright (C) 2019, Alexander Barkov and MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
Function Plugin API.
This file defines the API for server plugins that manage functions.
*/
#ifdef __cplusplus
#include
/*
API for function plugins. (MariaDB_FUNCTION_PLUGIN)
*/
#define MariaDB_FUNCTION_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
class Plugin_function
{
int m_interface_version;
Create_func *m_builder;
public:
Plugin_function(Create_func *builder)
:m_interface_version(MariaDB_FUNCTION_INTERFACE_VERSION),
m_builder(builder)
{ }
Create_func *create_func()
{
return m_builder;
}
};
#endif /* __cplusplus */
#endif /* MARIADB_PLUGIN_FUNCTION_INCLUDED */
PK ! (Y
my_compiler.hnu [ #ifndef MY_COMPILER_INCLUDED
#define MY_COMPILER_INCLUDED
/* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
Copyright (c) 2017, 2022, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
Header for compiler-dependent features.
Intended to contain a set of reusable wrappers for preprocessor
macros, attributes, pragmas, and any other features that are
specific to a target compiler.
*/
/**
Compiler-dependent internal convenience macros.
*/
/* C vs C++ */
#ifdef __cplusplus
#define CONSTEXPR constexpr
#else
#define CONSTEXPR
#endif /* __cplusplus */
/* GNU C/C++ */
#if defined __GNUC__
# define MY_ALIGN_EXT
/*
__builtin_unreachable() removes the "statement may fall through" warning-as-
error when MY_ASSERT_UNREACHABLE() is used in "case xxx:" in switch (...)
statements.
abort() is there to prevent the execution from reaching the
__builtin_unreachable() as this may cause misleading stack traces.
*/
# define MY_ASSERT_UNREACHABLE() { abort(); __builtin_unreachable(); }
/* Microsoft Visual C++ */
#elif defined _MSC_VER
# define MY_ALIGNOF(type) __alignof(type)
# define MY_ALIGNED(n) __declspec(align(n))
/* Oracle Solaris Studio */
#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC)
# if __SUNPRO_C >= 0x590
# define MY_ALIGN_EXT
# endif
/* IBM XL C/C++ */
#elif defined __xlC__
# if __xlC__ >= 0x0600
# define MY_ALIGN_EXT
# endif
/* HP aCC */
#elif defined(__HP_aCC) || defined(__HP_cc)
# if (__HP_aCC >= 60000) || (__HP_cc >= 60000)
# define MY_ALIGN_EXT
# endif
#endif
#ifdef MY_ALIGN_EXT
/** Specifies the minimum alignment of a type. */
# define MY_ALIGNOF(type) __alignof__(type)
/** Determine the alignment requirement of a type. */
# define MY_ALIGNED(n) __attribute__((__aligned__((n))))
#endif
/**
Generic (compiler-independent) features.
*/
#ifndef MY_ALIGNOF
# ifdef __cplusplus
template struct my_alignof_helper { char m1; type m2; };
/* Invalid for non-POD types, but most compilers give the right answer. */
# define MY_ALIGNOF(type) offsetof(my_alignof_helper, m2)
# else
# define MY_ALIGNOF(type) offsetof(struct { char m1; type m2; }, m2)
# endif
#endif
#ifndef MY_ASSERT_UNREACHABLE
# define MY_ASSERT_UNREACHABLE() do { abort(); } while (0)
#endif
/**
C++ Type Traits
*/
#ifdef __cplusplus
/**
Opaque storage with a particular alignment.
*/
# if defined(MY_ALIGNED)
/* Partial specialization used due to MSVC++. */
template struct my_alignment_imp;
template<> struct MY_ALIGNED(1) my_alignment_imp<1> {};
template<> struct MY_ALIGNED(2) my_alignment_imp<2> {};
template<> struct MY_ALIGNED(4) my_alignment_imp<4> {};
template<> struct MY_ALIGNED(8) my_alignment_imp<8> {};
template<> struct MY_ALIGNED(16) my_alignment_imp<16> {};
/* ... expand as necessary. */
# else
template
struct my_alignment_imp { double m1; };
# endif
/**
A POD type with a given size and alignment.
@remark If the compiler does not support a alignment attribute
(MY_ALIGN macro), the default alignment of a double is
used instead.
@tparam size The minimum size.
@tparam alignment The desired alignment: 1, 2, 4, 8 or 16.
*/
template
struct my_aligned_storage
{
union
{
char data[size];
my_alignment_imp align;
};
};
#endif /* __cplusplus */
# ifndef MY_ALIGNED
/*
Make sure MY_ALIGNED can be used also on platforms where we don't
have a way of aligning data structures.
*/
#define MY_ALIGNED(size)
#endif
#ifdef __GNUC__
# define ATTRIBUTE_NORETURN __attribute__((noreturn))
# define ATTRIBUTE_NOINLINE __attribute__((noinline))
/** Starting with GCC 4.3, the "cold" attribute is used to inform the
compiler that a function is unlikely executed. The function is
optimized for size rather than speed and on many targets it is placed
into special subsection of the text section so all cold functions
appears close together improving code locality of non-cold parts of
program. The paths leading to call of cold functions within code are
marked as unlikely by the branch prediction mechanism. optimize a
rarely invoked function for size instead for speed. */
# define ATTRIBUTE_COLD __attribute__((cold))
# define ATTRIBUTE_MALLOC __attribute__((malloc))
#elif defined _MSC_VER
# define ATTRIBUTE_NORETURN __declspec(noreturn)
# define ATTRIBUTE_NOINLINE __declspec(noinline)
#else
# define ATTRIBUTE_NORETURN /* empty */
# define ATTRIBUTE_NOINLINE /* empty */
#endif
#ifndef ATTRIBUTE_COLD
# define ATTRIBUTE_COLD /* empty */
#endif
#ifndef ATTRIBUTE_MALLOC
# define ATTRIBUTE_MALLOC
#endif
#include
#endif /* MY_COMPILER_INCLUDED */
PK ! gU|%.( .(
m_string.hnu [ /*
Copyright (c) 2000, 2012, Oracle and/or its affiliates.
Copyright (c) 2019, 2021, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/* There may be problems included in all of these. Try to test in
configure which ones are needed? */
/* This is needed for the definitions of strchr... on solaris */
#ifndef _m_string_h
#define _m_string_h
#include "my_decimal_limits.h"
#ifndef __USE_GNU
#define __USE_GNU /* We want to use stpcpy */
#endif
#if defined(HAVE_STRINGS_H)
#include
#endif
#if defined(HAVE_STRING_H)
#include
#endif
/* This is needed for the definitions of memcpy... on solaris */
#if defined(HAVE_MEMORY_H) && !defined(__cplusplus)
#include
#endif
#if !defined(HAVE_MEMCPY) && !defined(HAVE_MEMMOVE)
# define memcpy(d, s, n) bcopy ((s), (d), (n))
# define memset(A,C,B) bfill((A),(B),(C))
# define memmove(d, s, n) bmove ((d), (s), (n))
#elif defined(HAVE_MEMMOVE)
# define bmove(d, s, n) memmove((d), (s), (n))
#endif
/* Unixware 7 */
#if !defined(HAVE_BFILL)
# define bfill(A,B,C) memset((A),(C),(B))
#endif
# define bmove_align(A,B,C) memcpy((A),(B),(C))
# define bcmp(A,B,C) memcmp((A),(B),(C))
#if !defined(bzero)
# define bzero(A,B) memset((A),0,(B))
#endif
#if defined(__cplusplus)
extern "C" {
#endif
#ifdef DBUG_OFF
#if defined(HAVE_STPCPY) && defined(__GNUC__) && !defined(__INTEL_COMPILER)
#define strmov(A,B) __builtin_stpcpy((A),(B))
#elif defined(HAVE_STPCPY)
#define strmov(A,B) stpcpy((A),(B))
#endif
#endif
/* Declared in int2str() */
extern const char _dig_vec_base62[];
extern const char _dig_vec_upper[];
extern const char _dig_vec_lower[];
extern char *strmov_overlapp(char *dest, const char *src);
/* Prototypes for string functions */
extern void bmove_upp(uchar *dst,const uchar *src,size_t len);
extern void bchange(uchar *dst,size_t old_len,const uchar *src,
size_t new_len,size_t tot_len);
extern void strappend(char *s,size_t len,pchar fill);
extern char *strend(const char *s);
extern char *strcend(const char *, pchar);
extern char *strfill(char * s,size_t len,pchar fill);
extern char *strmake(char *dst,const char *src,size_t length);
#if !defined(__GNUC__) || (__GNUC__ < 4)
#define strmake_buf(D,S) strmake(D, S, sizeof(D) - 1)
#else
#define strmake_buf(D,S) ({ \
__typeof__ (D) __x __attribute__((unused)) = { 2 }; \
strmake(D, S, sizeof(D) - 1); \
})
#endif
#ifndef strmov
extern char *strmov(char *dst,const char *src);
#endif
extern char *strnmov(char *dst, const char *src, size_t n);
extern char *strcont(const char *src, const char *set);
extern char *strxmov(char *dst, const char *src, ...);
extern char *strxnmov(char *dst, size_t len, const char *src, ...);
/* Prototypes of normal stringfunctions (with may ours) */
#ifndef HAVE_STRNLEN
extern size_t strnlen(const char *s, size_t n);
#endif
extern int is_prefix(const char *, const char *);
/* Conversion routines */
typedef enum {
MY_GCVT_ARG_FLOAT,
MY_GCVT_ARG_DOUBLE
} my_gcvt_arg_type;
double my_strtod(const char *str, char **end, int *error);
double my_atof(const char *nptr);
size_t my_fcvt(double x, int precision, char *to, my_bool *error);
size_t my_gcvt(double x, my_gcvt_arg_type type, int width, char *to,
my_bool *error);
/*
The longest string my_fcvt can return is 311 + "precision" bytes.
Here we assume that we never cal my_fcvt() with
precision >= DECIMAL_NOT_SPECIFIED
(+ 1 byte for the terminating '\0').
*/
#define FLOATING_POINT_BUFFER (311 + DECIMAL_NOT_SPECIFIED)
/*
We want to use the 'e' format in some cases even if we have enough space
for the 'f' one just to mimic sprintf("%.15g") behavior for large integers,
and to improve it for numbers < 10^(-4).
That is, for |x| < 1 we require |x| >= 10^(-15), and for |x| > 1 we require
it to be integer and be <= 10^DBL_DIG for the 'f' format to be used.
We don't lose precision, but make cases like "1e200" or "0.00001" look nicer.
*/
#define MAX_DECPT_FOR_F_FORMAT DBL_DIG
/*
The maximum possible field width for my_gcvt() conversion.
(DBL_DIG + 2) significant digits + sign + "." + ("e-NNN" or
MAX_DECPT_FOR_F_FORMAT zeros for cases when |x|<1 and the 'f' format is used).
*/
#define MY_GCVT_MAX_FIELD_WIDTH (DBL_DIG + 4 + MY_MAX(5, MAX_DECPT_FOR_F_FORMAT)) \
extern char *llstr(longlong value,char *buff);
extern char *ullstr(longlong value,char *buff);
#ifndef HAVE_STRTOUL
extern long strtol(const char *str, char **ptr, int base);
extern ulong strtoul(const char *str, char **ptr, int base);
#endif
extern char *int2str(long val, char *dst, int radix, int upcase);
extern char *int10_to_str(long val,char *dst,int radix);
extern char *str2int(const char *src,int radix,long lower,long upper,
long *val);
longlong my_strtoll10(const char *nptr, char **endptr, int *error);
#if SIZEOF_LONG == SIZEOF_LONG_LONG
#define ll2str(A,B,C,D) int2str((A),(B),(C),(D))
#define longlong10_to_str(A,B,C) int10_to_str((A),(B),(C))
#undef strtoll
#define strtoll(A,B,C) strtol((A),(B),(C))
#define strtoull(A,B,C) strtoul((A),(B),(C))
#ifndef HAVE_STRTOULL
#define HAVE_STRTOULL
#endif
#ifndef HAVE_STRTOLL
#define HAVE_STRTOLL
#endif
#else
#ifdef HAVE_LONG_LONG
extern char *ll2str(longlong val,char *dst,int radix, int upcase);
extern char *longlong10_to_str(longlong val,char *dst,int radix);
#if (!defined(HAVE_STRTOULL) || defined(NO_STRTOLL_PROTO))
extern longlong strtoll(const char *str, char **ptr, int base);
extern ulonglong strtoull(const char *str, char **ptr, int base);
#endif
#endif
#endif
#define longlong2str(A,B,C) ll2str((A),(B),(C),1)
#if defined(__cplusplus)
}
#endif
#include
#ifdef __cplusplus
#include
template inline constexpr const char *_swl_check(T s)
{
static_assert(std::is_same::value
|| std::is_same::value,
"Wrong argument for STRING_WITH_LEN()");
return s;
}
#define STRING_WITH_LEN(X) _swl_check(X), ((size_t) (sizeof(X) - 1))
#else
#define STRING_WITH_LEN(X) (X ""), ((size_t) (sizeof(X) - 1))
#endif
#define USTRING_WITH_LEN(X) (uchar*) STRING_WITH_LEN(X)
#define C_STRING_WITH_LEN(X) (char *) STRING_WITH_LEN(X)
#define LEX_STRING_WITH_LEN(X) (X).str, (X).length
typedef struct st_mysql_const_lex_string LEX_CSTRING;
/* A variant with const and unsigned */
struct st_mysql_const_unsigned_lex_string
{
const uchar *str;
size_t length;
};
typedef struct st_mysql_const_unsigned_lex_string LEX_CUSTRING;
static inline void lex_string_set(LEX_CSTRING *lex_str, const char *c_str)
{
lex_str->str= c_str;
lex_str->length= strlen(c_str);
}
static inline void lex_string_set3(LEX_CSTRING *lex_str, const char *c_str,
size_t len)
{
lex_str->str= c_str;
lex_str->length= len;
}
/**
Copies a string.
@param dst destination buffer, will be NUL padded.
@param dst_size size of dst buffer, must be > 0
@param src NUL terminated source string
*/
static inline void safe_strcpy(char *dst, size_t dst_size, const char *src)
{
DBUG_ASSERT(dst_size > 0);
/* 1) IF there is a 0 byte in the first dst_size bytes of src, strncpy will
* 0-terminate dst, and pad dst with additional 0 bytes out to dst_size.
*
* 2) IF there is no 0 byte in the first dst_size bytes of src, strncpy will
* copy dst_size bytes, and the final byte won't be 0.
*
* In GCC 8+, the `-Wstringop-truncation` warning may object to strncpy()
* being used in this way, so we need to disable this warning for this
* single statement.
*/
#if defined __GNUC__ && __GNUC__ >= 8
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-truncation"
#endif
strncpy(dst, src, dst_size);
#if defined __GNUC__ && __GNUC__ >= 8
#pragma GCC diagnostic pop
#endif
dst[dst_size - 1]= 0;
}
/**
Copies a string, checking for truncation.
@param dst destination buffer, will be NUL padded.
@param dst_size size of dst buffer, must be > 0
@param src NUL terminated source string
@retval 1 if the src string was truncated due to too small size of dst.
@retval 0 if src completely fit within dst,
*/
static inline int safe_strcpy_truncated(char *dst, size_t dst_size,
const char *src)
{
DBUG_ASSERT(dst_size > 0);
if (dst_size == 0)
return 1;
/*
We do not want to use strncpy() as we do not want to rely on
strncpy() filling the unused dst with 0.
We cannot use strmake() here as it in debug mode fills the buffers
with 'Z'.
*/
if (strnmov(dst, src, dst_size) == dst+dst_size)
{
dst[dst_size-1]= 0;
return 1;
}
return 0;
}
/**
Appends src to dst and ensures dst is a NUL terminated C string.
@retval 1 if the src string was truncated due to too small size of dst.
@retval 0 if src completely fit within the remaining dst space,
including NUL termination.
*/
static inline int safe_strcat(char *dst, size_t dst_size, const char *src)
{
size_t init_len= strlen(dst);
if (init_len >= dst_size)
return 1;
return safe_strcpy_truncated(dst + init_len, dst_size - init_len, src);
}
#ifdef __cplusplus
static inline char *safe_str(char *str)
{ return str ? str : const_cast(""); }
static inline const char *safe_str(const LEX_CSTRING *lcs)
{ return lcs && lcs->str ? lcs->str : ""; }
#endif
static inline const char *safe_str(const char *str)
{ return str ? str : ""; }
static inline size_t safe_strlen(const char *str)
{ return str ? strlen(str) : 0; }
#endif
PK ! $ p mysql.hnu [ /*
Copyright (c) 2000, 2012, Oracle and/or its affiliates.
Copyright (c) 2012, Monty Program Ab.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/*
This file defines the client API to MySQL and also the ABI of the
dynamically linked libmysqlclient.
The ABI should never be changed in a released product of MySQL,
thus you need to take great care when changing the file. In case
the file is changed so the ABI is broken, you must also update
the SHARED_LIB_MAJOR_VERSION in cmake/mysql_version.cmake
*/
#ifndef _mysql_h
#define _mysql_h
#ifdef _AIX /* large-file support will break without this */
#include
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifndef MY_GLOBAL_INCLUDED /* If not standard header */
#ifndef MYSQL_ABI_CHECK
#include
#endif
#ifndef MYSQL_PLUGIN_INCLUDED
typedef char my_bool;
#endif
#if !defined(_WIN32)
#define STDCALL
#else
#define STDCALL __stdcall
#endif
#ifndef my_socket_defined
#if defined (_WIN64)
#define my_socket unsigned long long
#elif defined (_WIN32)
#define my_socket unsigned int
#else
typedef int my_socket;
#endif /* _WIN64 */
#endif /* my_socket_defined */
#endif /* MY_GLOBAL_INCLUDED */
#include "mariadb_capi_rename.h"
#include "mysql_version.h"
#include "mysql_com.h"
#include "mysql_time.h"
#include "my_list.h" /* for LISTs used in 'MYSQL' and 'MYSQL_STMT' */
extern unsigned int mariadb_deinitialize_ssl;
extern unsigned int mysql_port;
extern char *mysql_unix_port;
#define CLIENT_NET_READ_TIMEOUT (365*24*3600) /* Timeout on read */
#define CLIENT_NET_WRITE_TIMEOUT (365*24*3600) /* Timeout on write */
#define IS_PRI_KEY(n) ((n) & PRI_KEY_FLAG)
#define IS_NOT_NULL(n) ((n) & NOT_NULL_FLAG)
#define IS_BLOB(n) ((n) & BLOB_FLAG)
/**
Returns true if the value is a number which does not need quotes for
the sql_lex.cc parser to parse correctly.
*/
#define IS_NUM(t) (((t) <= MYSQL_TYPE_INT24 && (t) != MYSQL_TYPE_TIMESTAMP) || (t) == MYSQL_TYPE_YEAR || (t) == MYSQL_TYPE_NEWDECIMAL)
#define IS_LONGDATA(t) ((t) >= MYSQL_TYPE_TINY_BLOB && (t) <= MYSQL_TYPE_STRING)
typedef struct st_mysql_const_lex_string MARIADB_CONST_STRING;
typedef struct st_mysql_field {
char *name; /* Name of column */
char *org_name; /* Original column name, if an alias */
char *table; /* Table of column if column was a field */
char *org_table; /* Org table name, if table was an alias */
char *db; /* Database for table */
char *catalog; /* Catalog for table */
char *def; /* Default value (set by mysql_list_fields) */
unsigned long length; /* Width of column (create length) */
unsigned long max_length; /* Max width for selected set */
unsigned int name_length;
unsigned int org_name_length;
unsigned int table_length;
unsigned int org_table_length;
unsigned int db_length;
unsigned int catalog_length;
unsigned int def_length;
unsigned int flags; /* Div flags */
unsigned int decimals; /* Number of decimals in field */
unsigned int charsetnr; /* Character set */
enum enum_field_types type; /* Type of field. See mysql_com.h for types */
void *extension;
} MYSQL_FIELD;
typedef char **MYSQL_ROW; /* return data as array of strings */
typedef unsigned int MYSQL_FIELD_OFFSET; /* offset to current field */
#ifndef MY_GLOBAL_INCLUDED
#if defined(NO_CLIENT_LONG_LONG)
typedef unsigned long my_ulonglong;
#elif defined (_WIN32)
typedef unsigned __int64 my_ulonglong;
#else
typedef unsigned long long my_ulonglong;
#endif
#endif
#include "typelib.h"
#define MYSQL_COUNT_ERROR (~(my_ulonglong) 0)
/* backward compatibility define - to be removed eventually */
#define ER_WARN_DATA_TRUNCATED WARN_DATA_TRUNCATED
#define WARN_PLUGIN_DELETE_BUILTIN ER_PLUGIN_DELETE_BUILTIN
#define ER_FK_DUP_NAME ER_DUP_CONSTRAINT_NAME
#define ER_VIRTUAL_COLUMN_FUNCTION_IS_NOT_ALLOWED ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED
#define ER_PRIMARY_KEY_BASED_ON_VIRTUAL_COLUMN ER_PRIMARY_KEY_BASED_ON_GENERATED_COLUMN
#define ER_WRONG_FK_OPTION_FOR_VIRTUAL_COLUMN ER_WRONG_FK_OPTION_FOR_GENERATED_COLUMN
#define ER_UNSUPPORTED_ACTION_ON_VIRTUAL_COLUMN ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN
#define ER_UNSUPPORTED_ENGINE_FOR_VIRTUAL_COLUMNS ER_UNSUPPORTED_ENGINE_FOR_GENERATED_COLUMNS
#define ER_KEY_COLUMN_DOES_NOT_EXITS ER_KEY_COLUMN_DOES_NOT_EXIST
#define ER_DROP_PARTITION_NON_EXISTENT ER_PARTITION_DOES_NOT_EXIST
typedef struct st_mysql_rows {
struct st_mysql_rows *next; /* list of rows */
MYSQL_ROW data;
unsigned long length;
} MYSQL_ROWS;
typedef MYSQL_ROWS *MYSQL_ROW_OFFSET; /* offset to current row */
#include "my_alloc.h"
typedef struct embedded_query_result EMBEDDED_QUERY_RESULT;
typedef struct st_mysql_data {
MYSQL_ROWS *data;
struct embedded_query_result *embedded_info;
MEM_ROOT alloc;
my_ulonglong rows;
unsigned int fields;
/* extra info for embedded library */
void *extension;
} MYSQL_DATA;
enum mysql_option
{
MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_COMPRESS, MYSQL_OPT_NAMED_PIPE,
MYSQL_INIT_COMMAND, MYSQL_READ_DEFAULT_FILE, MYSQL_READ_DEFAULT_GROUP,
MYSQL_SET_CHARSET_DIR, MYSQL_SET_CHARSET_NAME, MYSQL_OPT_LOCAL_INFILE,
MYSQL_OPT_PROTOCOL, MYSQL_SHARED_MEMORY_BASE_NAME, MYSQL_OPT_READ_TIMEOUT,
MYSQL_OPT_WRITE_TIMEOUT, MYSQL_OPT_USE_RESULT,
MYSQL_OPT_USE_REMOTE_CONNECTION, MYSQL_OPT_USE_EMBEDDED_CONNECTION,
MYSQL_OPT_GUESS_CONNECTION, MYSQL_SET_CLIENT_IP, MYSQL_SECURE_AUTH,
MYSQL_REPORT_DATA_TRUNCATION, MYSQL_OPT_RECONNECT,
MYSQL_OPT_SSL_VERIFY_SERVER_CERT, MYSQL_PLUGIN_DIR, MYSQL_DEFAULT_AUTH,
MYSQL_OPT_BIND,
MYSQL_OPT_SSL_KEY, MYSQL_OPT_SSL_CERT,
MYSQL_OPT_SSL_CA, MYSQL_OPT_SSL_CAPATH, MYSQL_OPT_SSL_CIPHER,
MYSQL_OPT_SSL_CRL, MYSQL_OPT_SSL_CRLPATH,
MYSQL_OPT_CONNECT_ATTR_RESET, MYSQL_OPT_CONNECT_ATTR_ADD,
MYSQL_OPT_CONNECT_ATTR_DELETE,
MYSQL_SERVER_PUBLIC_KEY,
MYSQL_ENABLE_CLEARTEXT_PLUGIN,
MYSQL_OPT_CAN_HANDLE_EXPIRED_PASSWORDS,
/* MariaDB options */
MYSQL_PROGRESS_CALLBACK=5999,
MYSQL_OPT_NONBLOCK,
MYSQL_OPT_USE_THREAD_SPECIFIC_MEMORY
};
/**
@todo remove the "extension", move st_mysql_options completely
out of mysql.h
*/
struct st_mysql_options_extention;
struct st_mysql_options {
unsigned int connect_timeout, read_timeout, write_timeout;
unsigned int port, protocol;
unsigned long client_flag;
char *host,*user,*password,*unix_socket,*db;
struct st_dynamic_array *init_commands;
char *my_cnf_file,*my_cnf_group, *charset_dir, *charset_name;
char *ssl_key; /* PEM key file */
char *ssl_cert; /* PEM cert file */
char *ssl_ca; /* PEM CA file */
char *ssl_capath; /* PEM directory of CA-s? */
char *ssl_cipher; /* cipher to use */
char *shared_memory_base_name;
unsigned long max_allowed_packet;
my_bool use_ssl; /* if to use SSL or not */
my_bool compress,named_pipe;
my_bool use_thread_specific_memory;
my_bool unused2;
my_bool unused3;
my_bool unused4;
enum mysql_option methods_to_use;
char *client_ip;
/* Refuse client connecting to server if it uses old (pre-4.1.1) protocol */
my_bool secure_auth;
/* 0 - never report, 1 - always report (default) */
my_bool report_data_truncation;
/* function pointers for local infile support */
int (*local_infile_init)(void **, const char *, void *);
int (*local_infile_read)(void *, char *, unsigned int);
void (*local_infile_end)(void *);
int (*local_infile_error)(void *, char *, unsigned int);
void *local_infile_userdata;
struct st_mysql_options_extention *extension;
};
enum mysql_status
{
MYSQL_STATUS_READY, MYSQL_STATUS_GET_RESULT, MYSQL_STATUS_USE_RESULT,
MYSQL_STATUS_STATEMENT_GET_RESULT
};
enum mysql_protocol_type
{
MYSQL_PROTOCOL_DEFAULT, MYSQL_PROTOCOL_TCP, MYSQL_PROTOCOL_SOCKET,
MYSQL_PROTOCOL_PIPE, MYSQL_PROTOCOL_MEMORY
};
typedef struct character_set
{
unsigned int number; /* character set number */
unsigned int state; /* character set state */
const char *csname; /* collation name */
const char *name; /* character set name */
const char *comment; /* comment */
const char *dir; /* character set directory */
unsigned int mbminlen; /* min. length for multibyte strings */
unsigned int mbmaxlen; /* max. length for multibyte strings */
} MY_CHARSET_INFO;
struct st_mysql_methods;
struct st_mysql_stmt;
typedef struct st_mysql
{
NET net; /* Communication parameters */
unsigned char *connector_fd; /* ConnectorFd for SSL */
char *host,*user,*passwd,*unix_socket,*server_version,*host_info;
char *info, *db;
const struct charset_info_st *charset;
MEM_ROOT field_alloc;
my_ulonglong affected_rows;
my_ulonglong insert_id; /* id if insert on table with NEXTNR */
my_ulonglong extra_info; /* Not used */
unsigned long thread_id; /* Id for connection in server */
unsigned long packet_length;
unsigned int port;
unsigned long client_flag,server_capabilities;
unsigned int protocol_version;
unsigned int field_count;
unsigned int server_status;
unsigned int server_language;
unsigned int warning_count;
struct st_mysql_options options;
enum mysql_status status;
my_bool free_me; /* If free in mysql_close */
my_bool reconnect; /* set to 1 if automatic reconnect */
/* session-wide random string */
char scramble[SCRAMBLE_LENGTH+1];
my_bool auto_local_infile;
void *unused2, *unused3;
MYSQL_FIELD *fields;
const char *tls_self_signed_error;
LIST *stmts; /* list of all statements */
const struct st_mysql_methods *methods;
void *thd;
/*
Points to boolean flag in MYSQL_RES or MYSQL_STMT. We set this flag
from mysql_stmt_close if close had to cancel result set of this object.
*/
my_bool *unbuffered_fetch_owner;
/* needed for embedded server - no net buffer to store the 'info' */
char *info_buffer;
void *extension;
} MYSQL;
typedef struct st_mysql_res {
my_ulonglong row_count;
MYSQL_FIELD *fields;
MYSQL_DATA *data;
MYSQL_ROWS *data_cursor;
unsigned long *lengths; /* column lengths of current row */
MYSQL *handle; /* for unbuffered reads */
const struct st_mysql_methods *methods;
MYSQL_ROW row; /* If unbuffered read */
MYSQL_ROW current_row; /* buffer to current row */
MEM_ROOT field_alloc;
unsigned int field_count, current_field;
my_bool eof; /* Used by mysql_fetch_row */
/* mysql_stmt_close() had to cancel this result */
my_bool unbuffered_fetch_cancelled;
void *extension;
} MYSQL_RES;
/*
We should not define MYSQL_CLIENT when the mysql.h is included
by the server or server plugins.
Now it is important only for the SQL service to work so we rely on
the MYSQL_SERVICE_SQL to check we're compiling the server/plugin
related file.
*/
#if !defined(MYSQL_SERVICE_SQL) && !defined(MYSQL_CLIENT)
#define MYSQL_CLIENT
#endif
typedef struct st_mysql_parameters
{
unsigned long *p_max_allowed_packet;
unsigned long *p_net_buffer_length;
void *extension;
} MYSQL_PARAMETERS;
/*
Flag bits, the asynchronous methods return a combination of these ORed
together to let the application know when to resume the suspended operation.
*/
/*
Wait for data to be available on socket to read.
mysql_get_socket_fd() will return socket descriptor.
*/
#define MYSQL_WAIT_READ 1
/* Wait for socket to be ready to write data. */
#define MYSQL_WAIT_WRITE 2
/* Wait for select() to mark exception on socket. */
#define MYSQL_WAIT_EXCEPT 4
/*
Wait until timeout occurs. Value of timeout can be obtained from
mysql_get_timeout_value().
*/
#define MYSQL_WAIT_TIMEOUT 8
#if !defined(MYSQL_SERVICE_SQL)
#define max_allowed_packet (*mysql_get_parameters()->p_max_allowed_packet)
#define net_buffer_length (*mysql_get_parameters()->p_net_buffer_length)
#endif
/*
Set up and bring down the server; to ensure that applications will
work when linked against either the standard client library or the
embedded server library, these functions should be called.
*/
int STDCALL mysql_server_init(int argc, char **argv, char **groups);
void STDCALL mysql_server_end(void);
/*
mysql_server_init/end need to be called when using libmysqld or
libmysqlclient (exactly, mysql_server_init() is called by mysql_init() so
you don't need to call it explicitly; but you need to call
mysql_server_end() to free memory). The names are a bit misleading
(mysql_SERVER* to be used when using libmysqlCLIENT). So we add more general
names which suit well whether you're using libmysqld or libmysqlclient. We
intend to promote these aliases over the mysql_server* ones.
*/
#define mysql_library_init mysql_server_init
#define mysql_library_end mysql_server_end
MYSQL_PARAMETERS *STDCALL mysql_get_parameters(void);
/*
Set up and bring down a thread; these function should be called
for each thread in an application which opens at least one MySQL
connection. All uses of the connection(s) should be between these
function calls.
*/
my_bool STDCALL mysql_thread_init(void);
void STDCALL mysql_thread_end(void);
/*
Functions to get information from the MYSQL and MYSQL_RES structures
Should definitely be used if one uses shared libraries.
*/
my_ulonglong STDCALL mysql_num_rows(MYSQL_RES *res);
unsigned int STDCALL mysql_num_fields(MYSQL_RES *res);
my_bool STDCALL mysql_eof(MYSQL_RES *res);
MYSQL_FIELD *STDCALL mysql_fetch_field_direct(MYSQL_RES *res,
unsigned int fieldnr);
MYSQL_FIELD * STDCALL mysql_fetch_fields(MYSQL_RES *res);
MYSQL_ROW_OFFSET STDCALL mysql_row_tell(MYSQL_RES *res);
MYSQL_FIELD_OFFSET STDCALL mysql_field_tell(MYSQL_RES *res);
int STDCALL mariadb_field_attr(MARIADB_CONST_STRING *attr,
const MYSQL_FIELD *field,
enum mariadb_field_attr_t type);
unsigned int STDCALL mysql_field_count(MYSQL *mysql);
my_ulonglong STDCALL mysql_affected_rows(MYSQL *mysql);
my_ulonglong STDCALL mysql_insert_id(MYSQL *mysql);
unsigned int STDCALL mysql_errno(MYSQL *mysql);
const char * STDCALL mysql_error(MYSQL *mysql);
const char *STDCALL mysql_sqlstate(MYSQL *mysql);
unsigned int STDCALL mysql_warning_count(MYSQL *mysql);
const char * STDCALL mysql_info(MYSQL *mysql);
unsigned long STDCALL mysql_thread_id(MYSQL *mysql);
const char * STDCALL mysql_character_set_name(MYSQL *mysql);
int STDCALL mysql_set_character_set(MYSQL *mysql, const char *csname);
int STDCALL mysql_set_character_set_start(int *ret, MYSQL *mysql,
const char *csname);
int STDCALL mysql_set_character_set_cont(int *ret, MYSQL *mysql,
int status);
MYSQL * STDCALL mysql_init(MYSQL *mysql);
my_bool STDCALL mysql_ssl_set(MYSQL *mysql, const char *key,
const char *cert, const char *ca,
const char *capath, const char *cipher);
const char * STDCALL mysql_get_ssl_cipher(MYSQL *mysql);
my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user,
const char *passwd, const char *db);
int STDCALL mysql_change_user_start(my_bool *ret, MYSQL *mysql,
const char *user,
const char *passwd,
const char *db);
int STDCALL mysql_change_user_cont(my_bool *ret, MYSQL *mysql,
int status);
MYSQL * STDCALL mysql_real_connect(MYSQL *mysql, const char *host,
const char *user,
const char *passwd,
const char *db,
unsigned int port,
const char *unix_socket,
unsigned long clientflag);
int STDCALL mysql_real_connect_start(MYSQL **ret, MYSQL *mysql,
const char *host,
const char *user,
const char *passwd,
const char *db,
unsigned int port,
const char *unix_socket,
unsigned long clientflag);
int STDCALL mysql_real_connect_cont(MYSQL **ret, MYSQL *mysql,
int status);
int STDCALL mysql_select_db(MYSQL *mysql, const char *db);
int STDCALL mysql_select_db_start(int *ret, MYSQL *mysql,
const char *db);
int STDCALL mysql_select_db_cont(int *ret, MYSQL *mysql,
int status);
int STDCALL mysql_query(MYSQL *mysql, const char *q);
int STDCALL mysql_query_start(int *ret, MYSQL *mysql,
const char *q);
int STDCALL mysql_query_cont(int *ret, MYSQL *mysql,
int status);
int STDCALL mysql_send_query(MYSQL *mysql, const char *q,
unsigned long length);
int STDCALL mysql_send_query_start(int *ret, MYSQL *mysql,
const char *q,
unsigned long length);
int STDCALL mysql_send_query_cont(int *ret, MYSQL *mysql,
int status);
int STDCALL mysql_real_query(MYSQL *mysql, const char *q,
unsigned long length);
int STDCALL mysql_real_query_start(int *ret, MYSQL *mysql,
const char *q,
unsigned long length);
int STDCALL mysql_real_query_cont(int *ret, MYSQL *mysql,
int status);
MYSQL_RES * STDCALL mysql_store_result(MYSQL *mysql);
int STDCALL mysql_store_result_start(MYSQL_RES **ret, MYSQL *mysql);
int STDCALL mysql_store_result_cont(MYSQL_RES **ret, MYSQL *mysql,
int status);
MYSQL_RES * STDCALL mysql_use_result(MYSQL *mysql);
void STDCALL mysql_get_character_set_info(MYSQL *mysql,
MY_CHARSET_INFO *charset);
/* local infile support */
#define LOCAL_INFILE_ERROR_LEN 512
void
mysql_set_local_infile_handler(MYSQL *mysql,
int (*local_infile_init)(void **, const char *,
void *),
int (*local_infile_read)(void *, char *,
unsigned int),
void (*local_infile_end)(void *),
int (*local_infile_error)(void *, char*,
unsigned int),
void *);
void
mysql_set_local_infile_default(MYSQL *mysql);
int STDCALL mysql_shutdown(MYSQL *mysql,
enum mysql_enum_shutdown_level
shutdown_level);
int STDCALL mysql_shutdown_start(int *ret, MYSQL *mysql,
enum mysql_enum_shutdown_level
shutdown_level);
int STDCALL mysql_shutdown_cont(int *ret, MYSQL *mysql,
int status);
int STDCALL mysql_dump_debug_info(MYSQL *mysql);
int STDCALL mysql_dump_debug_info_start(int *ret, MYSQL *mysql);
int STDCALL mysql_dump_debug_info_cont(int *ret, MYSQL *mysql,
int status);
int STDCALL mysql_refresh(MYSQL *mysql,
unsigned int refresh_options);
int STDCALL mysql_refresh_start(int *ret, MYSQL *mysql,
unsigned int refresh_options);
int STDCALL mysql_refresh_cont(int *ret, MYSQL *mysql, int status);
int STDCALL mysql_kill(MYSQL *mysql,unsigned long pid);
int STDCALL mysql_kill_start(int *ret, MYSQL *mysql,
unsigned long pid);
int STDCALL mysql_kill_cont(int *ret, MYSQL *mysql, int status);
int STDCALL mysql_set_server_option(MYSQL *mysql,
enum enum_mysql_set_option
option);
int STDCALL mysql_set_server_option_start(int *ret, MYSQL *mysql,
enum enum_mysql_set_option
option);
int STDCALL mysql_set_server_option_cont(int *ret, MYSQL *mysql,
int status);
int STDCALL mysql_ping(MYSQL *mysql);
int STDCALL mysql_ping_start(int *ret, MYSQL *mysql);
int STDCALL mysql_ping_cont(int *ret, MYSQL *mysql, int status);
const char * STDCALL mysql_stat(MYSQL *mysql);
int STDCALL mysql_stat_start(const char **ret, MYSQL *mysql);
int STDCALL mysql_stat_cont(const char **ret, MYSQL *mysql,
int status);
const char * STDCALL mysql_get_server_info(MYSQL *mysql);
const char * STDCALL mysql_get_server_name(MYSQL *mysql);
const char * STDCALL mysql_get_client_info(void);
unsigned long STDCALL mysql_get_client_version(void);
const char * STDCALL mysql_get_host_info(MYSQL *mysql);
unsigned long STDCALL mysql_get_server_version(MYSQL *mysql);
unsigned int STDCALL mysql_get_proto_info(MYSQL *mysql);
MYSQL_RES * STDCALL mysql_list_dbs(MYSQL *mysql,const char *wild);
int STDCALL mysql_list_dbs_start(MYSQL_RES **ret, MYSQL *mysql,
const char *wild);
int STDCALL mysql_list_dbs_cont(MYSQL_RES **ret, MYSQL *mysql,
int status);
MYSQL_RES * STDCALL mysql_list_tables(MYSQL *mysql,const char *wild);
int STDCALL mysql_list_tables_start(MYSQL_RES **ret, MYSQL *mysql,
const char *wild);
int STDCALL mysql_list_tables_cont(MYSQL_RES **ret, MYSQL *mysql,
int status);
MYSQL_RES * STDCALL mysql_list_processes(MYSQL *mysql);
int STDCALL mysql_list_processes_start(MYSQL_RES **ret,
MYSQL *mysql);
int STDCALL mysql_list_processes_cont(MYSQL_RES **ret, MYSQL *mysql,
int status);
int STDCALL mysql_options(MYSQL *mysql,enum mysql_option option,
const void *arg);
int STDCALL mysql_options4(MYSQL *mysql,enum mysql_option option,
const void *arg1, const void *arg2);
void STDCALL mysql_free_result(MYSQL_RES *result);
int STDCALL mysql_free_result_start(MYSQL_RES *result);
int STDCALL mysql_free_result_cont(MYSQL_RES *result, int status);
void STDCALL mysql_data_seek(MYSQL_RES *result,
my_ulonglong offset);
MYSQL_ROW_OFFSET STDCALL mysql_row_seek(MYSQL_RES *result,
MYSQL_ROW_OFFSET offset);
MYSQL_FIELD_OFFSET STDCALL mysql_field_seek(MYSQL_RES *result,
MYSQL_FIELD_OFFSET offset);
MYSQL_ROW STDCALL mysql_fetch_row(MYSQL_RES *result);
int STDCALL mysql_fetch_row_start(MYSQL_ROW *ret,
MYSQL_RES *result);
int STDCALL mysql_fetch_row_cont(MYSQL_ROW *ret, MYSQL_RES *result,
int status);
unsigned long * STDCALL mysql_fetch_lengths(MYSQL_RES *result);
MYSQL_FIELD * STDCALL mysql_fetch_field(MYSQL_RES *result);
MYSQL_RES * STDCALL mysql_list_fields(MYSQL *mysql, const char *table,
const char *wild);
int STDCALL mysql_list_fields_start(MYSQL_RES **ret, MYSQL *mysql,
const char *table,
const char *wild);
int STDCALL mysql_list_fields_cont(MYSQL_RES **ret, MYSQL *mysql,
int status);
unsigned long STDCALL mysql_escape_string(char *to,const char *from,
unsigned long from_length);
unsigned long STDCALL mysql_hex_string(char *to,const char *from,
unsigned long from_length);
unsigned long STDCALL mysql_real_escape_string(MYSQL *mysql,
char *to,const char *from,
unsigned long length);
void STDCALL mysql_debug(const char *debug);
void STDCALL myodbc_remove_escape(MYSQL *mysql,char *name);
unsigned int STDCALL mysql_thread_safe(void);
my_bool STDCALL mysql_embedded(void);
my_bool STDCALL mariadb_connection(MYSQL *mysql);
my_bool STDCALL mysql_read_query_result(MYSQL *mysql);
int STDCALL mysql_read_query_result_start(my_bool *ret,
MYSQL *mysql);
int STDCALL mysql_read_query_result_cont(my_bool *ret,
MYSQL *mysql, int status);
/*
The following definitions are added for the enhanced
client-server protocol
*/
/* statement state */
enum enum_mysql_stmt_state
{
MYSQL_STMT_INIT_DONE= 1, MYSQL_STMT_PREPARE_DONE, MYSQL_STMT_EXECUTE_DONE,
MYSQL_STMT_FETCH_DONE
};
/*
This structure is used to define bind information, and
internally by the client library.
Public members with their descriptions are listed below
(conventionally `On input' refers to the binds given to
mysql_stmt_bind_param, `On output' refers to the binds given
to mysql_stmt_bind_result):
buffer_type - One of the MYSQL_* types, used to describe
the host language type of buffer.
On output: if column type is different from
buffer_type, column value is automatically converted
to buffer_type before it is stored in the buffer.
buffer - On input: points to the buffer with input data.
On output: points to the buffer capable to store
output data.
The type of memory pointed by buffer must correspond
to buffer_type. See the correspondence table in
the comment to mysql_stmt_bind_param.
The two above members are mandatory for any kind of bind.
buffer_length - the length of the buffer. You don't have to set
it for any fixed length buffer: float, double,
int, etc. It must be set however for variable-length
types, such as BLOBs or STRINGs.
length - On input: in case when lengths of input values
are different for each execute, you can set this to
point at a variable containing value length. This
way the value length can be different in each execute.
If length is not NULL, buffer_length is not used.
Note, length can even point at buffer_length if
you keep bind structures around while fetching:
this way you can change buffer_length before
each execution, everything will work ok.
On output: if length is set, mysql_stmt_fetch will
write column length into it.
is_null - On input: points to a boolean variable that should
be set to TRUE for NULL values.
This member is useful only if your data may be
NULL in some but not all cases.
If your data is never NULL, is_null should be set to 0.
If your data is always NULL, set buffer_type
to MYSQL_TYPE_NULL, and is_null will not be used.
is_unsigned - On input: used to signify that values provided for one
of numeric types are unsigned.
On output describes signedness of the output buffer.
If, taking into account is_unsigned flag, column data
is out of range of the output buffer, data for this column
is regarded truncated. Note that this has no correspondence
to the sign of result set column, if you need to find it out
use mysql_stmt_result_metadata.
error - where to write a truncation error if it is present.
possible error value is:
0 no truncation
1 value is out of range or buffer is too small
Please note that MYSQL_BIND also has internals members.
*/
typedef struct st_mysql_bind
{
unsigned long *length; /* output length pointer */
my_bool *is_null; /* Pointer to null indicator */
void *buffer; /* buffer to get/put data */
/* set this if you want to track data truncations happened during fetch */
my_bool *error;
unsigned char *row_ptr; /* for the current data position */
void (*store_param_func)(NET *net, struct st_mysql_bind *param);
void (*fetch_result)(struct st_mysql_bind *, MYSQL_FIELD *,
unsigned char **row);
void (*skip_result)(struct st_mysql_bind *, MYSQL_FIELD *,
unsigned char **row);
/* output buffer length, must be set when fetching str/binary */
unsigned long buffer_length;
unsigned long offset; /* offset position for char/binary fetch */
unsigned long length_value; /* Used if length is 0 */
unsigned int param_number; /* For null count and error messages */
unsigned int pack_length; /* Internal length for packed data */
enum enum_field_types buffer_type; /* buffer type */
my_bool error_value; /* used if error is 0 */
my_bool is_unsigned; /* set if integer type is unsigned */
my_bool long_data_used; /* If used with mysql_send_long_data */
my_bool is_null_value; /* Used if is_null is 0 */
void *extension;
} MYSQL_BIND;
struct st_mysql_stmt_extension;
/* statement handler */
typedef struct st_mysql_stmt
{
MEM_ROOT mem_root; /* root allocations */
LIST list; /* list to keep track of all stmts */
MYSQL *mysql; /* connection handle */
MYSQL_BIND *params; /* input parameters */
MYSQL_BIND *bind; /* output parameters */
MYSQL_FIELD *fields; /* result set metadata */
MYSQL_DATA result; /* cached result set */
MYSQL_ROWS *data_cursor; /* current row in cached result */
/*
mysql_stmt_fetch() calls this function to fetch one row (it's different
for buffered, unbuffered and cursor fetch).
*/
int (*read_row_func)(struct st_mysql_stmt *stmt,
unsigned char **row);
/* copy of mysql->affected_rows after statement execution */
my_ulonglong affected_rows;
my_ulonglong insert_id; /* copy of mysql->insert_id */
unsigned long stmt_id; /* Id for prepared statement */
unsigned long flags; /* i.e. type of cursor to open */
unsigned long prefetch_rows; /* number of rows per one COM_FETCH */
/*
Copied from mysql->server_status after execute/fetch to know
server-side cursor status for this statement.
*/
unsigned int server_status;
unsigned int last_errno; /* error code */
unsigned int param_count; /* input parameter count */
unsigned int field_count; /* number of columns in result set */
enum enum_mysql_stmt_state state; /* statement state */
char last_error[MYSQL_ERRMSG_SIZE]; /* error message */
char sqlstate[SQLSTATE_LENGTH+1];
/* Types of input parameters should be sent to server */
my_bool send_types_to_server;
my_bool bind_param_done; /* input buffers were supplied */
unsigned char bind_result_done; /* output buffers were supplied */
/* mysql_stmt_close() had to cancel this result */
my_bool unbuffered_fetch_cancelled;
/*
Is set to true if we need to calculate field->max_length for
metadata fields when doing mysql_stmt_store_result.
*/
my_bool update_max_length;
struct st_mysql_stmt_extension *extension;
} MYSQL_STMT;
enum enum_stmt_attr_type
{
/*
When doing mysql_stmt_store_result calculate max_length attribute
of statement metadata. This is to be consistent with the old API,
where this was done automatically.
In the new API we do that only by request because it slows down
mysql_stmt_store_result sufficiently.
*/
STMT_ATTR_UPDATE_MAX_LENGTH,
/*
unsigned long with combination of cursor flags (read only, for update,
etc)
*/
STMT_ATTR_CURSOR_TYPE,
/*
Amount of rows to retrieve from server per one fetch if using cursors.
Accepts unsigned long attribute in the range 1 - ulong_max
*/
STMT_ATTR_PREFETCH_ROWS
};
MYSQL_STMT * STDCALL mysql_stmt_init(MYSQL *mysql);
int STDCALL mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query,
unsigned long length);
int STDCALL mysql_stmt_prepare_start(int *ret, MYSQL_STMT *stmt,
const char *query, unsigned long length);
int STDCALL mysql_stmt_prepare_cont(int *ret, MYSQL_STMT *stmt, int status);
int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt);
int STDCALL mysql_stmt_execute_start(int *ret, MYSQL_STMT *stmt);
int STDCALL mysql_stmt_execute_cont(int *ret, MYSQL_STMT *stmt, int status);
int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt);
int STDCALL mysql_stmt_fetch_start(int *ret, MYSQL_STMT *stmt);
int STDCALL mysql_stmt_fetch_cont(int *ret, MYSQL_STMT *stmt, int status);
int STDCALL mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind_arg,
unsigned int column,
unsigned long offset);
int STDCALL mysql_stmt_store_result(MYSQL_STMT *stmt);
int STDCALL mysql_stmt_store_result_start(int *ret, MYSQL_STMT *stmt);
int STDCALL mysql_stmt_store_result_cont(int *ret, MYSQL_STMT *stmt,
int status);
unsigned long STDCALL mysql_stmt_param_count(MYSQL_STMT * stmt);
my_bool STDCALL mysql_stmt_attr_set(MYSQL_STMT *stmt,
enum enum_stmt_attr_type attr_type,
const void *attr);
my_bool STDCALL mysql_stmt_attr_get(MYSQL_STMT *stmt,
enum enum_stmt_attr_type attr_type,
void *attr);
my_bool STDCALL mysql_stmt_bind_param(MYSQL_STMT * stmt, MYSQL_BIND * bnd);
my_bool STDCALL mysql_stmt_bind_result(MYSQL_STMT * stmt, MYSQL_BIND * bnd);
my_bool STDCALL mysql_stmt_close(MYSQL_STMT * stmt);
int STDCALL mysql_stmt_close_start(my_bool *ret, MYSQL_STMT *stmt);
int STDCALL mysql_stmt_close_cont(my_bool *ret, MYSQL_STMT * stmt, int status);
my_bool STDCALL mysql_stmt_reset(MYSQL_STMT * stmt);
int STDCALL mysql_stmt_reset_start(my_bool *ret, MYSQL_STMT * stmt);
int STDCALL mysql_stmt_reset_cont(my_bool *ret, MYSQL_STMT *stmt, int status);
my_bool STDCALL mysql_stmt_free_result(MYSQL_STMT *stmt);
int STDCALL mysql_stmt_free_result_start(my_bool *ret, MYSQL_STMT *stmt);
int STDCALL mysql_stmt_free_result_cont(my_bool *ret, MYSQL_STMT *stmt,
int status);
my_bool STDCALL mysql_stmt_send_long_data(MYSQL_STMT *stmt,
unsigned int param_number,
const char *data,
unsigned long length);
int STDCALL mysql_stmt_send_long_data_start(my_bool *ret, MYSQL_STMT *stmt,
unsigned int param_number,
const char *data,
unsigned long len);
int STDCALL mysql_stmt_send_long_data_cont(my_bool *ret, MYSQL_STMT *stmt,
int status);
MYSQL_RES *STDCALL mysql_stmt_result_metadata(MYSQL_STMT *stmt);
MYSQL_RES *STDCALL mysql_stmt_param_metadata(MYSQL_STMT *stmt);
unsigned int STDCALL mysql_stmt_errno(MYSQL_STMT * stmt);
const char *STDCALL mysql_stmt_error(MYSQL_STMT * stmt);
const char *STDCALL mysql_stmt_sqlstate(MYSQL_STMT * stmt);
MYSQL_ROW_OFFSET STDCALL mysql_stmt_row_seek(MYSQL_STMT *stmt,
MYSQL_ROW_OFFSET offset);
MYSQL_ROW_OFFSET STDCALL mysql_stmt_row_tell(MYSQL_STMT *stmt);
void STDCALL mysql_stmt_data_seek(MYSQL_STMT *stmt, my_ulonglong offset);
my_ulonglong STDCALL mysql_stmt_num_rows(MYSQL_STMT *stmt);
my_ulonglong STDCALL mysql_stmt_affected_rows(MYSQL_STMT *stmt);
my_ulonglong STDCALL mysql_stmt_insert_id(MYSQL_STMT *stmt);
unsigned int STDCALL mysql_stmt_field_count(MYSQL_STMT *stmt);
my_bool STDCALL mysql_commit(MYSQL * mysql);
int STDCALL mysql_commit_start(my_bool *ret, MYSQL * mysql);
int STDCALL mysql_commit_cont(my_bool *ret, MYSQL * mysql, int status);
my_bool STDCALL mysql_rollback(MYSQL * mysql);
int STDCALL mysql_rollback_start(my_bool *ret, MYSQL * mysql);
int STDCALL mysql_rollback_cont(my_bool *ret, MYSQL * mysql, int status);
my_bool STDCALL mysql_autocommit(MYSQL * mysql, my_bool auto_mode);
int STDCALL mysql_autocommit_start(my_bool *ret, MYSQL * mysql,
my_bool auto_mode);
int STDCALL mysql_autocommit_cont(my_bool *ret, MYSQL * mysql, int status);
my_bool STDCALL mysql_more_results(MYSQL *mysql);
int STDCALL mysql_next_result(MYSQL *mysql);
int STDCALL mysql_next_result_start(int *ret, MYSQL *mysql);
int STDCALL mysql_next_result_cont(int *ret, MYSQL *mysql, int status);
int STDCALL mysql_stmt_next_result(MYSQL_STMT *stmt);
int STDCALL mysql_stmt_next_result_start(int *ret, MYSQL_STMT *stmt);
int STDCALL mysql_stmt_next_result_cont(int *ret, MYSQL_STMT *stmt, int status);
void STDCALL mysql_close_slow_part(MYSQL *mysql);
void STDCALL mysql_close(MYSQL *sock);
int STDCALL mysql_close_start(MYSQL *sock);
int STDCALL mysql_close_cont(MYSQL *sock, int status);
my_socket STDCALL mysql_get_socket(const MYSQL *mysql);
unsigned int STDCALL mysql_get_timeout_value(const MYSQL *mysql);
unsigned int STDCALL mysql_get_timeout_value_ms(const MYSQL *mysql);
/********************************************************************
mysql_net_ functions - low-level API to MySQL protocol
*********************************************************************/
unsigned long STDCALL mysql_net_read_packet(MYSQL *mysql);
unsigned long STDCALL mysql_net_field_length(unsigned char **packet);
/* status return codes */
#define MYSQL_NO_DATA 100
#define MYSQL_DATA_TRUNCATED 101
#define mysql_reload(mysql) mysql_refresh((mysql),REFRESH_GRANT)
#ifdef USE_OLD_FUNCTIONS
MYSQL * STDCALL mysql_connect(MYSQL *mysql, const char *host,
const char *user, const char *passwd);
int STDCALL mysql_create_db(MYSQL *mysql, const char *DB);
int STDCALL mysql_drop_db(MYSQL *mysql, const char *DB);
#endif
#define HAVE_MYSQL_REAL_CONNECT
#ifdef __cplusplus
}
#endif
#endif /* _mysql_h */
PK ! Z~m m ma_dyncol.hnu [ /* Copyright (c) 2011, Monty Program Ab
Copyright (c) 2011, Oleksandr Byelkin
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must the following disclaimer in
the documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY ``AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
*/
#ifndef ma_dyncol_h
#define ma_dyncol_h
#ifdef __cplusplus
extern "C" {
#endif
#include
#include
#include
#ifndef _my_sys_h
typedef struct st_dynamic_string
{
char *str;
size_t length,max_length,alloc_increment;
} DYNAMIC_STRING;
#endif
#ifndef MY_GLOBAL_INCLUDED
struct st_mysql_lex_string
{
char *str;
size_t length;
};
typedef struct st_mysql_lex_string MYSQL_LEX_STRING;
typedef struct st_mysql_lex_string LEX_STRING;
#endif
/*
Limits of implementation
*/
#define MAX_TOTAL_NAME_LENGTH 65535
#define MAX_NAME_LENGTH (MAX_TOTAL_NAME_LENGTH/4)
/* NO and OK is the same used just to show semantics */
#define ER_DYNCOL_NO ER_DYNCOL_OK
#ifdef HAVE_CHARSET_utf8mb4
#define DYNCOL_UTF (&my_charset_utf8mb4_general_ci)
#else
#define DYNCOL_UTF (&my_charset_utf8mb3_general_ci)
#endif
/* escape json strings */
#define DYNCOL_JSON_ESC ((char)1)
enum enum_dyncol_func_result
{
ER_DYNCOL_OK= 0,
ER_DYNCOL_YES= 1, /* For functions returning 0/1 */
ER_DYNCOL_FORMAT= -1, /* Wrong format of the encoded string */
ER_DYNCOL_LIMIT= -2, /* Some limit reached */
ER_DYNCOL_RESOURCE= -3, /* Out of resources */
ER_DYNCOL_DATA= -4, /* Incorrect input data */
ER_DYNCOL_UNKNOWN_CHARSET= -5, /* Unknown character set */
ER_DYNCOL_TRUNCATED= 2 /* OK, but data was truncated */
};
typedef DYNAMIC_STRING DYNAMIC_COLUMN;
enum enum_dynamic_column_type
{
DYN_COL_NULL= 0,
DYN_COL_INT,
DYN_COL_UINT,
DYN_COL_DOUBLE,
DYN_COL_STRING,
DYN_COL_DECIMAL,
DYN_COL_DATETIME,
DYN_COL_DATE,
DYN_COL_TIME,
DYN_COL_DYNCOL
};
typedef enum enum_dynamic_column_type DYNAMIC_COLUMN_TYPE;
struct st_dynamic_column_value
{
DYNAMIC_COLUMN_TYPE type;
union
{
long long long_value;
unsigned long long ulong_value;
double double_value;
struct {
MYSQL_LEX_STRING value;
CHARSET_INFO *charset;
} string;
struct {
decimal_digit_t buffer[DECIMAL_BUFF_LENGTH];
decimal_t value;
} decimal;
MYSQL_TIME time_value;
} x;
};
typedef struct st_dynamic_column_value DYNAMIC_COLUMN_VALUE;
#ifdef MADYNCOL_DEPRECATED
enum enum_dyncol_func_result
dynamic_column_create(DYNAMIC_COLUMN *str,
uint column_nr, DYNAMIC_COLUMN_VALUE *value);
enum enum_dyncol_func_result
dynamic_column_create_many(DYNAMIC_COLUMN *str,
uint column_count,
uint *column_numbers,
DYNAMIC_COLUMN_VALUE *values);
enum enum_dyncol_func_result
dynamic_column_update(DYNAMIC_COLUMN *org, uint column_nr,
DYNAMIC_COLUMN_VALUE *value);
enum enum_dyncol_func_result
dynamic_column_update_many(DYNAMIC_COLUMN *str,
uint add_column_count,
uint *column_numbers,
DYNAMIC_COLUMN_VALUE *values);
enum enum_dyncol_func_result
dynamic_column_exists(DYNAMIC_COLUMN *org, uint column_nr);
enum enum_dyncol_func_result
dynamic_column_list(DYNAMIC_COLUMN *org, DYNAMIC_ARRAY *array_of_uint);
enum enum_dyncol_func_result
dynamic_column_get(DYNAMIC_COLUMN *org, uint column_nr,
DYNAMIC_COLUMN_VALUE *store_it_here);
#endif
/* new functions */
enum enum_dyncol_func_result
mariadb_dyncol_create_many_num(DYNAMIC_COLUMN *str,
uint column_count,
uint *column_numbers,
DYNAMIC_COLUMN_VALUE *values,
my_bool new_string);
enum enum_dyncol_func_result
mariadb_dyncol_create_many_named(DYNAMIC_COLUMN *str,
uint column_count,
MYSQL_LEX_STRING *column_keys,
DYNAMIC_COLUMN_VALUE *values,
my_bool new_string);
enum enum_dyncol_func_result
mariadb_dyncol_update_many_num(DYNAMIC_COLUMN *str,
uint add_column_count,
uint *column_keys,
DYNAMIC_COLUMN_VALUE *values);
enum enum_dyncol_func_result
mariadb_dyncol_update_many_named(DYNAMIC_COLUMN *str,
uint add_column_count,
MYSQL_LEX_STRING *column_keys,
DYNAMIC_COLUMN_VALUE *values);
enum enum_dyncol_func_result
mariadb_dyncol_exists_num(DYNAMIC_COLUMN *org, uint column_nr);
enum enum_dyncol_func_result
mariadb_dyncol_exists_named(DYNAMIC_COLUMN *str, MYSQL_LEX_STRING *name);
/* List of not NULL columns */
enum enum_dyncol_func_result
mariadb_dyncol_list_num(DYNAMIC_COLUMN *str, uint *count, uint **nums);
enum enum_dyncol_func_result
mariadb_dyncol_list_named(DYNAMIC_COLUMN *str, uint *count,
MYSQL_LEX_STRING **names);
/*
if the column do not exists it is NULL
*/
enum enum_dyncol_func_result
mariadb_dyncol_get_num(DYNAMIC_COLUMN *org, uint column_nr,
DYNAMIC_COLUMN_VALUE *store_it_here);
enum enum_dyncol_func_result
mariadb_dyncol_get_named(DYNAMIC_COLUMN *str, MYSQL_LEX_STRING *name,
DYNAMIC_COLUMN_VALUE *store_it_here);
my_bool mariadb_dyncol_has_names(DYNAMIC_COLUMN *str);
enum enum_dyncol_func_result
mariadb_dyncol_check(DYNAMIC_COLUMN *str);
enum enum_dyncol_func_result
mariadb_dyncol_json(DYNAMIC_COLUMN *str, DYNAMIC_STRING *json);
#define mariadb_dyncol_init(A) memset((A), 0, sizeof(*(A)))
void mariadb_dyncol_free(DYNAMIC_COLUMN *str);
/* conversion of values to 3 base types */
enum enum_dyncol_func_result
mariadb_dyncol_val_str(DYNAMIC_STRING *str, DYNAMIC_COLUMN_VALUE *val,
CHARSET_INFO *cs, my_bool quote);
enum enum_dyncol_func_result
mariadb_dyncol_val_long(longlong *ll, DYNAMIC_COLUMN_VALUE *val);
enum enum_dyncol_func_result
mariadb_dyncol_val_double(double *dbl, DYNAMIC_COLUMN_VALUE *val);
enum enum_dyncol_func_result
mariadb_dyncol_unpack(DYNAMIC_COLUMN *str,
uint *count,
MYSQL_LEX_STRING **names, DYNAMIC_COLUMN_VALUE **vals);
void mariadb_dyncol_unpack_free(MYSQL_LEX_STRING *names,
DYNAMIC_COLUMN_VALUE *vals);
int mariadb_dyncol_column_cmp_named(const MYSQL_LEX_STRING *s1,
const MYSQL_LEX_STRING *s2);
enum enum_dyncol_func_result
mariadb_dyncol_column_count(DYNAMIC_COLUMN *str, uint *column_count);
#define mariadb_dyncol_value_init(V) (V)->type= DYN_COL_NULL
/*
Prepare value for using as decimal
*/
void mariadb_dyncol_prepare_decimal(DYNAMIC_COLUMN_VALUE *value);
#ifdef __cplusplus
}
#endif
#endif
PK ! D5
little_endian.hnu [ /* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/*
Data in little-endian format.
*/
#ifndef MY_BYTE_ORDER_ARCH_OPTIMIZED
#define float4get(V,M) memcpy(&V, (M), sizeof(float))
#define float4store(V,M) memcpy(V, (&M), sizeof(float))
#define float8get(V,M) doubleget((V),(M))
#define float8store(V,M) doublestore((V),(M))
/* Bi-endian hardware.... */
#if defined(__FLOAT_WORD_ORDER) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN)
#define doublestore(T,V) do { *(((char*)T)+0)=(char) ((uchar *) &V)[4];\
*(((char*)T)+1)=(char) ((uchar *) &V)[5];\
*(((char*)T)+2)=(char) ((uchar *) &V)[6];\
*(((char*)T)+3)=(char) ((uchar *) &V)[7];\
*(((char*)T)+4)=(char) ((uchar *) &V)[0];\
*(((char*)T)+5)=(char) ((uchar *) &V)[1];\
*(((char*)T)+6)=(char) ((uchar *) &V)[2];\
*(((char*)T)+7)=(char) ((uchar *) &V)[3]; }\
while(0)
#define doubleget(V,M) do { double def_temp;\
((uchar*) &def_temp)[0]=(M)[4];\
((uchar*) &def_temp)[1]=(M)[5];\
((uchar*) &def_temp)[2]=(M)[6];\
((uchar*) &def_temp)[3]=(M)[7];\
((uchar*) &def_temp)[4]=(M)[0];\
((uchar*) &def_temp)[5]=(M)[1];\
((uchar*) &def_temp)[6]=(M)[2];\
((uchar*) &def_temp)[7]=(M)[3];\
(V) = def_temp; } while(0)
#else /* Bi-endian hardware.... */
/* Cast away type qualifiers (necessary as macro takes argument by value). */
#define doublestore(T,V) memcpy((T), (void*) &V, sizeof(double))
#define doubleget(V,M) memcpy(&V, (M), sizeof(double))
#endif /* Bi-endian hardware.... */
#endif /* !MY_BYTE_ORDER_ARCH_OPTIMIZED */
#define ushortget(V,M) do { uchar *pM= (uchar*)(M);V = uint2korr(pM);} while(0)
#define shortget(V,M) do { uchar *pM= (uchar*)(M);V = sint2korr(pM);} while(0)
#define longget(V,M) do { uchar *pM= (uchar*)(M);V = sint4korr(pM);} while(0)
#define ulongget(V,M) do { uchar *pM= (uchar*)(M);V = uint4korr(pM);} while(0)
#define shortstore(T,V) int2store(T,V)
#define longstore(T,V) int4store(T,V)
#ifndef floatstore
/* Cast away type qualifiers (necessary as macro takes argument by value). */
#define floatstore(T,V) memcpy((T), (void*) (&V), sizeof(float))
#define floatget(V,M) memcpy(&V, (M), sizeof(float))
#endif
#ifndef doubleget
#define doubleget(V,M) memcpy(&V, (M), sizeof(double))
#define doublestore(T,V) memcpy((T), (void *) &V, sizeof(double))
#endif /* doubleget */
#define longlongget(V,M) memcpy(&V, (M), sizeof(ulonglong))
#define longlongstore(T,V) memcpy((T), &V, sizeof(ulonglong))
PK ! Y/@G my_alloca.hnu [ /* Copyright (c) 2023, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MY_ALLOCA_INCLUDED
#define MY_ALLOCA_INCLUDED
#ifdef _WIN32
#include /*for alloca*/
/*
MSVC may define "alloca" when compiling in /Ze mode
(with extensions from Microsoft), but otherwise only
the _alloca function is defined:
*/
#ifndef alloca
#define alloca _alloca
#endif
#else
#ifdef HAVE_ALLOCA_H
#include
#endif
#endif
#if defined(_AIX) && !defined(__GNUC__) && !defined(_AIX43)
#pragma alloca
#endif /* _AIX */
/*
If the GCC/LLVM compiler from the MinGW is used,
alloca may not be defined when using the MSVC CRT:
*/
#if defined(__GNUC__) && !defined(HAVE_ALLOCA_H) && !defined(alloca)
#define alloca __builtin_alloca
#endif /* GNUC */
#endif /* MY_ALLOCA_INCLUDED */
PK ! ֕
my_attribute.hnu [ /* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/*
Helper macros used for setting different __attributes__
on functions in a portable fashion
*/
#ifndef _my_attribute_h
#define _my_attribute_h
#if defined(__GNUC__)
# ifndef GCC_VERSION
# define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
# endif
#endif
/*
Disable __attribute__() on gcc < 2.7, g++ < 3.4, and non-gcc compilers.
Some forms of __attribute__ are actually supported in earlier versions of
g++, but we just disable them all because we only use them to generate
compilation warnings.
*/
#ifndef __attribute__
# if !defined(__GNUC__) && !defined(__clang__)
# define __attribute__(A)
# elif defined(__GNUC__)
# ifndef GCC_VERSION
# define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
# endif
# if GCC_VERSION < 2008
# define __attribute__(A)
# elif defined(__cplusplus) && GCC_VERSION < 3004
# define __attribute__(A)
# endif
# endif
#endif
/*
__attribute__((format(...))) is only supported in gcc >= 2.8 and g++ >= 3.4
But that's already covered by the __attribute__ tests above, so this is
just a convenience macro.
*/
#ifndef ATTRIBUTE_FORMAT
# define ATTRIBUTE_FORMAT(style, m, n) __attribute__((format(style, m, n)))
#endif
/*
__attribute__((format(...))) on a function pointer is not supported
until gcc 3.1
*/
#ifndef ATTRIBUTE_FORMAT_FPTR
# if (GCC_VERSION >= 3001)
# define ATTRIBUTE_FORMAT_FPTR(style, m, n) ATTRIBUTE_FORMAT(style, m, n)
# else
# define ATTRIBUTE_FORMAT_FPTR(style, m, n)
# endif /* GNUC >= 3.1 */
#endif
/* gcc 7.5.0 does not support __attribute__((no_sanitize("undefined")) */
#ifndef ATTRIBUTE_NO_UBSAN
# if (GCC_VERSION >= 8000) || defined(__clang__)
# define ATTRIBUTE_NO_UBSAN __attribute__((no_sanitize("undefined")))
# elif (GCC_VERSION >= 6001)
# define ATTRIBUTE_NO_UBSAN __attribute__((no_sanitize_undefined))
# else
# define ATTRIBUTE_NO_UBSAN
# endif
#endif
/* Define pragmas to disable warnings for stack frame checking */
#ifdef __GNUC__
#define PRAGMA_DISABLE_CHECK_STACK_FRAME \
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Wframe-larger-than=\"")
#define PRAGMA_REENABLE_CHECK_STACK_FRAME \
_Pragma("GCC diagnostic pop")
/*
The following check is for older gcc version that allocates
a lot of stack during startup that does not need to be checked
*/
#if !defined(__clang__) && __GNUC__ < 13
#define PRAGMA_DISABLE_CHECK_STACK_FRAME_EXTRA PRAGMA_DISABLE_CHECK_STACK_FRAME
#else
#define PRAGMA_DISABLE_CHECK_STACK_FRAME_EXTRA
#endif /* !defined(__clang__) && __GNUC__ < 13 */
#else /*! __GNUC__ */
#define PRAGMA_DISABLE_CHECK_STACK_FRAME
#define PRAGMA_REENABLE_CHECK_STACK_FRAME
#define PRAGMA_DISABLE_CHECK_STACK_FRAME
#define PRAGMA_DISABLE_CHECK_STACK_FRAME_EXTRA
#endif /* __GNUC__ */
#endif /* _my_attribute_h */
PK ! gK handler_state.hnu [ /*
Map handler error message to sql states. Note that this list MUST be in
increasing order!
See sql_state.c for usage
*/
{ HA_ERR_KEY_NOT_FOUND, "02000", "" },
{ HA_ERR_FOUND_DUPP_KEY, "23000", "" },
{ HA_ERR_WRONG_COMMAND, "0A000", "" },
{ HA_ERR_UNSUPPORTED, "0A000", "" },
{ HA_WRONG_CREATE_OPTION, "0A000", "" },
{ HA_ERR_FOUND_DUPP_UNIQUE, "23000", "" },
{ HA_ERR_UNKNOWN_CHARSET, "0A000", "" },
{ HA_ERR_READ_ONLY_TRANSACTION, "25000", "" },
{ HA_ERR_LOCK_DEADLOCK, "40001", "" },
{ HA_ERR_NO_REFERENCED_ROW, "23000", "" },
{ HA_ERR_ROW_IS_REFERENCED, "23000", "" },
{ HA_ERR_TABLE_EXIST, "42S01", "" },
{ HA_ERR_FOREIGN_DUPLICATE_KEY, "23000", "" },
{ HA_ERR_TABLE_READONLY, "25000", "" },
{ HA_ERR_AUTOINC_ERANGE, "22003", "" },
PK ! H97 7
json_lib.hnu [ #ifndef JSON_LIB_INCLUDED
#define JSON_LIB_INCLUDED
#include
#ifdef __cplusplus
extern "C" {
#endif
#define JSON_DEPTH_LIMIT 32
/*
When error happens, the c_next of the JSON engine contains the
character that caused the error, and the c_str is the position
in string where the error occurs.
*/
enum json_errors {
JE_BAD_CHR= -1, /* Invalid character, charset handler cannot read it. */
JE_NOT_JSON_CHR= -2, /* Character met not used in JSON. */
/* ASCII 00-08 for instance. */
JE_EOS= -3, /* Unexpected end of string. */
JE_SYN= -4, /* The next character breaks the JSON syntax. */
JE_STRING_CONST= -5, /* Character disallowed in string constant. */
JE_ESCAPING= -6, /* Error in the escaping. */
JE_DEPTH= -7, /* The limit on the JSON depth was overrun. */
};
typedef struct st_json_string_t
{
const uchar *c_str; /* Current position in JSON string */
const uchar *str_end; /* The end on the string. */
my_wc_t c_next; /* UNICODE of the last read character */
int c_next_len; /* character lenght of the last read character. */
int error; /* error code. */
CHARSET_INFO *cs; /* Character set of the JSON string. */
my_charset_conv_mb_wc wc; /* UNICODE conversion function. */
/* It's taken out of the cs just to speed calls. */
} json_string_t;
void json_string_set_cs(json_string_t *s, CHARSET_INFO *i_cs);
void json_string_set_str(json_string_t *s,
const uchar *str, const uchar *end);
#define json_next_char(j) \
((j)->c_next_len= (j)->wc((j)->cs, &(j)->c_next, (j)->c_str, (j)->str_end))
#define json_eos(j) ((j)->c_str >= (j)->str_end)
/*
read_string_const_chr() reads the next character of the string constant
and saves it to the js->c_next.
It takes into account possible escapings, so if for instance
the string is '\b', the read_string_const_chr() sets 8.
*/
int json_read_string_const_chr(json_string_t *js);
/*
Various JSON-related operations expect JSON path as a parameter.
The path is a string like this "$.keyA[2].*"
The path itself is a number of steps specifying either a key or a position
in an array. Some of them can be wildcards.
So the representation of the JSON path is the json_path_t class
containing an array of json_path_step_t objects.
*/
/* Path step types - actually bitmasks to let '&' or '|' operations. */
enum json_path_step_types
{
JSON_PATH_KEY_NULL=0,
JSON_PATH_KEY=1, /* Must be equal to JSON_VALUE_OBJECT. */
JSON_PATH_ARRAY=2, /* Must be equal to JSON_VALUE_ARRAY. */
JSON_PATH_KEY_OR_ARRAY=3,
JSON_PATH_WILD=4, /* Step like .* or [*] */
JSON_PATH_DOUBLE_WILD=8, /* Step like **.k or **[1] */
JSON_PATH_KEY_WILD= 1+4,
JSON_PATH_KEY_DOUBLEWILD= 1+8,
JSON_PATH_ARRAY_WILD= 2+4,
JSON_PATH_ARRAY_DOUBLEWILD= 2+8,
JSON_PATH_NEGATIVE_INDEX= 16,
JSON_PATH_ARRAY_RANGE= 32
};
typedef struct st_json_path_step_t
{
enum json_path_step_types type; /* The type of the step - */
/* see json_path_step_types */
const uchar *key; /* Pointer to the beginning of the key. */
const uchar *key_end; /* Pointer to the end of the key. */
int n_item; /* Item number in an array. No meaning for the key step. */
int n_item_end; /* Last index of the range. */
} json_path_step_t;
typedef struct st_json_path_t
{
json_string_t s; /* The string to be parsed. */
json_path_step_t steps[JSON_DEPTH_LIMIT]; /* Steps of the path. */
json_path_step_t *last_step; /* Points to the last step. */
int mode_strict; /* TRUE if the path specified as 'strict' */
enum json_path_step_types types_used; /* The '|' of all step's 'type'-s */
} json_path_t;
int json_path_setup(json_path_t *p,
CHARSET_INFO *i_cs, const uchar *str, const uchar *end);
/*
The set of functions and structures below provides interface
to the JSON text parser.
Running the parser normally goes like this:
json_engine_t j_eng; // structure keeps parser's data
json_scan_start(j_eng) // begin the parsing
do
{
// The parser has read next piece of JSON
// and set fields of j_eng structure accordingly.
// So let's see what we have:
switch (j_eng.state)
{
case JST_KEY:
// Handle key name. See the json_read_keyname_chr()
// Probably compare it with the keyname we're looking for
case JST_VALUE:
// Handle value. It is either value of the key or an array item.
// see the json_read_value()
case JST_OBJ_START:
// parser found an object (the '{' in JSON)
case JST_OBJ_END:
// parser found the end of the object (the '}' in JSON)
case JST_ARRAY_START:
// parser found an array (the '[' in JSON)
case JST_ARRAY_END:
// parser found the end of the array (the ']' in JSON)
};
} while (json_scan_next() == 0); // parse next structure
if (j_eng.s.error) // we need to check why the loop ended.
// Did we get to the end of JSON, or came upon error.
{
signal_error_in_JSON()
}
Parts of JSON can be quickly skipped. If we are not interested
in a particular key, we can just skip it with json_skip_key() call.
Similarly json_skip_level() goes right to the end of an object
or an array.
*/
/* These are JSON parser states that user can expect and handle. */
enum json_states {
JST_VALUE, /* value found */
JST_KEY, /* key found */
JST_OBJ_START, /* object */
JST_OBJ_END, /* object ended */
JST_ARRAY_START, /* array */
JST_ARRAY_END, /* array ended */
NR_JSON_USER_STATES
};
enum json_value_types
{
JSON_VALUE_UNINITIALIZED=0,
JSON_VALUE_OBJECT=1,
JSON_VALUE_ARRAY=2,
JSON_VALUE_STRING=3,
JSON_VALUE_NUMBER=4,
JSON_VALUE_TRUE=5,
JSON_VALUE_FALSE=6,
JSON_VALUE_NULL=7
};
enum json_num_flags
{
JSON_NUM_NEG=1, /* Number is negative. */
JSON_NUM_FRAC_PART=2, /* The fractional part is not empty. */
JSON_NUM_EXP=4, /* The number has the 'e' part. */
};
typedef struct st_json_engine_t
{
json_string_t s; /* String to parse. */
int sav_c_len; /* Length of the current character.
Can be more than 1 for multibyte charsets */
int state; /* The state of the parser. One of 'enum json_states'.
It tells us what construction of JSON we've just read. */
/* These values are only set after the json_read_value() call. */
enum json_value_types value_type; /* type of the value.*/
const uchar *value; /* Points to the value. */
const uchar *value_begin;/* Points to where the value starts in the JSON. */
int value_escaped; /* Flag telling if the string value has escaping.*/
uint num_flags; /* the details of the JSON_VALUE_NUMBER, is it negative,
or if it has the fractional part.
See the enum json_num_flags. */
/*
In most cases the 'value' and 'value_begin' are equal.
They only differ if the value is a string constants. Then 'value_begin'
points to the starting quotation mark, while the 'value' - to
the first character of the string.
*/
const uchar *value_end; /* Points to the next character after the value. */
int value_len; /* The length of the value. Does not count quotations for */
/* string constants. */
int stack[JSON_DEPTH_LIMIT]; /* Keeps the stack of nested JSON structures. */
int stack_p; /* The 'stack' pointer. */
volatile uchar *killed_ptr;
} json_engine_t;
int json_scan_start(json_engine_t *je,
CHARSET_INFO *i_cs, const uchar *str, const uchar *end);
int json_scan_next(json_engine_t *j);
/*
json_read_keyname_chr() function assists parsing the name of an JSON key.
It only can be called when the json_engine is in JST_KEY.
The json_read_keyname_chr() reads one character of the name of the key,
and puts it in j_eng.s.next_c.
Typical usage is like this:
if (j_eng.state == JST_KEY)
{
while (json_read_keyname_chr(&j) == 0)
{
//handle next character i.e. match it against the pattern
}
}
*/
int json_read_keyname_chr(json_engine_t *j);
/*
Check if the name of the current JSON key matches
the step of the path.
*/
int json_key_matches(json_engine_t *je, json_string_t *k);
/*
json_read_value() function parses the JSON value syntax,
so that we can handle the value of a key or an array item.
It only returns meaningful result when the engine is in
the JST_VALUE state.
Typical usage is like this:
if (j_eng.state == JST_VALUE)
{
json_read_value(&j_eng);
switch(j_eng.value_type)
{
case JSON_VALUE_STRING:
// get the string
str= j_eng.value;
str_length= j_eng.value_len;
case JSON_VALUE_NUMBER:
// get the number
... etc
}
*/
int json_read_value(json_engine_t *j);
/*
json_skip_key() makes parser skip the content of the current
JSON key quickly.
It can be called only when the json_engine state is JST_KEY.
Typical usage is:
if (j_eng.state == JST_KEY)
{
if (key_does_not_match(j_eng))
json_skip_key(j_eng);
}
*/
int json_skip_key(json_engine_t *j);
typedef const int *json_level_t;
/*
json_skip_to_level() makes parser quickly get out of nested
loops and arrays. It is used when we're not interested in what is
there in the rest of these structures.
The 'level' should be remembered in advance.
json_level_t level= json_get_level(j);
.... // getting into the nested JSON structures
json_skip_to_level(j, level);
*/
#define json_get_level(j) (j->stack_p)
int json_skip_to_level(json_engine_t *j, int level);
/*
json_skip_level() works as above with just current structure.
So it gets to the end of the current JSON array or object.
*/
#define json_skip_level(json_engine) \
json_skip_to_level((json_engine), (json_engine)->stack_p)
/*
works as json_skip_level() but also counts items on the current
level skipped.
*/
int json_skip_level_and_count(json_engine_t *j, int *n_items_skipped);
#define json_skip_array_item json_skip_key
/*
Checks if the current value is of scalar type -
not an OBJECT nor ARRAY.
*/
#define json_value_scalar(je) ((je)->value_type > JSON_VALUE_ARRAY)
/*
Look for the JSON PATH in the json string.
Function can be called several times with same JSON/PATH to
find multiple matches.
On the first call, the json_engine_t parameter should be
initialized with the JSON string, and the json_path_t with the JSON path
appropriately. The 'p_cur_step' should point at the first
step of the path.
The 'array_counters' is the array of JSON_DEPTH_LIMIT size.
It stores the array counters of the parsed JSON.
If function returns 0, it means it found the match. The position of
the match is je->s.c_str. Then we can call the json_find_path()
with same engine/path/p_cur_step to get the next match.
Non-zero return means no matches found.
Check je->s.error to see if there was an error in JSON.
*/
int json_find_path(json_engine_t *je,
json_path_t *p, json_path_step_t **p_cur_step,
int *array_counters);
typedef struct st_json_find_paths_t
{
uint n_paths;
json_path_t *paths;
uint cur_depth;
uint *path_depths;
int array_counters[JSON_DEPTH_LIMIT];
} json_find_paths_t;
int json_find_paths_first(json_engine_t *je, json_find_paths_t *state,
uint n_paths, json_path_t *paths, uint *path_depths);
int json_find_paths_next(json_engine_t *je, json_find_paths_t *state);
#define JSON_ERROR_OUT_OF_SPACE (-1)
#define JSON_ERROR_ILLEGAL_SYMBOL (-2)
/*
Convert JSON string constant into ordinary string constant
which can involve unpacking json escapes and changing character set.
Returns negative integer in the case of an error,
the length of the result otherwise.
*/
int __attribute__((warn_unused_result)) json_unescape(CHARSET_INFO *json_cs,
const uchar *json_str, const uchar *json_end,
CHARSET_INFO *res_cs,
uchar *res, uchar *res_end);
/*
Convert a string constant into JSON string constant.
This can involve appropriate escaping and changing the character set.
Returns the length of the result on success,
on error returns a negative error code.
Some error codes:
JSON_ERROR_OUT_OF_SPACE Not enough space in the provided buffer
JSON_ERROR_ILLEGAL_SYMBOL Source symbol cannot be represented in JSON
*/
int __attribute__((warn_unused_result)) json_escape(CHARSET_INFO *str_cs,
const uchar *str, const uchar *str_end,
CHARSET_INFO *json_cs, uchar *json, uchar *json_end);
/*
Appends the ASCII string to the json with the charset conversion.
*/
int json_append_ascii(CHARSET_INFO *json_cs,
uchar *json, uchar *json_end,
const uchar *ascii, const uchar *ascii_end);
/*
Scan the JSON and return paths met one-by-one.
json_get_path_start(&p)
while (json_get_path_next(&p))
{
handle_the_next_path();
}
*/
int json_get_path_start(json_engine_t *je, CHARSET_INFO *i_cs,
const uchar *str, const uchar *end,
json_path_t *p);
int json_get_path_next(json_engine_t *je, json_path_t *p);
int json_path_compare(const json_path_t *a, const json_path_t *b,
enum json_value_types vt, const int* array_size_counter);
int json_valid(const char *js, size_t js_len, CHARSET_INFO *cs);
int json_locate_key(const char *js, const char *js_end,
const char *kname,
const char **key_start, const char **key_end,
int *comma_pos);
int json_normalize(DYNAMIC_STRING *result,
const char *s, size_t size, CHARSET_INFO *cs);
int json_skip_array_and_count(json_engine_t *j, int* n_item);
inline static int json_scan_ended(json_engine_t *j)
{
return (j->state == JST_ARRAY_END && j->stack_p == 0);
}
#ifdef __cplusplus
}
#endif
#endif /* JSON_LIB_INCLUDED */
PK ! : : sql_state.hnu [ /* Autogenerated file, please don't edit */
{ ER_DUP_KEY ,"23000", "" },
{ ER_OUTOFMEMORY ,"HY001", "S1001" },
{ ER_OUT_OF_SORTMEMORY ,"HY001", "S1001" },
{ ER_CON_COUNT_ERROR ,"08004", "" },
{ ER_BAD_HOST_ERROR ,"08S01", "" },
{ ER_HANDSHAKE_ERROR ,"08S01", "" },
{ ER_DBACCESS_DENIED_ERROR ,"42000", "" },
{ ER_ACCESS_DENIED_ERROR ,"28000", "" },
{ ER_NO_DB_ERROR ,"3D000", "" },
{ ER_UNKNOWN_COM_ERROR ,"08S01", "" },
{ ER_BAD_NULL_ERROR ,"23000", "" },
{ ER_BAD_DB_ERROR ,"42000", "" },
{ ER_TABLE_EXISTS_ERROR ,"42S01", "" },
{ ER_BAD_TABLE_ERROR ,"42S02", "" },
{ ER_NON_UNIQ_ERROR ,"23000", "" },
{ ER_SERVER_SHUTDOWN ,"08S01", "" },
{ ER_BAD_FIELD_ERROR ,"42S22", "S0022" },
{ ER_WRONG_FIELD_WITH_GROUP ,"42000", "S1009" },
{ ER_WRONG_GROUP_FIELD ,"42000", "S1009" },
{ ER_WRONG_SUM_SELECT ,"42000", "S1009" },
{ ER_WRONG_VALUE_COUNT ,"21S01", "" },
{ ER_TOO_LONG_IDENT ,"42000", "S1009" },
{ ER_DUP_FIELDNAME ,"42S21", "S1009" },
{ ER_DUP_KEYNAME ,"42000", "S1009" },
{ ER_DUP_ENTRY ,"23000", "S1009" },
{ ER_WRONG_FIELD_SPEC ,"42000", "S1009" },
{ ER_PARSE_ERROR ,"42000", "s1009" },
{ ER_EMPTY_QUERY ,"42000", "" },
{ ER_NONUNIQ_TABLE ,"42000", "S1009" },
{ ER_INVALID_DEFAULT ,"42000", "S1009" },
{ ER_MULTIPLE_PRI_KEY ,"42000", "S1009" },
{ ER_TOO_MANY_KEYS ,"42000", "S1009" },
{ ER_TOO_MANY_KEY_PARTS ,"42000", "S1009" },
{ ER_TOO_LONG_KEY ,"42000", "S1009" },
{ ER_KEY_COLUMN_DOES_NOT_EXIST ,"42000", "S1009" },
{ ER_BLOB_USED_AS_KEY ,"42000", "S1009" },
{ ER_TOO_BIG_FIELDLENGTH ,"42000", "S1009" },
{ ER_WRONG_AUTO_KEY ,"42000", "S1009" },
{ ER_FORCING_CLOSE ,"08S01", "" },
{ ER_IPSOCK_ERROR ,"08S01", "" },
{ ER_NO_SUCH_INDEX ,"42S12", "S1009" },
{ ER_WRONG_FIELD_TERMINATORS ,"42000", "S1009" },
{ ER_BLOBS_AND_NO_TERMINATED ,"42000", "S1009" },
{ ER_CANT_REMOVE_ALL_FIELDS ,"42000", "" },
{ ER_CANT_DROP_FIELD_OR_KEY ,"42000", "" },
{ ER_WRONG_DB_NAME ,"42000", "" },
{ ER_WRONG_TABLE_NAME ,"42000", "" },
{ ER_TOO_BIG_SELECT ,"42000", "" },
{ ER_UNKNOWN_PROCEDURE ,"42000", "" },
{ ER_WRONG_PARAMCOUNT_TO_PROCEDURE ,"42000", "" },
{ ER_UNKNOWN_TABLE ,"42S02", "" },
{ ER_FIELD_SPECIFIED_TWICE ,"42000", "" },
{ ER_UNSUPPORTED_EXTENSION ,"42000", "" },
{ ER_TABLE_MUST_HAVE_COLUMNS ,"42000", "" },
{ ER_UNKNOWN_CHARACTER_SET ,"42000", "" },
{ ER_TOO_BIG_ROWSIZE ,"42000", "" },
{ ER_WRONG_OUTER_JOIN ,"42000", "" },
{ ER_NULL_COLUMN_IN_INDEX ,"42000", "" },
{ ER_PASSWORD_ANONYMOUS_USER ,"42000", "" },
{ ER_PASSWORD_NOT_ALLOWED ,"42000", "" },
{ ER_PASSWORD_NO_MATCH ,"28000", "" },
{ ER_WRONG_VALUE_COUNT_ON_ROW ,"21S01", "" },
{ ER_INVALID_USE_OF_NULL ,"22004", "" },
{ ER_REGEXP_ERROR ,"42000", "" },
{ ER_MIX_OF_GROUP_FUNC_AND_FIELDS ,"42000", "" },
{ ER_NONEXISTING_GRANT ,"42000", "" },
{ ER_TABLEACCESS_DENIED_ERROR ,"42000", "" },
{ ER_COLUMNACCESS_DENIED_ERROR ,"42000", "" },
{ ER_ILLEGAL_GRANT_FOR_TABLE ,"42000", "" },
{ ER_GRANT_WRONG_HOST_OR_USER ,"42000", "" },
{ ER_NO_SUCH_TABLE ,"42S02", "" },
{ ER_NONEXISTING_TABLE_GRANT ,"42000", "" },
{ ER_NOT_ALLOWED_COMMAND ,"42000", "" },
{ ER_SYNTAX_ERROR ,"42000", "" },
{ ER_ABORTING_CONNECTION ,"08S01", "" },
{ ER_NET_PACKET_TOO_LARGE ,"08S01", "" },
{ ER_NET_READ_ERROR_FROM_PIPE ,"08S01", "" },
{ ER_NET_FCNTL_ERROR ,"08S01", "" },
{ ER_NET_PACKETS_OUT_OF_ORDER ,"08S01", "" },
{ ER_NET_UNCOMPRESS_ERROR ,"08S01", "" },
{ ER_NET_READ_ERROR ,"08S01", "" },
{ ER_NET_READ_INTERRUPTED ,"08S01", "" },
{ ER_NET_ERROR_ON_WRITE ,"08S01", "" },
{ ER_NET_WRITE_INTERRUPTED ,"08S01", "" },
{ ER_TOO_LONG_STRING ,"42000", "" },
{ ER_TABLE_CANT_HANDLE_BLOB ,"42000", "" },
{ ER_TABLE_CANT_HANDLE_AUTO_INCREMENT ,"42000", "" },
{ ER_WRONG_COLUMN_NAME ,"42000", "" },
{ ER_WRONG_KEY_COLUMN ,"42000", "" },
{ ER_DUP_UNIQUE ,"23000", "" },
{ ER_BLOB_KEY_WITHOUT_LENGTH ,"42000", "" },
{ ER_PRIMARY_CANT_HAVE_NULL ,"42000", "" },
{ ER_TOO_MANY_ROWS ,"42000", "" },
{ ER_REQUIRES_PRIMARY_KEY ,"42000", "" },
{ ER_KEY_DOES_NOT_EXISTS ,"42000", "S1009" },
{ ER_CHECK_NO_SUCH_TABLE ,"42000", "" },
{ ER_CHECK_NOT_IMPLEMENTED ,"42000", "" },
{ ER_CANT_DO_THIS_DURING_AN_TRANSACTION ,"25000", "" },
{ ER_NEW_ABORTING_CONNECTION ,"08S01", "" },
{ ER_MASTER_NET_READ ,"08S01", "" },
{ ER_MASTER_NET_WRITE ,"08S01", "" },
{ ER_TOO_MANY_USER_CONNECTIONS ,"42000", "" },
{ ER_READ_ONLY_TRANSACTION ,"25000", "" },
{ ER_NO_PERMISSION_TO_CREATE_USER ,"42000", "" },
{ ER_LOCK_DEADLOCK ,"40001", "" },
{ ER_NO_REFERENCED_ROW ,"23000", "" },
{ ER_ROW_IS_REFERENCED ,"23000", "" },
{ ER_CONNECT_TO_MASTER ,"08S01", "" },
{ ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT ,"21000", "" },
{ ER_USER_LIMIT_REACHED ,"42000", "" },
{ ER_SPECIFIC_ACCESS_DENIED_ERROR ,"42000", "" },
{ ER_NO_DEFAULT ,"42000", "" },
{ ER_WRONG_VALUE_FOR_VAR ,"42000", "" },
{ ER_WRONG_TYPE_FOR_VAR ,"42000", "" },
{ ER_CANT_USE_OPTION_HERE ,"42000", "" },
{ ER_NOT_SUPPORTED_YET ,"42000", "" },
{ ER_WRONG_FK_DEF ,"42000", "" },
{ ER_OPERAND_COLUMNS ,"21000", "" },
{ ER_SUBQUERY_NO_1_ROW ,"21000", "" },
{ ER_ILLEGAL_REFERENCE ,"42S22", "" },
{ ER_DERIVED_MUST_HAVE_ALIAS ,"42000", "" },
{ ER_SELECT_REDUCED ,"01000", "" },
{ ER_TABLENAME_NOT_ALLOWED_HERE ,"42000", "" },
{ ER_NOT_SUPPORTED_AUTH_MODE ,"08004", "" },
{ ER_SPATIAL_CANT_HAVE_NULL ,"42000", "" },
{ ER_COLLATION_CHARSET_MISMATCH ,"42000", "" },
{ ER_WARN_TOO_FEW_RECORDS ,"01000", "" },
{ ER_WARN_TOO_MANY_RECORDS ,"01000", "" },
{ ER_WARN_NULL_TO_NOTNULL ,"22004", "" },
{ ER_WARN_DATA_OUT_OF_RANGE ,"22003", "" },
{ WARN_DATA_TRUNCATED ,"01000", "" },
{ ER_WRONG_NAME_FOR_INDEX ,"42000", "" },
{ ER_WRONG_NAME_FOR_CATALOG ,"42000", "" },
{ ER_UNKNOWN_STORAGE_ENGINE ,"42000", "" },
{ ER_TRUNCATED_WRONG_VALUE ,"22007", "" },
{ ER_SP_NO_RECURSIVE_CREATE ,"2F003", "" },
{ ER_SP_ALREADY_EXISTS ,"42000", "" },
{ ER_SP_DOES_NOT_EXIST ,"42000", "" },
{ ER_SP_LILABEL_MISMATCH ,"42000", "" },
{ ER_SP_LABEL_REDEFINE ,"42000", "" },
{ ER_SP_LABEL_MISMATCH ,"42000", "" },
{ ER_SP_UNINIT_VAR ,"01000", "" },
{ ER_SP_BADSELECT ,"0A000", "" },
{ ER_SP_BADRETURN ,"42000", "" },
{ ER_SP_BADSTATEMENT ,"0A000", "" },
{ ER_UPDATE_LOG_DEPRECATED_IGNORED ,"42000", "" },
{ ER_UPDATE_LOG_DEPRECATED_TRANSLATED ,"42000", "" },
{ ER_QUERY_INTERRUPTED ,"70100", "" },
{ ER_SP_WRONG_NO_OF_ARGS ,"42000", "" },
{ ER_SP_COND_MISMATCH ,"42000", "" },
{ ER_SP_NORETURN ,"42000", "" },
{ ER_SP_NORETURNEND ,"2F005", "" },
{ ER_SP_BAD_CURSOR_QUERY ,"42000", "" },
{ ER_SP_BAD_CURSOR_SELECT ,"42000", "" },
{ ER_SP_CURSOR_MISMATCH ,"42000", "" },
{ ER_SP_CURSOR_ALREADY_OPEN ,"24000", "" },
{ ER_SP_CURSOR_NOT_OPEN ,"24000", "" },
{ ER_SP_UNDECLARED_VAR ,"42000", "" },
{ ER_SP_FETCH_NO_DATA ,"02000", "" },
{ ER_SP_DUP_PARAM ,"42000", "" },
{ ER_SP_DUP_VAR ,"42000", "" },
{ ER_SP_DUP_COND ,"42000", "" },
{ ER_SP_DUP_CURS ,"42000", "" },
{ ER_SP_SUBSELECT_NYI ,"0A000", "" },
{ ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG ,"0A000", "" },
{ ER_SP_VARCOND_AFTER_CURSHNDLR ,"42000", "" },
{ ER_SP_CURSOR_AFTER_HANDLER ,"42000", "" },
{ ER_SP_CASE_NOT_FOUND ,"20000", "" },
{ ER_DIVISION_BY_ZERO ,"22012", "" },
{ ER_TRUNCATED_WRONG_VALUE_FOR_FIELD ,"22007", "" },
{ ER_ILLEGAL_VALUE_FOR_TYPE ,"22007", "" },
{ ER_VIEW_CHECK_FAILED ,"44000", "" },
{ ER_PROCACCESS_DENIED_ERROR ,"42000", "" },
{ ER_XAER_NOTA ,"XAE04", "" },
{ ER_XAER_INVAL ,"XAE05", "" },
{ ER_XAER_RMFAIL ,"XAE07", "" },
{ ER_XAER_OUTSIDE ,"XAE09", "" },
{ ER_XAER_RMERR ,"XAE03", "" },
{ ER_XA_RBROLLBACK ,"XA100", "" },
{ ER_NONEXISTING_PROC_GRANT ,"42000", "" },
{ ER_DATA_TOO_LONG ,"22001", "" },
{ ER_SP_BAD_SQLSTATE ,"42000", "" },
{ ER_CANT_CREATE_USER_WITH_GRANT ,"42000", "" },
{ ER_SP_DUP_HANDLER ,"42000", "" },
{ ER_SP_NOT_VAR_ARG ,"42000", "" },
{ ER_SP_NO_RETSET ,"0A000", "" },
{ ER_CANT_CREATE_GEOMETRY_OBJECT ,"22003", "" },
{ ER_TOO_BIG_SCALE ,"42000", "S1009" },
{ ER_TOO_BIG_PRECISION ,"42000", "S1009" },
{ ER_M_BIGGER_THAN_D ,"42000", "S1009" },
{ ER_TOO_LONG_BODY ,"42000", "S1009" },
{ ER_TOO_BIG_DISPLAYWIDTH ,"42000", "S1009" },
{ ER_XAER_DUPID ,"XAE08", "" },
{ ER_DATETIME_FUNCTION_OVERFLOW ,"22008", "" },
{ ER_MALFORMED_DEFINER ,"0L000", "" },
{ ER_ROW_IS_REFERENCED_2 ,"23000", "" },
{ ER_NO_REFERENCED_ROW_2 ,"23000", "" },
{ ER_SP_BAD_VAR_SHADOW ,"42000", "" },
{ ER_SP_WRONG_NAME ,"42000", "" },
{ ER_SP_NO_AGGREGATE ,"42000", "" },
{ ER_MAX_PREPARED_STMT_COUNT_REACHED ,"42000", "" },
{ ER_NON_GROUPING_FIELD_USED ,"42000", "" },
{ ER_CANT_CHANGE_TX_CHARACTERISTICS ,"25001", "" },
{ ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT ,"42000", "" },
{ ER_WRONG_PARAMETERS_TO_NATIVE_FCT ,"42000", "" },
{ ER_WRONG_PARAMETERS_TO_STORED_FCT ,"42000", "" },
{ ER_DUP_ENTRY_WITH_KEY_NAME ,"23000", "S1009" },
{ ER_XA_RBTIMEOUT ,"XA106", "" },
{ ER_XA_RBDEADLOCK ,"XA102", "" },
{ ER_FUNC_INEXISTENT_NAME_COLLISION ,"42000", "" },
{ ER_DUP_SIGNAL_SET ,"42000", "" },
{ ER_SIGNAL_WARN ,"01000", "" },
{ ER_SIGNAL_NOT_FOUND ,"02000", "" },
{ ER_SIGNAL_EXCEPTION ,"HY000", "" },
{ ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER ,"0K000", "" },
{ ER_SPATIAL_MUST_HAVE_GEOM_COL ,"42000", "" },
{ ER_DATA_OUT_OF_RANGE ,"22003", "" },
{ ER_ACCESS_DENIED_NO_PASSWORD_ERROR ,"28000", "" },
{ ER_TRUNCATE_ILLEGAL_FK ,"42000", "" },
{ ER_DA_INVALID_CONDITION_NUMBER ,"35000", "" },
{ ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO,"23000", "S1009" },
{ ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO,"23000", "S1009" },
{ ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION,"25006", "" },
{ ER_ALTER_OPERATION_NOT_SUPPORTED ,"0A000", "" },
{ ER_ALTER_OPERATION_NOT_SUPPORTED_REASON ,"0A000", "" },
{ ER_DUP_UNKNOWN_IN_INDEX ,"23000", "" },
{ ER_ACCESS_DENIED_CHANGE_USER_ERROR ,"28000", "" },
{ ER_DATA_OVERFLOW ,"22003", "" },
{ ER_DATA_TRUNCATED ,"22003", "" },
{ ER_BAD_DATA ,"22007", "" },
{ ER_DYN_COL_DATA ,"22007", "" },
{ ER_CONNECTION_KILLED ,"70100", "" },
{ ER_NO_SUCH_TABLE_IN_ENGINE ,"42S02", "" },
{ ER_INVALID_ROLE ,"OP000", "" },
{ ER_INVALID_CURRENT_USER ,"0L000", "" },
{ ER_IT_IS_A_VIEW ,"42S02", "" },
{ ER_STATEMENT_TIMEOUT ,"70100", "" },
{ ER_SUBQUERIES_NOT_SUPPORTED ,"42000", "" },
{ ER_SET_STATEMENT_NOT_SUPPORTED ,"42000", "" },
{ ER_INVALID_DEFAULT_VALUE_FOR_FIELD ,"22007", "" },
{ ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER,"0Z002", "" },
{ ER_INVALID_ARGUMENT_FOR_LOGARITHM ,"2201E", "" },
{ ER_GIS_INVALID_DATA ,"22023", "" },
{ ER_USER_LOCK_WRONG_NAME ,"42000", "" },
{ ER_SECURE_TRANSPORT_REQUIRED ,"08004", "" },
{ ER_UNUSED_26 ,"0A000", "" },
{ ER_CONSTRAINT_FAILED ,"23000", "" },
{ ER_EXPRESSION_REFERS_TO_UNINIT_FIELD ,"01000", "" },
{ ER_WRONG_PARAMCOUNT_TO_CURSOR ,"42000", "" },
{ ER_NOT_SEQUENCE ,"42S02", "" },
{ ER_NOT_SEQUENCE2 ,"42S02", "" },
{ ER_UNKNOWN_SEQUENCES ,"42S02", "" },
{ ER_UNKNOWN_VIEW ,"42S02", "" },
{ ER_TOO_LONG_KEYPART ,"42000", "S1009" },
{ ER_SLAVE_STATEMENT_TIMEOUT ,"70100", "" },
PK ! mysqld_error.hnu [ /* Autogenerated file, please don't edit */
#ifndef ER_ERROR_FIRST
#define ER_ERROR_FIRST 1000
#define ER_HASHCHK 1000
#define ER_NISAMCHK 1001
#define ER_NO 1002
#define ER_YES 1003
#define ER_CANT_CREATE_FILE 1004
#define ER_CANT_CREATE_TABLE 1005
#define ER_CANT_CREATE_DB 1006
#define ER_DB_CREATE_EXISTS 1007
#define ER_DB_DROP_EXISTS 1008
#define ER_DB_DROP_DELETE 1009
#define ER_DB_DROP_RMDIR 1010
#define ER_CANT_DELETE_FILE 1011
#define ER_CANT_FIND_SYSTEM_REC 1012
#define ER_CANT_GET_STAT 1013
#define ER_CANT_GET_WD 1014
#define ER_CANT_LOCK 1015
#define ER_CANT_OPEN_FILE 1016
#define ER_FILE_NOT_FOUND 1017
#define ER_CANT_READ_DIR 1018
#define ER_CANT_SET_WD 1019
#define ER_CHECKREAD 1020
#define ER_DISK_FULL 1021
#define ER_DUP_KEY 1022
#define ER_ERROR_ON_CLOSE 1023
#define ER_ERROR_ON_READ 1024
#define ER_ERROR_ON_RENAME 1025
#define ER_ERROR_ON_WRITE 1026
#define ER_FILE_USED 1027
#define ER_FILSORT_ABORT 1028
#define ER_FORM_NOT_FOUND 1029
#define ER_GET_ERRNO 1030
#define ER_ILLEGAL_HA 1031
#define ER_KEY_NOT_FOUND 1032
#define ER_NOT_FORM_FILE 1033
#define ER_NOT_KEYFILE 1034
#define ER_OLD_KEYFILE 1035
#define ER_OPEN_AS_READONLY 1036
#define ER_OUTOFMEMORY 1037
#define ER_OUT_OF_SORTMEMORY 1038
#define ER_UNEXPECTED_EOF 1039
#define ER_CON_COUNT_ERROR 1040
#define ER_OUT_OF_RESOURCES 1041
#define ER_BAD_HOST_ERROR 1042
#define ER_HANDSHAKE_ERROR 1043
#define ER_DBACCESS_DENIED_ERROR 1044
#define ER_ACCESS_DENIED_ERROR 1045
#define ER_NO_DB_ERROR 1046
#define ER_UNKNOWN_COM_ERROR 1047
#define ER_BAD_NULL_ERROR 1048
#define ER_BAD_DB_ERROR 1049
#define ER_TABLE_EXISTS_ERROR 1050
#define ER_BAD_TABLE_ERROR 1051
#define ER_NON_UNIQ_ERROR 1052
#define ER_SERVER_SHUTDOWN 1053
#define ER_BAD_FIELD_ERROR 1054
#define ER_WRONG_FIELD_WITH_GROUP 1055
#define ER_WRONG_GROUP_FIELD 1056
#define ER_WRONG_SUM_SELECT 1057
#define ER_WRONG_VALUE_COUNT 1058
#define ER_TOO_LONG_IDENT 1059
#define ER_DUP_FIELDNAME 1060
#define ER_DUP_KEYNAME 1061
#define ER_DUP_ENTRY 1062
#define ER_WRONG_FIELD_SPEC 1063
#define ER_PARSE_ERROR 1064
#define ER_EMPTY_QUERY 1065
#define ER_NONUNIQ_TABLE 1066
#define ER_INVALID_DEFAULT 1067
#define ER_MULTIPLE_PRI_KEY 1068
#define ER_TOO_MANY_KEYS 1069
#define ER_TOO_MANY_KEY_PARTS 1070
#define ER_TOO_LONG_KEY 1071
#define ER_KEY_COLUMN_DOES_NOT_EXIST 1072
#define ER_BLOB_USED_AS_KEY 1073
#define ER_TOO_BIG_FIELDLENGTH 1074
#define ER_WRONG_AUTO_KEY 1075
#define ER_BINLOG_CANT_DELETE_GTID_DOMAIN 1076
#define ER_NORMAL_SHUTDOWN 1077
#define ER_GOT_SIGNAL 1078
#define ER_SHUTDOWN_COMPLETE 1079
#define ER_FORCING_CLOSE 1080
#define ER_IPSOCK_ERROR 1081
#define ER_NO_SUCH_INDEX 1082
#define ER_WRONG_FIELD_TERMINATORS 1083
#define ER_BLOBS_AND_NO_TERMINATED 1084
#define ER_TEXTFILE_NOT_READABLE 1085
#define ER_FILE_EXISTS_ERROR 1086
#define ER_LOAD_INFO 1087
#define ER_ALTER_INFO 1088
#define ER_WRONG_SUB_KEY 1089
#define ER_CANT_REMOVE_ALL_FIELDS 1090
#define ER_CANT_DROP_FIELD_OR_KEY 1091
#define ER_INSERT_INFO 1092
#define ER_UPDATE_TABLE_USED 1093
#define ER_NO_SUCH_THREAD 1094
#define ER_KILL_DENIED_ERROR 1095
#define ER_NO_TABLES_USED 1096
#define ER_TOO_BIG_SET 1097
#define ER_NO_UNIQUE_LOGFILE 1098
#define ER_TABLE_NOT_LOCKED_FOR_WRITE 1099
#define ER_TABLE_NOT_LOCKED 1100
#define ER_UNUSED_17 1101
#define ER_WRONG_DB_NAME 1102
#define ER_WRONG_TABLE_NAME 1103
#define ER_TOO_BIG_SELECT 1104
#define ER_UNKNOWN_ERROR 1105
#define ER_UNKNOWN_PROCEDURE 1106
#define ER_WRONG_PARAMCOUNT_TO_PROCEDURE 1107
#define ER_WRONG_PARAMETERS_TO_PROCEDURE 1108
#define ER_UNKNOWN_TABLE 1109
#define ER_FIELD_SPECIFIED_TWICE 1110
#define ER_INVALID_GROUP_FUNC_USE 1111
#define ER_UNSUPPORTED_EXTENSION 1112
#define ER_TABLE_MUST_HAVE_COLUMNS 1113
#define ER_RECORD_FILE_FULL 1114
#define ER_UNKNOWN_CHARACTER_SET 1115
#define ER_TOO_MANY_TABLES 1116
#define ER_TOO_MANY_FIELDS 1117
#define ER_TOO_BIG_ROWSIZE 1118
#define ER_STACK_OVERRUN 1119
#define ER_WRONG_OUTER_JOIN 1120
#define ER_NULL_COLUMN_IN_INDEX 1121
#define ER_CANT_FIND_UDF 1122
#define ER_CANT_INITIALIZE_UDF 1123
#define ER_UDF_NO_PATHS 1124
#define ER_UDF_EXISTS 1125
#define ER_CANT_OPEN_LIBRARY 1126
#define ER_CANT_FIND_DL_ENTRY 1127
#define ER_FUNCTION_NOT_DEFINED 1128
#define ER_HOST_IS_BLOCKED 1129
#define ER_HOST_NOT_PRIVILEGED 1130
#define ER_PASSWORD_ANONYMOUS_USER 1131
#define ER_PASSWORD_NOT_ALLOWED 1132
#define ER_PASSWORD_NO_MATCH 1133
#define ER_UPDATE_INFO 1134
#define ER_CANT_CREATE_THREAD 1135
#define ER_WRONG_VALUE_COUNT_ON_ROW 1136
#define ER_CANT_REOPEN_TABLE 1137
#define ER_INVALID_USE_OF_NULL 1138
#define ER_REGEXP_ERROR 1139
#define ER_MIX_OF_GROUP_FUNC_AND_FIELDS 1140
#define ER_NONEXISTING_GRANT 1141
#define ER_TABLEACCESS_DENIED_ERROR 1142
#define ER_COLUMNACCESS_DENIED_ERROR 1143
#define ER_ILLEGAL_GRANT_FOR_TABLE 1144
#define ER_GRANT_WRONG_HOST_OR_USER 1145
#define ER_NO_SUCH_TABLE 1146
#define ER_NONEXISTING_TABLE_GRANT 1147
#define ER_NOT_ALLOWED_COMMAND 1148
#define ER_SYNTAX_ERROR 1149
#define ER_DELAYED_CANT_CHANGE_LOCK 1150
#define ER_TOO_MANY_DELAYED_THREADS 1151
#define ER_ABORTING_CONNECTION 1152
#define ER_NET_PACKET_TOO_LARGE 1153
#define ER_NET_READ_ERROR_FROM_PIPE 1154
#define ER_NET_FCNTL_ERROR 1155
#define ER_NET_PACKETS_OUT_OF_ORDER 1156
#define ER_NET_UNCOMPRESS_ERROR 1157
#define ER_NET_READ_ERROR 1158
#define ER_NET_READ_INTERRUPTED 1159
#define ER_NET_ERROR_ON_WRITE 1160
#define ER_NET_WRITE_INTERRUPTED 1161
#define ER_TOO_LONG_STRING 1162
#define ER_TABLE_CANT_HANDLE_BLOB 1163
#define ER_TABLE_CANT_HANDLE_AUTO_INCREMENT 1164
#define ER_DELAYED_INSERT_TABLE_LOCKED 1165
#define ER_WRONG_COLUMN_NAME 1166
#define ER_WRONG_KEY_COLUMN 1167
#define ER_WRONG_MRG_TABLE 1168
#define ER_DUP_UNIQUE 1169
#define ER_BLOB_KEY_WITHOUT_LENGTH 1170
#define ER_PRIMARY_CANT_HAVE_NULL 1171
#define ER_TOO_MANY_ROWS 1172
#define ER_REQUIRES_PRIMARY_KEY 1173
#define ER_NO_RAID_COMPILED 1174
#define ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE 1175
#define ER_KEY_DOES_NOT_EXISTS 1176
#define ER_CHECK_NO_SUCH_TABLE 1177
#define ER_CHECK_NOT_IMPLEMENTED 1178
#define ER_CANT_DO_THIS_DURING_AN_TRANSACTION 1179
#define ER_ERROR_DURING_COMMIT 1180
#define ER_ERROR_DURING_ROLLBACK 1181
#define ER_ERROR_DURING_FLUSH_LOGS 1182
#define ER_ERROR_DURING_CHECKPOINT 1183
#define ER_NEW_ABORTING_CONNECTION 1184
#define ER_UNUSED_10 1185
#define ER_FLUSH_MASTER_BINLOG_CLOSED 1186
#define ER_INDEX_REBUILD 1187
#define ER_MASTER 1188
#define ER_MASTER_NET_READ 1189
#define ER_MASTER_NET_WRITE 1190
#define ER_FT_MATCHING_KEY_NOT_FOUND 1191
#define ER_LOCK_OR_ACTIVE_TRANSACTION 1192
#define ER_UNKNOWN_SYSTEM_VARIABLE 1193
#define ER_CRASHED_ON_USAGE 1194
#define ER_CRASHED_ON_REPAIR 1195
#define ER_WARNING_NOT_COMPLETE_ROLLBACK 1196
#define ER_TRANS_CACHE_FULL 1197
#define ER_SLAVE_MUST_STOP 1198
#define ER_SLAVE_NOT_RUNNING 1199
#define ER_BAD_SLAVE 1200
#define ER_MASTER_INFO 1201
#define ER_SLAVE_THREAD 1202
#define ER_TOO_MANY_USER_CONNECTIONS 1203
#define ER_SET_CONSTANTS_ONLY 1204
#define ER_LOCK_WAIT_TIMEOUT 1205
#define ER_LOCK_TABLE_FULL 1206
#define ER_READ_ONLY_TRANSACTION 1207
#define ER_DROP_DB_WITH_READ_LOCK 1208
#define ER_CREATE_DB_WITH_READ_LOCK 1209
#define ER_WRONG_ARGUMENTS 1210
#define ER_NO_PERMISSION_TO_CREATE_USER 1211
#define ER_UNION_TABLES_IN_DIFFERENT_DIR 1212
#define ER_LOCK_DEADLOCK 1213
#define ER_TABLE_CANT_HANDLE_FT 1214
#define ER_CANNOT_ADD_FOREIGN 1215
#define ER_NO_REFERENCED_ROW 1216
#define ER_ROW_IS_REFERENCED 1217
#define ER_CONNECT_TO_MASTER 1218
#define ER_QUERY_ON_MASTER 1219
#define ER_ERROR_WHEN_EXECUTING_COMMAND 1220
#define ER_WRONG_USAGE 1221
#define ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT 1222
#define ER_CANT_UPDATE_WITH_READLOCK 1223
#define ER_MIXING_NOT_ALLOWED 1224
#define ER_DUP_ARGUMENT 1225
#define ER_USER_LIMIT_REACHED 1226
#define ER_SPECIFIC_ACCESS_DENIED_ERROR 1227
#define ER_LOCAL_VARIABLE 1228
#define ER_GLOBAL_VARIABLE 1229
#define ER_NO_DEFAULT 1230
#define ER_WRONG_VALUE_FOR_VAR 1231
#define ER_WRONG_TYPE_FOR_VAR 1232
#define ER_VAR_CANT_BE_READ 1233
#define ER_CANT_USE_OPTION_HERE 1234
#define ER_NOT_SUPPORTED_YET 1235
#define ER_MASTER_FATAL_ERROR_READING_BINLOG 1236
#define ER_SLAVE_IGNORED_TABLE 1237
#define ER_INCORRECT_GLOBAL_LOCAL_VAR 1238
#define ER_WRONG_FK_DEF 1239
#define ER_KEY_REF_DO_NOT_MATCH_TABLE_REF 1240
#define ER_OPERAND_COLUMNS 1241
#define ER_SUBQUERY_NO_1_ROW 1242
#define ER_UNKNOWN_STMT_HANDLER 1243
#define ER_CORRUPT_HELP_DB 1244
#define ER_CYCLIC_REFERENCE 1245
#define ER_AUTO_CONVERT 1246
#define ER_ILLEGAL_REFERENCE 1247
#define ER_DERIVED_MUST_HAVE_ALIAS 1248
#define ER_SELECT_REDUCED 1249
#define ER_TABLENAME_NOT_ALLOWED_HERE 1250
#define ER_NOT_SUPPORTED_AUTH_MODE 1251
#define ER_SPATIAL_CANT_HAVE_NULL 1252
#define ER_COLLATION_CHARSET_MISMATCH 1253
#define ER_SLAVE_WAS_RUNNING 1254
#define ER_SLAVE_WAS_NOT_RUNNING 1255
#define ER_TOO_BIG_FOR_UNCOMPRESS 1256
#define ER_ZLIB_Z_MEM_ERROR 1257
#define ER_ZLIB_Z_BUF_ERROR 1258
#define ER_ZLIB_Z_DATA_ERROR 1259
#define ER_CUT_VALUE_GROUP_CONCAT 1260
#define ER_WARN_TOO_FEW_RECORDS 1261
#define ER_WARN_TOO_MANY_RECORDS 1262
#define ER_WARN_NULL_TO_NOTNULL 1263
#define ER_WARN_DATA_OUT_OF_RANGE 1264
#define WARN_DATA_TRUNCATED 1265
#define ER_WARN_USING_OTHER_HANDLER 1266
#define ER_CANT_AGGREGATE_2COLLATIONS 1267
#define ER_DROP_USER 1268
#define ER_REVOKE_GRANTS 1269
#define ER_CANT_AGGREGATE_3COLLATIONS 1270
#define ER_CANT_AGGREGATE_NCOLLATIONS 1271
#define ER_VARIABLE_IS_NOT_STRUCT 1272
#define ER_UNKNOWN_COLLATION 1273
#define ER_SLAVE_IGNORED_SSL_PARAMS 1274
#define ER_SERVER_IS_IN_SECURE_AUTH_MODE 1275
#define ER_WARN_FIELD_RESOLVED 1276
#define ER_BAD_SLAVE_UNTIL_COND 1277
#define ER_MISSING_SKIP_SLAVE 1278
#define ER_UNTIL_COND_IGNORED 1279
#define ER_WRONG_NAME_FOR_INDEX 1280
#define ER_WRONG_NAME_FOR_CATALOG 1281
#define ER_WARN_QC_RESIZE 1282
#define ER_BAD_FT_COLUMN 1283
#define ER_UNKNOWN_KEY_CACHE 1284
#define ER_WARN_HOSTNAME_WONT_WORK 1285
#define ER_UNKNOWN_STORAGE_ENGINE 1286
#define ER_WARN_DEPRECATED_SYNTAX 1287
#define ER_NON_UPDATABLE_TABLE 1288
#define ER_FEATURE_DISABLED 1289
#define ER_OPTION_PREVENTS_STATEMENT 1290
#define ER_DUPLICATED_VALUE_IN_TYPE 1291
#define ER_TRUNCATED_WRONG_VALUE 1292
#define ER_TOO_MUCH_AUTO_TIMESTAMP_COLS 1293
#define ER_INVALID_ON_UPDATE 1294
#define ER_UNSUPPORTED_PS 1295
#define ER_GET_ERRMSG 1296
#define ER_GET_TEMPORARY_ERRMSG 1297
#define ER_UNKNOWN_TIME_ZONE 1298
#define ER_WARN_INVALID_TIMESTAMP 1299
#define ER_INVALID_CHARACTER_STRING 1300
#define ER_WARN_ALLOWED_PACKET_OVERFLOWED 1301
#define ER_CONFLICTING_DECLARATIONS 1302
#define ER_SP_NO_RECURSIVE_CREATE 1303
#define ER_SP_ALREADY_EXISTS 1304
#define ER_SP_DOES_NOT_EXIST 1305
#define ER_SP_DROP_FAILED 1306
#define ER_SP_STORE_FAILED 1307
#define ER_SP_LILABEL_MISMATCH 1308
#define ER_SP_LABEL_REDEFINE 1309
#define ER_SP_LABEL_MISMATCH 1310
#define ER_SP_UNINIT_VAR 1311
#define ER_SP_BADSELECT 1312
#define ER_SP_BADRETURN 1313
#define ER_SP_BADSTATEMENT 1314
#define ER_UPDATE_LOG_DEPRECATED_IGNORED 1315
#define ER_UPDATE_LOG_DEPRECATED_TRANSLATED 1316
#define ER_QUERY_INTERRUPTED 1317
#define ER_SP_WRONG_NO_OF_ARGS 1318
#define ER_SP_COND_MISMATCH 1319
#define ER_SP_NORETURN 1320
#define ER_SP_NORETURNEND 1321
#define ER_SP_BAD_CURSOR_QUERY 1322
#define ER_SP_BAD_CURSOR_SELECT 1323
#define ER_SP_CURSOR_MISMATCH 1324
#define ER_SP_CURSOR_ALREADY_OPEN 1325
#define ER_SP_CURSOR_NOT_OPEN 1326
#define ER_SP_UNDECLARED_VAR 1327
#define ER_SP_WRONG_NO_OF_FETCH_ARGS 1328
#define ER_SP_FETCH_NO_DATA 1329
#define ER_SP_DUP_PARAM 1330
#define ER_SP_DUP_VAR 1331
#define ER_SP_DUP_COND 1332
#define ER_SP_DUP_CURS 1333
#define ER_SP_CANT_ALTER 1334
#define ER_SP_SUBSELECT_NYI 1335
#define ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG 1336
#define ER_SP_VARCOND_AFTER_CURSHNDLR 1337
#define ER_SP_CURSOR_AFTER_HANDLER 1338
#define ER_SP_CASE_NOT_FOUND 1339
#define ER_FPARSER_TOO_BIG_FILE 1340
#define ER_FPARSER_BAD_HEADER 1341
#define ER_FPARSER_EOF_IN_COMMENT 1342
#define ER_FPARSER_ERROR_IN_PARAMETER 1343
#define ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER 1344
#define ER_VIEW_NO_EXPLAIN 1345
#define ER_FRM_UNKNOWN_TYPE 1346
#define ER_WRONG_OBJECT 1347
#define ER_NONUPDATEABLE_COLUMN 1348
#define ER_VIEW_SELECT_DERIVED 1349
#define ER_VIEW_SELECT_CLAUSE 1350
#define ER_VIEW_SELECT_VARIABLE 1351
#define ER_VIEW_SELECT_TMPTABLE 1352
#define ER_VIEW_WRONG_LIST 1353
#define ER_WARN_VIEW_MERGE 1354
#define ER_WARN_VIEW_WITHOUT_KEY 1355
#define ER_VIEW_INVALID 1356
#define ER_SP_NO_DROP_SP 1357
#define ER_SP_GOTO_IN_HNDLR 1358
#define ER_TRG_ALREADY_EXISTS 1359
#define ER_TRG_DOES_NOT_EXIST 1360
#define ER_TRG_ON_VIEW_OR_TEMP_TABLE 1361
#define ER_TRG_CANT_CHANGE_ROW 1362
#define ER_TRG_NO_SUCH_ROW_IN_TRG 1363
#define ER_NO_DEFAULT_FOR_FIELD 1364
#define ER_DIVISION_BY_ZERO 1365
#define ER_TRUNCATED_WRONG_VALUE_FOR_FIELD 1366
#define ER_ILLEGAL_VALUE_FOR_TYPE 1367
#define ER_VIEW_NONUPD_CHECK 1368
#define ER_VIEW_CHECK_FAILED 1369
#define ER_PROCACCESS_DENIED_ERROR 1370
#define ER_RELAY_LOG_FAIL 1371
#define ER_PASSWD_LENGTH 1372
#define ER_UNKNOWN_TARGET_BINLOG 1373
#define ER_IO_ERR_LOG_INDEX_READ 1374
#define ER_BINLOG_PURGE_PROHIBITED 1375
#define ER_FSEEK_FAIL 1376
#define ER_BINLOG_PURGE_FATAL_ERR 1377
#define ER_LOG_IN_USE 1378
#define ER_LOG_PURGE_UNKNOWN_ERR 1379
#define ER_RELAY_LOG_INIT 1380
#define ER_NO_BINARY_LOGGING 1381
#define ER_RESERVED_SYNTAX 1382
#define ER_WSAS_FAILED 1383
#define ER_DIFF_GROUPS_PROC 1384
#define ER_NO_GROUP_FOR_PROC 1385
#define ER_ORDER_WITH_PROC 1386
#define ER_LOGGING_PROHIBIT_CHANGING_OF 1387
#define ER_NO_FILE_MAPPING 1388
#define ER_WRONG_MAGIC 1389
#define ER_PS_MANY_PARAM 1390
#define ER_KEY_PART_0 1391
#define ER_VIEW_CHECKSUM 1392
#define ER_VIEW_MULTIUPDATE 1393
#define ER_VIEW_NO_INSERT_FIELD_LIST 1394
#define ER_VIEW_DELETE_MERGE_VIEW 1395
#define ER_CANNOT_USER 1396
#define ER_XAER_NOTA 1397
#define ER_XAER_INVAL 1398
#define ER_XAER_RMFAIL 1399
#define ER_XAER_OUTSIDE 1400
#define ER_XAER_RMERR 1401
#define ER_XA_RBROLLBACK 1402
#define ER_NONEXISTING_PROC_GRANT 1403
#define ER_PROC_AUTO_GRANT_FAIL 1404
#define ER_PROC_AUTO_REVOKE_FAIL 1405
#define ER_DATA_TOO_LONG 1406
#define ER_SP_BAD_SQLSTATE 1407
#define ER_STARTUP 1408
#define ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR 1409
#define ER_CANT_CREATE_USER_WITH_GRANT 1410
#define ER_WRONG_VALUE_FOR_TYPE 1411
#define ER_TABLE_DEF_CHANGED 1412
#define ER_SP_DUP_HANDLER 1413
#define ER_SP_NOT_VAR_ARG 1414
#define ER_SP_NO_RETSET 1415
#define ER_CANT_CREATE_GEOMETRY_OBJECT 1416
#define ER_FAILED_ROUTINE_BREAK_BINLOG 1417
#define ER_BINLOG_UNSAFE_ROUTINE 1418
#define ER_BINLOG_CREATE_ROUTINE_NEED_SUPER 1419
#define ER_EXEC_STMT_WITH_OPEN_CURSOR 1420
#define ER_STMT_HAS_NO_OPEN_CURSOR 1421
#define ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG 1422
#define ER_NO_DEFAULT_FOR_VIEW_FIELD 1423
#define ER_SP_NO_RECURSION 1424
#define ER_TOO_BIG_SCALE 1425
#define ER_TOO_BIG_PRECISION 1426
#define ER_M_BIGGER_THAN_D 1427
#define ER_WRONG_LOCK_OF_SYSTEM_TABLE 1428
#define ER_CONNECT_TO_FOREIGN_DATA_SOURCE 1429
#define ER_QUERY_ON_FOREIGN_DATA_SOURCE 1430
#define ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST 1431
#define ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE 1432
#define ER_FOREIGN_DATA_STRING_INVALID 1433
#define ER_CANT_CREATE_FEDERATED_TABLE 1434
#define ER_TRG_IN_WRONG_SCHEMA 1435
#define ER_STACK_OVERRUN_NEED_MORE 1436
#define ER_TOO_LONG_BODY 1437
#define ER_WARN_CANT_DROP_DEFAULT_KEYCACHE 1438
#define ER_TOO_BIG_DISPLAYWIDTH 1439
#define ER_XAER_DUPID 1440
#define ER_DATETIME_FUNCTION_OVERFLOW 1441
#define ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG 1442
#define ER_VIEW_PREVENT_UPDATE 1443
#define ER_PS_NO_RECURSION 1444
#define ER_SP_CANT_SET_AUTOCOMMIT 1445
#define ER_MALFORMED_DEFINER 1446
#define ER_VIEW_FRM_NO_USER 1447
#define ER_UNUSED_30 1448
#define ER_NO_SUCH_USER 1449
#define ER_FORBID_SCHEMA_CHANGE 1450
#define ER_ROW_IS_REFERENCED_2 1451
#define ER_NO_REFERENCED_ROW_2 1452
#define ER_SP_BAD_VAR_SHADOW 1453
#define ER_TRG_NO_DEFINER 1454
#define ER_OLD_FILE_FORMAT 1455
#define ER_SP_RECURSION_LIMIT 1456
#define ER_SP_PROC_TABLE_CORRUPT 1457
#define ER_SP_WRONG_NAME 1458
#define ER_TABLE_NEEDS_UPGRADE 1459
#define ER_SP_NO_AGGREGATE 1460
#define ER_MAX_PREPARED_STMT_COUNT_REACHED 1461
#define ER_VIEW_RECURSIVE 1462
#define ER_NON_GROUPING_FIELD_USED 1463
#define ER_TABLE_CANT_HANDLE_SPKEYS 1464
#define ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA 1465
#define ER_REMOVED_SPACES 1466
#define ER_AUTOINC_READ_FAILED 1467
#define ER_USERNAME 1468
#define ER_HOSTNAME 1469
#define ER_WRONG_STRING_LENGTH 1470
#define ER_NON_INSERTABLE_TABLE 1471
#define ER_ADMIN_WRONG_MRG_TABLE 1472
#define ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT 1473
#define ER_NAME_BECOMES_EMPTY 1474
#define ER_AMBIGUOUS_FIELD_TERM 1475
#define ER_FOREIGN_SERVER_EXISTS 1476
#define ER_FOREIGN_SERVER_DOESNT_EXIST 1477
#define ER_ILLEGAL_HA_CREATE_OPTION 1478
#define ER_PARTITION_REQUIRES_VALUES_ERROR 1479
#define ER_PARTITION_WRONG_VALUES_ERROR 1480
#define ER_PARTITION_MAXVALUE_ERROR 1481
#define ER_PARTITION_SUBPARTITION_ERROR 1482
#define ER_PARTITION_SUBPART_MIX_ERROR 1483
#define ER_PARTITION_WRONG_NO_PART_ERROR 1484
#define ER_PARTITION_WRONG_NO_SUBPART_ERROR 1485
#define ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR 1486
#define ER_NOT_CONSTANT_EXPRESSION 1487
#define ER_FIELD_NOT_FOUND_PART_ERROR 1488
#define ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR 1489
#define ER_INCONSISTENT_PARTITION_INFO_ERROR 1490
#define ER_PARTITION_FUNC_NOT_ALLOWED_ERROR 1491
#define ER_PARTITIONS_MUST_BE_DEFINED_ERROR 1492
#define ER_RANGE_NOT_INCREASING_ERROR 1493
#define ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR 1494
#define ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR 1495
#define ER_PARTITION_ENTRY_ERROR 1496
#define ER_MIX_HANDLER_ERROR 1497
#define ER_PARTITION_NOT_DEFINED_ERROR 1498
#define ER_TOO_MANY_PARTITIONS_ERROR 1499
#define ER_SUBPARTITION_ERROR 1500
#define ER_CANT_CREATE_HANDLER_FILE 1501
#define ER_BLOB_FIELD_IN_PART_FUNC_ERROR 1502
#define ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF 1503
#define ER_NO_PARTS_ERROR 1504
#define ER_PARTITION_MGMT_ON_NONPARTITIONED 1505
#define ER_FEATURE_NOT_SUPPORTED_WITH_PARTITIONING 1506
#define ER_PARTITION_DOES_NOT_EXIST 1507
#define ER_DROP_LAST_PARTITION 1508
#define ER_COALESCE_ONLY_ON_HASH_PARTITION 1509
#define ER_REORG_HASH_ONLY_ON_SAME_NO 1510
#define ER_REORG_NO_PARAM_ERROR 1511
#define ER_ONLY_ON_RANGE_LIST_PARTITION 1512
#define ER_ADD_PARTITION_SUBPART_ERROR 1513
#define ER_ADD_PARTITION_NO_NEW_PARTITION 1514
#define ER_COALESCE_PARTITION_NO_PARTITION 1515
#define ER_REORG_PARTITION_NOT_EXIST 1516
#define ER_SAME_NAME_PARTITION 1517
#define ER_NO_BINLOG_ERROR 1518
#define ER_CONSECUTIVE_REORG_PARTITIONS 1519
#define ER_REORG_OUTSIDE_RANGE 1520
#define ER_PARTITION_FUNCTION_FAILURE 1521
#define ER_PART_STATE_ERROR 1522
#define ER_LIMITED_PART_RANGE 1523
#define ER_PLUGIN_IS_NOT_LOADED 1524
#define ER_WRONG_VALUE 1525
#define ER_NO_PARTITION_FOR_GIVEN_VALUE 1526
#define ER_FILEGROUP_OPTION_ONLY_ONCE 1527
#define ER_CREATE_FILEGROUP_FAILED 1528
#define ER_DROP_FILEGROUP_FAILED 1529
#define ER_TABLESPACE_AUTO_EXTEND_ERROR 1530
#define ER_WRONG_SIZE_NUMBER 1531
#define ER_SIZE_OVERFLOW_ERROR 1532
#define ER_ALTER_FILEGROUP_FAILED 1533
#define ER_BINLOG_ROW_LOGGING_FAILED 1534
#define ER_BINLOG_ROW_WRONG_TABLE_DEF 1535
#define ER_BINLOG_ROW_RBR_TO_SBR 1536
#define ER_EVENT_ALREADY_EXISTS 1537
#define ER_EVENT_STORE_FAILED 1538
#define ER_EVENT_DOES_NOT_EXIST 1539
#define ER_EVENT_CANT_ALTER 1540
#define ER_EVENT_DROP_FAILED 1541
#define ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG 1542
#define ER_EVENT_ENDS_BEFORE_STARTS 1543
#define ER_EVENT_EXEC_TIME_IN_THE_PAST 1544
#define ER_EVENT_OPEN_TABLE_FAILED 1545
#define ER_EVENT_NEITHER_M_EXPR_NOR_M_AT 1546
#define ER_UNUSED_2 1547
#define ER_UNUSED_3 1548
#define ER_EVENT_CANNOT_DELETE 1549
#define ER_EVENT_COMPILE_ERROR 1550
#define ER_EVENT_SAME_NAME 1551
#define ER_EVENT_DATA_TOO_LONG 1552
#define ER_DROP_INDEX_FK 1553
#define ER_WARN_DEPRECATED_SYNTAX_WITH_VER 1554
#define ER_CANT_WRITE_LOCK_LOG_TABLE 1555
#define ER_CANT_LOCK_LOG_TABLE 1556
#define ER_UNUSED_4 1557
#define ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE 1558
#define ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR 1559
#define ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT 1560
#define ER_UNUSED_13 1561
#define ER_PARTITION_NO_TEMPORARY 1562
#define ER_PARTITION_CONST_DOMAIN_ERROR 1563
#define ER_PARTITION_FUNCTION_IS_NOT_ALLOWED 1564
#define ER_DDL_LOG_ERROR 1565
#define ER_NULL_IN_VALUES_LESS_THAN 1566
#define ER_WRONG_PARTITION_NAME 1567
#define ER_CANT_CHANGE_TX_CHARACTERISTICS 1568
#define ER_DUP_ENTRY_AUTOINCREMENT_CASE 1569
#define ER_EVENT_MODIFY_QUEUE_ERROR 1570
#define ER_EVENT_SET_VAR_ERROR 1571
#define ER_PARTITION_MERGE_ERROR 1572
#define ER_CANT_ACTIVATE_LOG 1573
#define ER_RBR_NOT_AVAILABLE 1574
#define ER_BASE64_DECODE_ERROR 1575
#define ER_EVENT_RECURSION_FORBIDDEN 1576
#define ER_EVENTS_DB_ERROR 1577
#define ER_ONLY_INTEGERS_ALLOWED 1578
#define ER_UNSUPORTED_LOG_ENGINE 1579
#define ER_BAD_LOG_STATEMENT 1580
#define ER_CANT_RENAME_LOG_TABLE 1581
#define ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT 1582
#define ER_WRONG_PARAMETERS_TO_NATIVE_FCT 1583
#define ER_WRONG_PARAMETERS_TO_STORED_FCT 1584
#define ER_NATIVE_FCT_NAME_COLLISION 1585
#define ER_DUP_ENTRY_WITH_KEY_NAME 1586
#define ER_BINLOG_PURGE_EMFILE 1587
#define ER_EVENT_CANNOT_CREATE_IN_THE_PAST 1588
#define ER_EVENT_CANNOT_ALTER_IN_THE_PAST 1589
#define ER_SLAVE_INCIDENT 1590
#define ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT 1591
#define ER_BINLOG_UNSAFE_STATEMENT 1592
#define ER_SLAVE_FATAL_ERROR 1593
#define ER_SLAVE_RELAY_LOG_READ_FAILURE 1594
#define ER_SLAVE_RELAY_LOG_WRITE_FAILURE 1595
#define ER_SLAVE_CREATE_EVENT_FAILURE 1596
#define ER_SLAVE_MASTER_COM_FAILURE 1597
#define ER_BINLOG_LOGGING_IMPOSSIBLE 1598
#define ER_VIEW_NO_CREATION_CTX 1599
#define ER_VIEW_INVALID_CREATION_CTX 1600
#define ER_SR_INVALID_CREATION_CTX 1601
#define ER_TRG_CORRUPTED_FILE 1602
#define ER_TRG_NO_CREATION_CTX 1603
#define ER_TRG_INVALID_CREATION_CTX 1604
#define ER_EVENT_INVALID_CREATION_CTX 1605
#define ER_TRG_CANT_OPEN_TABLE 1606
#define ER_CANT_CREATE_SROUTINE 1607
#define ER_UNUSED_11 1608
#define ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT 1609
#define ER_SLAVE_CORRUPT_EVENT 1610
#define ER_LOAD_DATA_INVALID_COLUMN 1611
#define ER_LOG_PURGE_NO_FILE 1612
#define ER_XA_RBTIMEOUT 1613
#define ER_XA_RBDEADLOCK 1614
#define ER_NEED_REPREPARE 1615
#define ER_DELAYED_NOT_SUPPORTED 1616
#define WARN_NO_MASTER_INFO 1617
#define WARN_OPTION_IGNORED 1618
#define ER_PLUGIN_DELETE_BUILTIN 1619
#define WARN_PLUGIN_BUSY 1620
#define ER_VARIABLE_IS_READONLY 1621
#define ER_WARN_ENGINE_TRANSACTION_ROLLBACK 1622
#define ER_SLAVE_HEARTBEAT_FAILURE 1623
#define ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE 1624
#define ER_UNUSED_14 1625
#define ER_CONFLICT_FN_PARSE_ERROR 1626
#define ER_EXCEPTIONS_WRITE_ERROR 1627
#define ER_TOO_LONG_TABLE_COMMENT 1628
#define ER_TOO_LONG_FIELD_COMMENT 1629
#define ER_FUNC_INEXISTENT_NAME_COLLISION 1630
#define ER_DATABASE_NAME 1631
#define ER_TABLE_NAME 1632
#define ER_PARTITION_NAME 1633
#define ER_SUBPARTITION_NAME 1634
#define ER_TEMPORARY_NAME 1635
#define ER_RENAMED_NAME 1636
#define ER_TOO_MANY_CONCURRENT_TRXS 1637
#define WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED 1638
#define ER_DEBUG_SYNC_TIMEOUT 1639
#define ER_DEBUG_SYNC_HIT_LIMIT 1640
#define ER_DUP_SIGNAL_SET 1641
#define ER_SIGNAL_WARN 1642
#define ER_SIGNAL_NOT_FOUND 1643
#define ER_SIGNAL_EXCEPTION 1644
#define ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER 1645
#define ER_SIGNAL_BAD_CONDITION_TYPE 1646
#define WARN_COND_ITEM_TRUNCATED 1647
#define ER_COND_ITEM_TOO_LONG 1648
#define ER_UNKNOWN_LOCALE 1649
#define ER_SLAVE_IGNORE_SERVER_IDS 1650
#define ER_QUERY_CACHE_DISABLED 1651
#define ER_SAME_NAME_PARTITION_FIELD 1652
#define ER_PARTITION_COLUMN_LIST_ERROR 1653
#define ER_WRONG_TYPE_COLUMN_VALUE_ERROR 1654
#define ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR 1655
#define ER_MAXVALUE_IN_VALUES_IN 1656
#define ER_TOO_MANY_VALUES_ERROR 1657
#define ER_ROW_SINGLE_PARTITION_FIELD_ERROR 1658
#define ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD 1659
#define ER_PARTITION_FIELDS_TOO_LONG 1660
#define ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE 1661
#define ER_BINLOG_ROW_MODE_AND_STMT_ENGINE 1662
#define ER_BINLOG_UNSAFE_AND_STMT_ENGINE 1663
#define ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE 1664
#define ER_BINLOG_STMT_MODE_AND_ROW_ENGINE 1665
#define ER_BINLOG_ROW_INJECTION_AND_STMT_MODE 1666
#define ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE 1667
#define ER_BINLOG_UNSAFE_LIMIT 1668
#define ER_BINLOG_UNSAFE_INSERT_DELAYED 1669
#define ER_BINLOG_UNSAFE_SYSTEM_TABLE 1670
#define ER_BINLOG_UNSAFE_AUTOINC_COLUMNS 1671
#define ER_BINLOG_UNSAFE_UDF 1672
#define ER_BINLOG_UNSAFE_SYSTEM_VARIABLE 1673
#define ER_BINLOG_UNSAFE_SYSTEM_FUNCTION 1674
#define ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS 1675
#define ER_MESSAGE_AND_STATEMENT 1676
#define ER_SLAVE_CONVERSION_FAILED 1677
#define ER_SLAVE_CANT_CREATE_CONVERSION 1678
#define ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT 1679
#define ER_PATH_LENGTH 1680
#define ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT 1681
#define ER_WRONG_NATIVE_TABLE_STRUCTURE 1682
#define ER_WRONG_PERFSCHEMA_USAGE 1683
#define ER_WARN_I_S_SKIPPED_TABLE 1684
#define ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT 1685
#define ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT 1686
#define ER_SPATIAL_MUST_HAVE_GEOM_COL 1687
#define ER_TOO_LONG_INDEX_COMMENT 1688
#define ER_LOCK_ABORTED 1689
#define ER_DATA_OUT_OF_RANGE 1690
#define ER_WRONG_SPVAR_TYPE_IN_LIMIT 1691
#define ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE 1692
#define ER_BINLOG_UNSAFE_MIXED_STATEMENT 1693
#define ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN 1694
#define ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN 1695
#define ER_FAILED_READ_FROM_PAR_FILE 1696
#define ER_VALUES_IS_NOT_INT_TYPE_ERROR 1697
#define ER_ACCESS_DENIED_NO_PASSWORD_ERROR 1698
#define ER_SET_PASSWORD_AUTH_PLUGIN 1699
#define ER_GRANT_PLUGIN_USER_EXISTS 1700
#define ER_TRUNCATE_ILLEGAL_FK 1701
#define ER_PLUGIN_IS_PERMANENT 1702
#define ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN 1703
#define ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX 1704
#define ER_STMT_CACHE_FULL 1705
#define ER_MULTI_UPDATE_KEY_CONFLICT 1706
#define ER_TABLE_NEEDS_REBUILD 1707
#define WARN_OPTION_BELOW_LIMIT 1708
#define ER_INDEX_COLUMN_TOO_LONG 1709
#define ER_ERROR_IN_TRIGGER_BODY 1710
#define ER_ERROR_IN_UNKNOWN_TRIGGER_BODY 1711
#define ER_INDEX_CORRUPT 1712
#define ER_UNDO_RECORD_TOO_BIG 1713
#define ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT 1714
#define ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE 1715
#define ER_BINLOG_UNSAFE_REPLACE_SELECT 1716
#define ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT 1717
#define ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT 1718
#define ER_BINLOG_UNSAFE_UPDATE_IGNORE 1719
#define ER_UNUSED_15 1720
#define ER_UNUSED_16 1721
#define ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT 1722
#define ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC 1723
#define ER_BINLOG_UNSAFE_INSERT_TWO_KEYS 1724
#define ER_UNUSED_28 1725
#define ER_VERS_NOT_ALLOWED 1726
#define ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST 1727
#define ER_CANNOT_LOAD_FROM_TABLE_V2 1728
#define ER_MASTER_DELAY_VALUE_OUT_OF_RANGE 1729
#define ER_ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT 1730
#define ER_PARTITION_EXCHANGE_DIFFERENT_OPTION 1731
#define ER_PARTITION_EXCHANGE_PART_TABLE 1732
#define ER_PARTITION_EXCHANGE_TEMP_TABLE 1733
#define ER_PARTITION_INSTEAD_OF_SUBPARTITION 1734
#define ER_UNKNOWN_PARTITION 1735
#define ER_TABLES_DIFFERENT_METADATA 1736
#define ER_ROW_DOES_NOT_MATCH_PARTITION 1737
#define ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX 1738
#define ER_WARN_INDEX_NOT_APPLICABLE 1739
#define ER_PARTITION_EXCHANGE_FOREIGN_KEY 1740
#define ER_NO_SUCH_KEY_VALUE 1741
#define ER_VALUE_TOO_LONG 1742
#define ER_NETWORK_READ_EVENT_CHECKSUM_FAILURE 1743
#define ER_BINLOG_READ_EVENT_CHECKSUM_FAILURE 1744
#define ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX 1745
#define ER_CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT 1746
#define ER_PARTITION_CLAUSE_ON_NONPARTITIONED 1747
#define ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET 1748
#define ER_UNUSED_5 1749
#define ER_CHANGE_RPL_INFO_REPOSITORY_FAILURE 1750
#define ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE 1751
#define ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE 1752
#define ER_MTS_FEATURE_IS_NOT_SUPPORTED 1753
#define ER_MTS_UPDATED_DBS_GREATER_MAX 1754
#define ER_MTS_CANT_PARALLEL 1755
#define ER_MTS_INCONSISTENT_DATA 1756
#define ER_FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING 1757
#define ER_DA_INVALID_CONDITION_NUMBER 1758
#define ER_INSECURE_PLAIN_TEXT 1759
#define ER_INSECURE_CHANGE_MASTER 1760
#define ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO 1761
#define ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO 1762
#define ER_SQLTHREAD_WITH_SECURE_SLAVE 1763
#define ER_TABLE_HAS_NO_FT 1764
#define ER_VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER 1765
#define ER_VARIABLE_NOT_SETTABLE_IN_TRANSACTION 1766
#define ER_GTID_NEXT_IS_NOT_IN_GTID_NEXT_LIST 1767
#define ER_CANT_CHANGE_GTID_NEXT_IN_TRANSACTION_WHEN_GTID_NEXT_LIST_IS_NULL 1768
#define ER_SET_STATEMENT_CANNOT_INVOKE_FUNCTION 1769
#define ER_GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL 1770
#define ER_SKIPPING_LOGGED_TRANSACTION 1771
#define ER_MALFORMED_GTID_SET_SPECIFICATION 1772
#define ER_MALFORMED_GTID_SET_ENCODING 1773
#define ER_MALFORMED_GTID_SPECIFICATION 1774
#define ER_GNO_EXHAUSTED 1775
#define ER_BAD_SLAVE_AUTO_POSITION 1776
#define ER_AUTO_POSITION_REQUIRES_GTID_MODE_ON 1777
#define ER_CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET 1778
#define ER_GTID_MODE_2_OR_3_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON 1779
#define ER_GTID_MODE_REQUIRES_BINLOG 1780
#define ER_CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF 1781
#define ER_CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON 1782
#define ER_CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF 1783
#define ER_FOUND_GTID_EVENT_WHEN_GTID_MODE_IS_OFF 1784
#define ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE 1785
#define ER_GTID_UNSAFE_CREATE_SELECT 1786
#define ER_GTID_UNSAFE_CREATE_DROP_TEMPORARY_TABLE_IN_TRANSACTION 1787
#define ER_GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME 1788
#define ER_MASTER_HAS_PURGED_REQUIRED_GTIDS 1789
#define ER_CANT_SET_GTID_NEXT_WHEN_OWNING_GTID 1790
#define ER_UNKNOWN_EXPLAIN_FORMAT 1791
#define ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION 1792
#define ER_TOO_LONG_TABLE_PARTITION_COMMENT 1793
#define ER_SLAVE_CONFIGURATION 1794
#define ER_INNODB_FT_LIMIT 1795
#define ER_INNODB_NO_FT_TEMP_TABLE 1796
#define ER_INNODB_FT_WRONG_DOCID_COLUMN 1797
#define ER_INNODB_FT_WRONG_DOCID_INDEX 1798
#define ER_INNODB_ONLINE_LOG_TOO_BIG 1799
#define ER_UNKNOWN_ALTER_ALGORITHM 1800
#define ER_UNKNOWN_ALTER_LOCK 1801
#define ER_MTS_CHANGE_MASTER_CANT_RUN_WITH_GAPS 1802
#define ER_MTS_RECOVERY_FAILURE 1803
#define ER_MTS_RESET_WORKERS 1804
#define ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2 1805
#define ER_SLAVE_SILENT_RETRY_TRANSACTION 1806
#define ER_UNUSED_22 1807
#define ER_TABLE_SCHEMA_MISMATCH 1808
#define ER_TABLE_IN_SYSTEM_TABLESPACE 1809
#define ER_IO_READ_ERROR 1810
#define ER_IO_WRITE_ERROR 1811
#define ER_TABLESPACE_MISSING 1812
#define ER_TABLESPACE_EXISTS 1813
#define ER_TABLESPACE_DISCARDED 1814
#define ER_INTERNAL_ERROR 1815
#define ER_INNODB_IMPORT_ERROR 1816
#define ER_INNODB_INDEX_CORRUPT 1817
#define ER_INVALID_YEAR_COLUMN_LENGTH 1818
#define ER_NOT_VALID_PASSWORD 1819
#define ER_MUST_CHANGE_PASSWORD 1820
#define ER_FK_NO_INDEX_CHILD 1821
#define ER_FK_NO_INDEX_PARENT 1822
#define ER_FK_FAIL_ADD_SYSTEM 1823
#define ER_FK_CANNOT_OPEN_PARENT 1824
#define ER_FK_INCORRECT_OPTION 1825
#define ER_DUP_CONSTRAINT_NAME 1826
#define ER_PASSWORD_FORMAT 1827
#define ER_FK_COLUMN_CANNOT_DROP 1828
#define ER_FK_COLUMN_CANNOT_DROP_CHILD 1829
#define ER_FK_COLUMN_NOT_NULL 1830
#define ER_DUP_INDEX 1831
#define ER_FK_COLUMN_CANNOT_CHANGE 1832
#define ER_FK_COLUMN_CANNOT_CHANGE_CHILD 1833
#define ER_FK_CANNOT_DELETE_PARENT 1834
#define ER_MALFORMED_PACKET 1835
#define ER_READ_ONLY_MODE 1836
#define ER_GTID_NEXT_TYPE_UNDEFINED_GROUP 1837
#define ER_VARIABLE_NOT_SETTABLE_IN_SP 1838
#define ER_CANT_SET_GTID_PURGED_WHEN_GTID_MODE_IS_OFF 1839
#define ER_CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY 1840
#define ER_CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY 1841
#define ER_GTID_PURGED_WAS_CHANGED 1842
#define ER_GTID_EXECUTED_WAS_CHANGED 1843
#define ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES 1844
#define ER_ALTER_OPERATION_NOT_SUPPORTED 1845
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON 1846
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY 1847
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION 1848
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME 1849
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE 1850
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK 1851
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_IGNORE 1852
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK 1853
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC 1854
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS 1855
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS 1856
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS 1857
#define ER_SQL_SLAVE_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE 1858
#define ER_DUP_UNKNOWN_IN_INDEX 1859
#define ER_IDENT_CAUSES_TOO_LONG_PATH 1860
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL 1861
#define ER_MUST_CHANGE_PASSWORD_LOGIN 1862
#define ER_ROW_IN_WRONG_PARTITION 1863
#define ER_MTS_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX 1864
#define ER_INNODB_NO_FT_USES_PARSER 1865
#define ER_BINLOG_LOGICAL_CORRUPTION 1866
#define ER_WARN_PURGE_LOG_IN_USE 1867
#define ER_WARN_PURGE_LOG_IS_ACTIVE 1868
#define ER_AUTO_INCREMENT_CONFLICT 1869
#define WARN_ON_BLOCKHOLE_IN_RBR 1870
#define ER_SLAVE_MI_INIT_REPOSITORY 1871
#define ER_SLAVE_RLI_INIT_REPOSITORY 1872
#define ER_ACCESS_DENIED_CHANGE_USER_ERROR 1873
#define ER_INNODB_READ_ONLY 1874
#define ER_STOP_SLAVE_SQL_THREAD_TIMEOUT 1875
#define ER_STOP_SLAVE_IO_THREAD_TIMEOUT 1876
#define ER_TABLE_CORRUPT 1877
#define ER_TEMP_FILE_WRITE_FAILURE 1878
#define ER_INNODB_FT_AUX_NOT_HEX_ID 1879
#define ER_LAST_MYSQL_ERROR_MESSAGE 1880
#define ER_ERROR_LAST_SECTION_1 1880
/* New section */
#define ER_ERROR_FIRST_SECTION_2 1900
#define ER_UNUSED_18 1900
#define ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED 1901
#define ER_UNUSED_19 1902
#define ER_PRIMARY_KEY_BASED_ON_GENERATED_COLUMN 1903
#define ER_KEY_BASED_ON_GENERATED_VIRTUAL_COLUMN 1904
#define ER_WRONG_FK_OPTION_FOR_GENERATED_COLUMN 1905
#define ER_WARNING_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN 1906
#define ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN 1907
#define ER_UNUSED_20 1908
#define ER_UNUSED_21 1909
#define ER_UNSUPPORTED_ENGINE_FOR_GENERATED_COLUMNS 1910
#define ER_UNKNOWN_OPTION 1911
#define ER_BAD_OPTION_VALUE 1912
#define ER_UNUSED_6 1913
#define ER_UNUSED_7 1914
#define ER_UNUSED_8 1915
#define ER_DATA_OVERFLOW 1916
#define ER_DATA_TRUNCATED 1917
#define ER_BAD_DATA 1918
#define ER_DYN_COL_WRONG_FORMAT 1919
#define ER_DYN_COL_IMPLEMENTATION_LIMIT 1920
#define ER_DYN_COL_DATA 1921
#define ER_DYN_COL_WRONG_CHARSET 1922
#define ER_ILLEGAL_SUBQUERY_OPTIMIZER_SWITCHES 1923
#define ER_QUERY_CACHE_IS_DISABLED 1924
#define ER_QUERY_CACHE_IS_GLOBALY_DISABLED 1925
#define ER_VIEW_ORDERBY_IGNORED 1926
#define ER_CONNECTION_KILLED 1927
#define ER_UNUSED_12 1928
#define ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SKIP_REPLICATION 1929
#define ER_STORED_FUNCTION_PREVENTS_SWITCH_SKIP_REPLICATION 1930
#define ER_QUERY_RESULT_INCOMPLETE 1931
#define ER_NO_SUCH_TABLE_IN_ENGINE 1932
#define ER_TARGET_NOT_EXPLAINABLE 1933
#define ER_CONNECTION_ALREADY_EXISTS 1934
#define ER_MASTER_LOG_PREFIX 1935
#define ER_CANT_START_STOP_SLAVE 1936
#define ER_SLAVE_STARTED 1937
#define ER_SLAVE_STOPPED 1938
#define ER_SQL_DISCOVER_ERROR 1939
#define ER_FAILED_GTID_STATE_INIT 1940
#define ER_INCORRECT_GTID_STATE 1941
#define ER_CANNOT_UPDATE_GTID_STATE 1942
#define ER_DUPLICATE_GTID_DOMAIN 1943
#define ER_GTID_OPEN_TABLE_FAILED 1944
#define ER_GTID_POSITION_NOT_FOUND_IN_BINLOG 1945
#define ER_CANNOT_LOAD_SLAVE_GTID_STATE 1946
#define ER_MASTER_GTID_POS_CONFLICTS_WITH_BINLOG 1947
#define ER_MASTER_GTID_POS_MISSING_DOMAIN 1948
#define ER_UNTIL_REQUIRES_USING_GTID 1949
#define ER_GTID_STRICT_OUT_OF_ORDER 1950
#define ER_GTID_START_FROM_BINLOG_HOLE 1951
#define ER_SLAVE_UNEXPECTED_MASTER_SWITCH 1952
#define ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_GTID_DOMAIN_ID_SEQ_NO 1953
#define ER_STORED_FUNCTION_PREVENTS_SWITCH_GTID_DOMAIN_ID_SEQ_NO 1954
#define ER_GTID_POSITION_NOT_FOUND_IN_BINLOG2 1955
#define ER_BINLOG_MUST_BE_EMPTY 1956
#define ER_NO_SUCH_QUERY 1957
#define ER_BAD_BASE64_DATA 1958
#define ER_INVALID_ROLE 1959
#define ER_INVALID_CURRENT_USER 1960
#define ER_CANNOT_GRANT_ROLE 1961
#define ER_CANNOT_REVOKE_ROLE 1962
#define ER_CHANGE_SLAVE_PARALLEL_THREADS_ACTIVE 1963
#define ER_PRIOR_COMMIT_FAILED 1964
#define ER_IT_IS_A_VIEW 1965
#define ER_SLAVE_SKIP_NOT_IN_GTID 1966
#define ER_TABLE_DEFINITION_TOO_BIG 1967
#define ER_PLUGIN_INSTALLED 1968
#define ER_STATEMENT_TIMEOUT 1969
#define ER_SUBQUERIES_NOT_SUPPORTED 1970
#define ER_SET_STATEMENT_NOT_SUPPORTED 1971
#define ER_UNUSED_9 1972
#define ER_USER_CREATE_EXISTS 1973
#define ER_USER_DROP_EXISTS 1974
#define ER_ROLE_CREATE_EXISTS 1975
#define ER_ROLE_DROP_EXISTS 1976
#define ER_CANNOT_CONVERT_CHARACTER 1977
#define ER_INVALID_DEFAULT_VALUE_FOR_FIELD 1978
#define ER_KILL_QUERY_DENIED_ERROR 1979
#define ER_NO_EIS_FOR_FIELD 1980
#define ER_WARN_AGGFUNC_DEPENDENCE 1981
#define WARN_INNODB_PARTITION_OPTION_IGNORED 1982
#define ER_ERROR_LAST_SECTION_2 1982
/* New section */
#define ER_ERROR_FIRST_SECTION_3 2000
#define ER_ERROR_LAST_SECTION_3 2000
/* New section */
#define ER_ERROR_FIRST_SECTION_4 3000
#define ER_FILE_CORRUPT 3000
#define ER_ERROR_ON_MASTER 3001
#define ER_INCONSISTENT_ERROR 3002
#define ER_STORAGE_ENGINE_NOT_LOADED 3003
#define ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER 3004
#define ER_WARN_LEGACY_SYNTAX_CONVERTED 3005
#define ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN 3006
#define ER_CANNOT_DISCARD_TEMPORARY_TABLE 3007
#define ER_FK_DEPTH_EXCEEDED 3008
#define ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE_V2 3009
#define ER_WARN_TRIGGER_DOESNT_HAVE_CREATED 3010
#define ER_REFERENCED_TRG_DOES_NOT_EXIST_MYSQL 3011
#define ER_EXPLAIN_NOT_SUPPORTED 3012
#define ER_INVALID_FIELD_SIZE 3013
#define ER_MISSING_HA_CREATE_OPTION 3014
#define ER_ENGINE_OUT_OF_MEMORY 3015
#define ER_PASSWORD_EXPIRE_ANONYMOUS_USER 3016
#define ER_SLAVE_SQL_THREAD_MUST_STOP 3017
#define ER_NO_FT_MATERIALIZED_SUBQUERY 3018
#define ER_INNODB_UNDO_LOG_FULL 3019
#define ER_INVALID_ARGUMENT_FOR_LOGARITHM 3020
#define ER_SLAVE_CHANNEL_IO_THREAD_MUST_STOP 3021
#define ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO 3022
#define ER_WARN_ONLY_MASTER_LOG_FILE_NO_POS 3023
#define ER_UNUSED_1 3024
#define ER_NON_RO_SELECT_DISABLE_TIMER 3025
#define ER_DUP_LIST_ENTRY 3026
#define ER_SQL_MODE_NO_EFFECT 3027
#define ER_AGGREGATE_ORDER_FOR_UNION 3028
#define ER_AGGREGATE_ORDER_NON_AGG_QUERY 3029
#define ER_SLAVE_WORKER_STOPPED_PREVIOUS_THD_ERROR 3030
#define ER_DONT_SUPPORT_SLAVE_PRESERVE_COMMIT_ORDER 3031
#define ER_SERVER_OFFLINE_MODE 3032
#define ER_GIS_DIFFERENT_SRIDS 3033
#define ER_GIS_UNSUPPORTED_ARGUMENT 3034
#define ER_GIS_UNKNOWN_ERROR 3035
#define ER_GIS_UNKNOWN_EXCEPTION 3036
#define ER_GIS_INVALID_DATA 3037
#define ER_BOOST_GEOMETRY_EMPTY_INPUT_EXCEPTION 3038
#define ER_BOOST_GEOMETRY_CENTROID_EXCEPTION 3039
#define ER_BOOST_GEOMETRY_OVERLAY_INVALID_INPUT_EXCEPTION 3040
#define ER_BOOST_GEOMETRY_TURN_INFO_EXCEPTION 3041
#define ER_BOOST_GEOMETRY_SELF_INTERSECTION_POINT_EXCEPTION 3042
#define ER_BOOST_GEOMETRY_UNKNOWN_EXCEPTION 3043
#define ER_STD_BAD_ALLOC_ERROR 3044
#define ER_STD_DOMAIN_ERROR 3045
#define ER_STD_LENGTH_ERROR 3046
#define ER_STD_INVALID_ARGUMENT 3047
#define ER_STD_OUT_OF_RANGE_ERROR 3048
#define ER_STD_OVERFLOW_ERROR 3049
#define ER_STD_RANGE_ERROR 3050
#define ER_STD_UNDERFLOW_ERROR 3051
#define ER_STD_LOGIC_ERROR 3052
#define ER_STD_RUNTIME_ERROR 3053
#define ER_STD_UNKNOWN_EXCEPTION 3054
#define ER_GIS_DATA_WRONG_ENDIANESS 3055
#define ER_CHANGE_MASTER_PASSWORD_LENGTH 3056
#define ER_USER_LOCK_WRONG_NAME 3057
#define ER_USER_LOCK_DEADLOCK 3058
#define ER_REPLACE_INACCESSIBLE_ROWS 3059
#define ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_GIS 3060
#define ER_MYSQL_3061 3061
#define ER_MYSQL_3062 3062
#define ER_MYSQL_3063 3063
#define ER_MYSQL_3064 3064
#define ER_MYSQL_3065 3065
#define ER_MYSQL_3066 3066
#define ER_MYSQL_3067 3067
#define ER_MYSQL_3068 3068
#define ER_MYSQL_3069 3069
#define ER_MYSQL_3070 3070
#define ER_MYSQL_3071 3071
#define ER_MYSQL_3072 3072
#define ER_MYSQL_3073 3073
#define ER_MYSQL_3074 3074
#define ER_MYSQL_3075 3075
#define ER_MYSQL_3076 3076
#define ER_MYSQL_3077 3077
#define ER_MYSQL_3078 3078
#define ER_MYSQL_3079 3079
#define ER_MYSQL_3080 3080
#define ER_MYSQL_3081 3081
#define ER_MYSQL_3082 3082
#define ER_MYSQL_3083 3083
#define ER_MYSQL_3084 3084
#define ER_MYSQL_3085 3085
#define ER_MYSQL_3086 3086
#define ER_MYSQL_3087 3087
#define ER_MYSQL_3088 3088
#define ER_MYSQL_3089 3089
#define ER_MYSQL_3090 3090
#define ER_MYSQL_3091 3091
#define ER_MYSQL_3092 3092
#define ER_MYSQL_3093 3093
#define ER_MYSQL_3094 3094
#define ER_MYSQL_3095 3095
#define ER_MYSQL_3096 3096
#define ER_MYSQL_3097 3097
#define ER_MYSQL_3098 3098
#define ER_MYSQL_3099 3099
#define ER_MYSQL_3100 3100
#define ER_MYSQL_3101 3101
#define ER_MYSQL_3102 3102
#define ER_MYSQL_3103 3103
#define ER_MYSQL_3104 3104
#define ER_MYSQL_3105 3105
#define ER_MYSQL_3106 3106
#define ER_MYSQL_3107 3107
#define ER_MYSQL_3108 3108
#define ER_MYSQL_3109 3109
#define ER_MYSQL_3110 3110
#define ER_MYSQL_3111 3111
#define ER_MYSQL_3112 3112
#define ER_MYSQL_3113 3113
#define ER_MYSQL_3114 3114
#define ER_MYSQL_3115 3115
#define ER_MYSQL_3116 3116
#define ER_MYSQL_3117 3117
#define ER_MYSQL_3118 3118
#define ER_MYSQL_3119 3119
#define ER_MYSQL_3120 3120
#define ER_MYSQL_3121 3121
#define ER_MYSQL_3122 3122
#define ER_MYSQL_3123 3123
#define ER_MYSQL_3124 3124
#define ER_MYSQL_3125 3125
#define ER_MYSQL_3126 3126
#define ER_MYSQL_3127 3127
#define ER_MYSQL_3128 3128
#define ER_MYSQL_3129 3129
#define ER_MYSQL_3130 3130
#define ER_MYSQL_3131 3131
#define ER_MYSQL_3132 3132
#define ER_MYSQL_3133 3133
#define ER_MYSQL_3134 3134
#define ER_MYSQL_3135 3135
#define ER_MYSQL_3136 3136
#define ER_MYSQL_3137 3137
#define ER_MYSQL_3138 3138
#define ER_MYSQL_3139 3139
#define ER_MYSQL_3140 3140
#define ER_MYSQL_3141 3141
#define ER_MYSQL_3142 3142
#define ER_MYSQL_3143 3143
#define ER_MYSQL_3144 3144
#define ER_MYSQL_3145 3145
#define ER_MYSQL_3146 3146
#define ER_MYSQL_3147 3147
#define ER_MYSQL_3148 3148
#define ER_MYSQL_3149 3149
#define ER_MYSQL_3150 3150
#define ER_MYSQL_3151 3151
#define ER_MYSQL_3152 3152
#define ER_MYSQL_3153 3153
#define ER_MYSQL_3154 3154
#define ER_MYSQL_3155 3155
#define ER_MYSQL_3156 3156
#define ER_MYSQL_3157 3157
#define ER_MYSQL_3158 3158
#define ER_SECURE_TRANSPORT_REQUIRED 3159
#define ER_ERROR_LAST_SECTION_4 3159
/* New section */
#define ER_ERROR_FIRST_SECTION_5 4000
#define ER_UNUSED_26 4000
#define ER_UNUSED_27 4001
#define ER_WITH_COL_WRONG_LIST 4002
#define ER_TOO_MANY_DEFINITIONS_IN_WITH_CLAUSE 4003
#define ER_DUP_QUERY_NAME 4004
#define ER_RECURSIVE_WITHOUT_ANCHORS 4005
#define ER_UNACCEPTABLE_MUTUAL_RECURSION 4006
#define ER_REF_TO_RECURSIVE_WITH_TABLE_IN_DERIVED 4007
#define ER_NOT_STANDARD_COMPLIANT_RECURSIVE 4008
#define ER_WRONG_WINDOW_SPEC_NAME 4009
#define ER_DUP_WINDOW_NAME 4010
#define ER_PARTITION_LIST_IN_REFERENCING_WINDOW_SPEC 4011
#define ER_ORDER_LIST_IN_REFERENCING_WINDOW_SPEC 4012
#define ER_WINDOW_FRAME_IN_REFERENCED_WINDOW_SPEC 4013
#define ER_BAD_COMBINATION_OF_WINDOW_FRAME_BOUND_SPECS 4014
#define ER_WRONG_PLACEMENT_OF_WINDOW_FUNCTION 4015
#define ER_WINDOW_FUNCTION_IN_WINDOW_SPEC 4016
#define ER_NOT_ALLOWED_WINDOW_FRAME 4017
#define ER_NO_ORDER_LIST_IN_WINDOW_SPEC 4018
#define ER_RANGE_FRAME_NEEDS_SIMPLE_ORDERBY 4019
#define ER_WRONG_TYPE_FOR_ROWS_FRAME 4020
#define ER_WRONG_TYPE_FOR_RANGE_FRAME 4021
#define ER_FRAME_EXCLUSION_NOT_SUPPORTED 4022
#define ER_WINDOW_FUNCTION_DONT_HAVE_FRAME 4023
#define ER_INVALID_NTILE_ARGUMENT 4024
#define ER_CONSTRAINT_FAILED 4025
#define ER_EXPRESSION_IS_TOO_BIG 4026
#define ER_ERROR_EVALUATING_EXPRESSION 4027
#define ER_CALCULATING_DEFAULT_VALUE 4028
#define ER_EXPRESSION_REFERS_TO_UNINIT_FIELD 4029
#define ER_PARTITION_DEFAULT_ERROR 4030
#define ER_REFERENCED_TRG_DOES_NOT_EXIST 4031
#define ER_INVALID_DEFAULT_PARAM 4032
#define ER_BINLOG_NON_SUPPORTED_BULK 4033
#define ER_BINLOG_UNCOMPRESS_ERROR 4034
#define ER_JSON_BAD_CHR 4035
#define ER_JSON_NOT_JSON_CHR 4036
#define ER_JSON_EOS 4037
#define ER_JSON_SYNTAX 4038
#define ER_JSON_ESCAPING 4039
#define ER_JSON_DEPTH 4040
#define ER_JSON_PATH_EOS 4041
#define ER_JSON_PATH_SYNTAX 4042
#define ER_JSON_PATH_DEPTH 4043
#define ER_JSON_PATH_NO_WILDCARD 4044
#define ER_JSON_PATH_ARRAY 4045
#define ER_JSON_ONE_OR_ALL 4046
#define ER_UNSUPPORTED_COMPRESSED_TABLE 4047
#define ER_GEOJSON_INCORRECT 4048
#define ER_GEOJSON_TOO_FEW_POINTS 4049
#define ER_GEOJSON_NOT_CLOSED 4050
#define ER_JSON_PATH_EMPTY 4051
#define ER_SLAVE_SAME_ID 4052
#define ER_FLASHBACK_NOT_SUPPORTED 4053
#define ER_KEYS_OUT_OF_ORDER 4054
#define ER_OVERLAPPING_KEYS 4055
#define ER_REQUIRE_ROW_BINLOG_FORMAT 4056
#define ER_ISOLATION_MODE_NOT_SUPPORTED 4057
#define ER_ON_DUPLICATE_DISABLED 4058
#define ER_UPDATES_WITH_CONSISTENT_SNAPSHOT 4059
#define ER_ROLLBACK_ONLY 4060
#define ER_ROLLBACK_TO_SAVEPOINT 4061
#define ER_ISOLATION_LEVEL_WITH_CONSISTENT_SNAPSHOT 4062
#define ER_UNSUPPORTED_COLLATION 4063
#define ER_METADATA_INCONSISTENCY 4064
#define ER_CF_DIFFERENT 4065
#define ER_RDB_TTL_DURATION_FORMAT 4066
#define ER_RDB_STATUS_GENERAL 4067
#define ER_RDB_STATUS_MSG 4068
#define ER_RDB_TTL_UNSUPPORTED 4069
#define ER_RDB_TTL_COL_FORMAT 4070
#define ER_PER_INDEX_CF_DEPRECATED 4071
#define ER_KEY_CREATE_DURING_ALTER 4072
#define ER_SK_POPULATE_DURING_ALTER 4073
#define ER_SUM_FUNC_WITH_WINDOW_FUNC_AS_ARG 4074
#define ER_NET_OK_PACKET_TOO_LARGE 4075
#define ER_GEOJSON_EMPTY_COORDINATES 4076
#define ER_MYROCKS_CANT_NOPAD_COLLATION 4077
#define ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION 4078
#define ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION 4079
#define ER_WRONG_PARAMCOUNT_TO_CURSOR 4080
#define ER_UNKNOWN_STRUCTURED_VARIABLE 4081
#define ER_ROW_VARIABLE_DOES_NOT_HAVE_FIELD 4082
#define ER_END_IDENTIFIER_DOES_NOT_MATCH 4083
#define ER_SEQUENCE_RUN_OUT 4084
#define ER_SEQUENCE_INVALID_DATA 4085
#define ER_SEQUENCE_INVALID_TABLE_STRUCTURE 4086
#define ER_SEQUENCE_ACCESS_ERROR 4087
#define ER_SEQUENCE_BINLOG_FORMAT 4088
#define ER_NOT_SEQUENCE 4089
#define ER_NOT_SEQUENCE2 4090
#define ER_UNKNOWN_SEQUENCES 4091
#define ER_UNKNOWN_VIEW 4092
#define ER_WRONG_INSERT_INTO_SEQUENCE 4093
#define ER_SP_STACK_TRACE 4094
#define ER_PACKAGE_ROUTINE_IN_SPEC_NOT_DEFINED_IN_BODY 4095
#define ER_PACKAGE_ROUTINE_FORWARD_DECLARATION_NOT_DEFINED 4096
#define ER_COMPRESSED_COLUMN_USED_AS_KEY 4097
#define ER_UNKNOWN_COMPRESSION_METHOD 4098
#define ER_WRONG_NUMBER_OF_VALUES_IN_TVC 4099
#define ER_FIELD_REFERENCE_IN_TVC 4100
#define ER_WRONG_TYPE_FOR_PERCENTILE_FUNC 4101
#define ER_ARGUMENT_NOT_CONSTANT 4102
#define ER_ARGUMENT_OUT_OF_RANGE 4103
#define ER_WRONG_TYPE_OF_ARGUMENT 4104
#define ER_NOT_AGGREGATE_FUNCTION 4105
#define ER_INVALID_AGGREGATE_FUNCTION 4106
#define ER_INVALID_VALUE_TO_LIMIT 4107
#define ER_INVISIBLE_NOT_NULL_WITHOUT_DEFAULT 4108
#define ER_UPDATE_INFO_WITH_SYSTEM_VERSIONING 4109
#define ER_VERS_FIELD_WRONG_TYPE 4110
#define ER_VERS_ENGINE_UNSUPPORTED 4111
#define ER_WRONG_VERSIONING_RANGE 4112
#define ER_PARTITION_WRONG_TYPE 4113
#define WARN_VERS_PART_FULL 4114
#define WARN_VERS_PARAMETERS 4115
#define ER_VERS_DROP_PARTITION_INTERVAL 4116
#define ER_UNUSED_25 4117
#define WARN_VERS_PART_NON_HISTORICAL 4118
#define ER_VERS_ALTER_NOT_ALLOWED 4119
#define ER_VERS_ALTER_ENGINE_PROHIBITED 4120
#define ER_VERS_RANGE_PROHIBITED 4121
#define ER_CONFLICTING_FOR_SYSTEM_TIME 4122
#define ER_VERS_TABLE_MUST_HAVE_COLUMNS 4123
#define ER_VERS_NOT_VERSIONED 4124
#define ER_MISSING 4125
#define ER_VERS_PERIOD_COLUMNS 4126
#define ER_PART_WRONG_VALUE 4127
#define ER_VERS_WRONG_PARTS 4128
#define ER_VERS_NO_TRX_ID 4129
#define ER_VERS_ALTER_SYSTEM_FIELD 4130
#define ER_DROP_VERSIONING_SYSTEM_TIME_PARTITION 4131
#define ER_VERS_DB_NOT_SUPPORTED 4132
#define ER_VERS_TRT_IS_DISABLED 4133
#define ER_VERS_DUPLICATE_ROW_START_END 4134
#define ER_VERS_ALREADY_VERSIONED 4135
#define ER_UNUSED_24 4136
#define ER_VERS_NOT_SUPPORTED 4137
#define ER_VERS_TRX_PART_HISTORIC_ROW_NOT_SUPPORTED 4138
#define ER_INDEX_FILE_FULL 4139
#define ER_UPDATED_COLUMN_ONLY_ONCE 4140
#define ER_EMPTY_ROW_IN_TVC 4141
#define ER_VERS_QUERY_IN_PARTITION 4142
#define ER_KEY_DOESNT_SUPPORT 4143
#define ER_ALTER_OPERATION_TABLE_OPTIONS_NEED_REBUILD 4144
#define ER_BACKUP_LOCK_IS_ACTIVE 4145
#define ER_BACKUP_NOT_RUNNING 4146
#define ER_BACKUP_WRONG_STAGE 4147
#define ER_BACKUP_STAGE_FAILED 4148
#define ER_BACKUP_UNKNOWN_STAGE 4149
#define ER_USER_IS_BLOCKED 4150
#define ER_ACCOUNT_HAS_BEEN_LOCKED 4151
#define ER_PERIOD_TEMPORARY_NOT_ALLOWED 4152
#define ER_PERIOD_TYPES_MISMATCH 4153
#define ER_MORE_THAN_ONE_PERIOD 4154
#define ER_PERIOD_FIELD_WRONG_ATTRIBUTES 4155
#define ER_PERIOD_NOT_FOUND 4156
#define ER_PERIOD_COLUMNS_UPDATED 4157
#define ER_PERIOD_CONSTRAINT_DROP 4158
#define ER_TOO_LONG_KEYPART 4159
#define ER_TOO_LONG_DATABASE_COMMENT 4160
#define ER_UNKNOWN_DATA_TYPE 4161
#define ER_UNKNOWN_OPERATOR 4162
#define ER_UNUSED_29 4163
#define ER_PART_STARTS_BEYOND_INTERVAL 4164
#define ER_GALERA_REPLICATION_NOT_SUPPORTED 4165
#define ER_LOAD_INFILE_CAPABILITY_DISABLED 4166
#define ER_NO_SECURE_TRANSPORTS_CONFIGURED 4167
#define ER_SLAVE_IGNORED_SHARED_TABLE 4168
#define ER_NO_AUTOINCREMENT_WITH_UNIQUE 4169
#define ER_KEY_CONTAINS_PERIOD_FIELDS 4170
#define ER_KEY_CANT_HAVE_WITHOUT_OVERLAPS 4171
#define ER_NOT_ALLOWED_IN_THIS_CONTEXT 4172
#define ER_DATA_WAS_COMMITED_UNDER_ROLLBACK 4173
#define ER_PK_INDEX_CANT_BE_IGNORED 4174
#define ER_BINLOG_UNSAFE_SKIP_LOCKED 4175
#define ER_JSON_TABLE_ERROR_ON_FIELD 4176
#define ER_JSON_TABLE_ALIAS_REQUIRED 4177
#define ER_JSON_TABLE_SCALAR_EXPECTED 4178
#define ER_JSON_TABLE_MULTIPLE_MATCHES 4179
#define ER_WITH_TIES_NEEDS_ORDER 4180
#define ER_REMOVED_ORPHAN_TRIGGER 4181
#define ER_STORAGE_ENGINE_DISABLED 4182
#define WARN_SFORMAT_ERROR 4183
#define ER_PARTITION_CONVERT_SUBPARTITIONED 4184
#define ER_PROVIDER_NOT_LOADED 4185
#define ER_JSON_HISTOGRAM_PARSE_FAILED 4186
#define ER_SF_OUT_INOUT_ARG_NOT_ALLOWED 4187
#define ER_INCONSISTENT_SLAVE_TEMP_TABLE 4188
#define ER_VERS_HIST_PART_FAILED 4189
#define WARN_OPTION_CHANGING 4190
#define ER_CM_OPTION_MISSING_REQUIREMENT 4191
#define ER_SLAVE_STATEMENT_TIMEOUT 4192
#define ER_JSON_INVALID_VALUE_FOR_KEYWORD 4193
#define ER_JSON_SCHEMA_KEYWORD_UNSUPPORTED 4194
#define ER_JSON_NO_VARIABLE_SCHEMA 4195
#define ER_SEQUENCE_TABLE_HAS_WRONG_NUMBER_OF_COLUMNS 4196
#define ER_SEQUENCE_TABLE_CANNOT_HAVE_ANY_KEYS 4197
#define ER_SEQUENCE_TABLE_CANNOT_HAVE_ANY_CONSTRAINTS 4198
#define ER_SEQUENCE_TABLE_ORDER_BY 4199
#define ER_VARIABLE_IGNORED 4200
#define ER_INCORRECT_COLUMN_NAME_COUNT 4201
#define WARN_SORTING_ON_TRUNCATED_LENGTH 4202
#define ER_VECTOR_BINARY_FORMAT_INVALID 4203
#define ER_VECTOR_FORMAT_INVALID 4204
#define ER_PSEUDO_THREAD_ID_OVERWRITE 4205
#define ER_ERROR_LAST 4205
#endif /* ER_ERROR_FIRST */
PK ! ^ mysql_version.hnu [ /* Copyright Abandoned 1996,1999 TCX DataKonsult AB & Monty Program KB
& Detron HB, 1996, 1999-2004, 2007 MySQL AB.
This file is public domain and comes with NO WARRANTY of any kind
*/
/* Version numbers for protocol & mysqld */
#ifndef _mysql_version_h
#define _mysql_version_h
#ifdef _CUSTOMCONFIG_
#include
#else
#define PROTOCOL_VERSION 10
#define MYSQL_SERVER_VERSION "11.4.12-MariaDB"
#define MYSQL_BASE_VERSION "mysqld-11.4"
#define MARIADB_BASE_VERSION "mariadb-11.4"
#define MARIADBD_BASE_VERSION "mariadbd-11.4"
#define MYSQL_SERVER_SUFFIX_DEF ""
#define FRM_VER 6
#define MYSQL_VERSION_ID 110412
#define MARIADB_PORT 3306
#define MYSQL_PORT_DEFAULT 0
#define MARIADB_UNIX_ADDR "/var/lib/mysql/mysql.sock"
#define MYSQL_CONFIG_NAME "my"
#define MYSQL_COMPILATION_COMMENT "MariaDB Server"
#define SERVER_MATURITY_LEVEL MariaDB_PLUGIN_MATURITY_STABLE
#define MYSQL_PORT MARIADB_PORT
#define MYSQL_UNIX_ADDR MARIADB_UNIX_ADDR
#ifdef WITH_WSREP
#define WSREP_PATCH_VERSION "wsrep_26.22"
#endif
/* mysqld compile time options */
#endif /* _CUSTOMCONFIG_ */
#ifndef LICENSE
#define LICENSE GPL
#endif /* LICENSE */
#endif /* _mysql_version_h */
PK ! ɗ-d d
mysql_embed.hnu [ #ifndef MYSQL_EMBED_INCLUDED
#define MYSQL_EMBED_INCLUDED
/*
Copyright (c) 2000, 2011, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/* Defines that are unique to the embedded version of MySQL */
#ifdef EMBEDDED_LIBRARY
/* Things we don't need in the embedded version of MySQL */
/* TODO HF add #undef HAVE_VIO if we don't want client in embedded library */
#undef HAVE_DLOPEN /* No udf functions */
#endif /* EMBEDDED_LIBRARY */
#endif /* MYSQL_EMBED_INCLUDED */
PK ! y my_sys.hnu [ /* Copyright (c) 2000, 2013, Oracle and/or its affiliates.
Copyright (c) 2010, 2022, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _my_sys_h
#define _my_sys_h
#include
#include
C_MODE_START
#include
#include
#include /* for CHARSET_INFO */
#include
#include
#include
#include
#include
#include
#define MY_INIT(name) { my_progname= name; my_init(); }
/**
Max length of an error message generated by mysys utilities.
Some mysys functions produce error messages. These mostly go
to stderr.
This constant defines the size of the buffer used to format
the message. It should be kept in sync with MYSQL_ERRMSG_SIZE,
since sometimes mysys errors are stored in the server diagnostics
area, and we would like to avoid unexpected truncation.
*/
#define MYSYS_ERRMSG_SIZE (512)
#define MYSYS_STRERROR_SIZE (128)
#define MY_FILE_ERROR ((size_t) -1)
/* General bitmaps for my_func's */
#define MY_FFNF 1U /* Fatal if file not found */
#define MY_FNABP 2U /* Fatal if not all bytes read/written */
#define MY_NABP 4U /* Error if not all bytes read/written */
#define MY_FAE 8U /* Fatal if any error */
#define MY_WME 16U /* Write message on error */
#define MY_WAIT_IF_FULL 32U /* Wait and try again if disk full error */
#define MY_IGNORE_BADFD 32U /* my_sync(): ignore 'bad descriptor' errors */
#define MY_IGNORE_ENOENT 32U /* my_delete() ignores ENOENT (no such file) */
#define MY_ENCRYPT 64U /* Encrypt IO_CACHE temporary files */
#define MY_TEMPORARY 64U /* create_temp_file(): delete file at once */
#define MY_NOSYMLINKS 512U /* my_open(): don't follow symlinks */
#define MY_FULL_IO 512U /* my_read(): loop until I/O is complete */
#define MY_DONT_CHECK_FILESIZE 128U /* Option to init_io_cache() */
#define MY_LINK_WARNING 32U /* my_redel() gives warning if links */
#define MY_COPYTIME 64U /* my_redel() copies time */
#define MY_DELETE_OLD 256U /* my_create_with_symlink() */
#define MY_RESOLVE_LINK 128U /* my_realpath(); Only resolve links */
#define MY_HOLD_ORIGINAL_MODES 128U /* my_copy() holds to file modes */
#define MY_REDEL_MAKE_BACKUP 256U
#define MY_SEEK_NOT_DONE 32U /* my_lock may have to do a seek */
#define MY_SHORT_WAIT 64U /* my_lock() don't wait if can't lock */
#define MY_FORCE_LOCK 128U /* use my_lock() even if disable_locking */
#define MY_NO_WAIT 256U /* my_lock() don't wait at all */
#define MY_NO_REGISTER 8196U /* my_open(), no malloc for file name */
/*
If old_mode is UTF8_IS_UTF8MB3, then pass this flag. It mean utf8 is
alias for utf8mb3. Otherwise utf8 is alias for utf8mb4.
*/
#define MY_UTF8_IS_UTF8MB3 1024U
/*
init_dynamic_array() has init buffer; Internal flag, not to be used by
caller.
*/
#define MY_INIT_BUFFER_USED 256U
#define MY_ZEROFILL 32U /* my_malloc(), fill array with zero */
#define MY_ALLOW_ZERO_PTR 64U /* my_realloc() ; zero ptr -> malloc */
#define MY_FREE_ON_ERROR 128U /* my_realloc() ; Free old ptr on error */
#define MY_DONT_OVERWRITE_FILE 2048U /* my_copy: Don't overwrite file */
#define MY_THREADSAFE 2048U /* my_seek(): lock fd mutex */
#define MY_SYNC 4096U /* my_copy(): sync dst file */
#define MY_SYNC_DIR 32768U /* my_create/delete/rename: sync directory */
#define MY_THREAD_SPECIFIC 0x10000U /* my_malloc(): thread specific */
#define MY_ROOT_USE_MPROTECT 0x20000U /* init_alloc_root: read only segments */
/* Tree that should delete things automatically */
#define MY_TREE_WITH_DELETE 0x40000U
#define MY_CHECK_ERROR 1U /* Params to my_end; Check open-close */
#define MY_GIVE_INFO 2U /* Give time info about process*/
#define MY_DONT_FREE_DBUG 4U /* Do not call DBUG_END() in my_end() */
#define ME_BELL 4U /* Ring bell then printing message */
#define ME_ERROR_LOG 64 /**< write the error message to error log */
#define ME_ERROR_LOG_ONLY 128 /**< write the error message to error log only */
#define ME_NOTE 1024 /**< not error but just info */
#define ME_WARNING 2048 /**< not error but just warning */
#define ME_FATAL 4096 /**< fatal statement error */
/* Bits in last argument to fn_format */
#define MY_REPLACE_DIR 1U /* replace dir in name with 'dir' */
#define MY_REPLACE_EXT 2U /* replace extension with 'ext' */
#define MY_UNPACK_FILENAME 4U /* Unpack name (~ -> home) */
#define MY_PACK_FILENAME 8U /* Pack name (home -> ~) */
#define MY_RESOLVE_SYMLINKS 16U /* Resolve all symbolic links */
#define MY_RETURN_REAL_PATH 32U /* return full path for file */
#define MY_SAFE_PATH 64U /* Return NULL if too long path */
#define MY_RELATIVE_PATH 128U /* name is relative to 'dir' */
#define MY_APPEND_EXT 256U /* add 'ext' as additional extension*/
/* My seek flags */
#define MY_SEEK_SET 0
#define MY_SEEK_CUR 1
#define MY_SEEK_END 2
/* Some constants */
#define MY_WAIT_FOR_USER_TO_FIX_PANIC 60 /* in seconds */
#define MY_WAIT_GIVE_USER_A_MESSAGE 10 /* Every 10 times of prev */
#define MIN_COMPRESS_LENGTH 50 /* Don't compress small bl. */
#define DFLT_INIT_HITS 3
/* root_alloc flags */
#define MY_KEEP_PREALLOC 1U
#define MY_MARK_BLOCKS_FREE 2U /* move used to free list and reuse them */
/* Internal error numbers (for assembler functions) */
#define MY_ERRNO_EDOM 33
#define MY_ERRNO_ERANGE 34
/* Bits for get_date timeflag */
#define GETDATE_DATE_TIME 1U
#define GETDATE_SHORT_DATE 2U
#define GETDATE_HHMMSSTIME 4U
#define GETDATE_GMT 8U
#define GETDATE_FIXEDLENGTH 16U
/* Extra length needed for filename if one calls my_create_backup_name */
#define MY_BACKUP_NAME_EXTRA_LENGTH 17
char *guess_malloc_library();
/* If we have our own safemalloc (for debugging) */
#if defined(SAFEMALLOC)
my_bool sf_report_leaked_memory(my_thread_id id);
int sf_sanity();
my_bool sf_have_memory_leak();
extern my_thread_id (*sf_malloc_dbug_id)(void);
#define SAFEMALLOC_REPORT_MEMORY(X) if (!sf_leaking_memory) sf_report_leaked_memory(X)
#define SAFEMALLOC_HAVE_MEMORY_LEAK sf_have_memory_leak()
#else
#define SAFEMALLOC_REPORT_MEMORY(X) do {} while(0)
#define SAFEMALLOC_HAVE_MEMORY_LEAK 0
#endif
typedef void (*MALLOC_SIZE_CB) (long long size, my_bool is_thread_specific);
extern void set_malloc_size_cb(MALLOC_SIZE_CB func);
extern MALLOC_SIZE_CB update_malloc_size;
extern int64 my_malloc_init_memory_allocated;
/* defines when allocating data */
extern void *my_malloc(PSI_memory_key key, size_t size, myf MyFlags);
extern void *my_multi_malloc(PSI_memory_key key, myf MyFlags, ...);
extern void *my_multi_malloc_large(PSI_memory_key key, myf MyFlags, ...);
extern void *my_realloc(PSI_memory_key key, void *ptr, size_t size, myf MyFlags);
extern void my_free(void *ptr);
extern void *my_memdup(PSI_memory_key key, const void *from,size_t length,myf MyFlags);
extern char *my_strdup(PSI_memory_key key, const char *from,myf MyFlags);
extern char *my_strndup(PSI_memory_key key, const char *from, size_t length, myf MyFlags);
extern my_bool my_use_large_pages;
int my_init_large_pages(void);
uchar *my_large_malloc(size_t *size, myf my_flags);
#ifdef _WIN32
/* On Windows, use my_virtual_mem_reserve() and my_virtual_mem_commit(). */
#else
char *my_large_virtual_alloc(size_t *size);
#endif
void my_large_free(void *ptr, size_t size);
void my_large_page_truncate(size_t *size);
#ifdef _WIN32
extern BOOL my_obtain_privilege(LPCSTR lpPrivilege);
#endif
void my_init_atomic_write(void);
#ifdef __linux__
my_bool my_test_if_atomic_write(File handle, int pagesize);
my_bool my_test_if_thinly_provisioned(File handle);
#else
# define my_test_if_atomic_write(A, B) 0
# define my_test_if_thinly_provisioned(A) 0
#endif /* __linux__ */
extern my_bool my_may_have_atomic_write;
#if defined(HAVE_ALLOCA) && !defined(HAVE_valgrind)
#define my_alloca(SZ) alloca((size_t) (SZ))
#define my_afree(PTR) ((void)0)
#define MAX_ALLOCA_SZ 4096
#define my_safe_alloca(size) (((size) <= MAX_ALLOCA_SZ) ? \
my_alloca(size) : \
my_malloc(PSI_NOT_INSTRUMENTED, (size), MYF(MY_THREAD_SPECIFIC|MY_WME)))
#define my_safe_afree(ptr, size) \
do { if ((size) > MAX_ALLOCA_SZ) my_free(ptr); } while(0)
#else
#define my_alloca(SZ) my_malloc(PSI_NOT_INSTRUMENTED, SZ,MYF(MY_FAE))
#define my_afree(PTR) my_free(PTR)
#define my_safe_alloca(size) my_alloca(size)
#define my_safe_afree(ptr, size) my_afree(ptr)
#endif /* HAVE_ALLOCA */
#ifndef errno /* did we already get it? */
#ifdef HAVE_ERRNO_AS_DEFINE
#include /* errno is a define */
#else
extern int errno; /* declare errno */
#endif
#endif /* #ifndef errno */
extern char *home_dir; /* Home directory for user */
extern MYSQL_PLUGIN_IMPORT char *mysql_data_home;
extern const char *my_progname; /* program-name (printed in errors) */
extern const char *my_progname_short; /* like above but without directory */
extern char curr_dir[]; /* Current directory for user */
extern void (*error_handler_hook)(uint my_err, const char *str,myf MyFlags);
extern void (*fatal_error_handler_hook)(uint my_err, const char *str,
myf MyFlags);
extern uint my_file_limit;
extern ulonglong my_thread_stack_size;
extern int sf_leaking_memory; /* set to 1 to disable memleak detection */
extern void (*proc_info_hook)(void *, const PSI_stage_info *, PSI_stage_info *,
const char *, const char *, const unsigned int);
/* charsets */
#define MY_ALL_CHARSETS_SIZE 4096
extern MYSQL_PLUGIN_IMPORT CHARSET_INFO *default_charset_info;
extern MYSQL_PLUGIN_IMPORT CHARSET_INFO *all_charsets[MY_ALL_CHARSETS_SIZE];
extern struct charset_info_st compiled_charsets[];
/* Collation properties and use statistics */
extern my_bool my_collation_is_known_id(uint id);
extern ulonglong my_collation_statistics_get_use_count(uint id);
extern const char *my_collation_get_tailoring(uint id);
/* statistics */
extern ulong my_stream_opened, my_tmp_file_created;
extern ulong my_file_total_opened;
extern ulong my_sync_count;
extern uint mysys_usage_id;
extern int32 my_file_opened;
extern my_bool my_init_done, my_thr_key_mysys_exists;
extern my_bool my_assert;
extern my_bool my_assert_on_error;
extern myf my_global_flags; /* Set to MY_WME for more error messages */
/* Point to current my_message() */
extern void (*my_sigtstp_cleanup)(void),
/* Executed before jump to shell */
(*my_sigtstp_restart)(void);
/* Executed when coming from shell */
extern MYSQL_PLUGIN_IMPORT mode_t my_umask; /* Default creation mask */
extern mode_t my_umask_dir;
extern int my_recived_signals, /* Signals we have got */
my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
my_dont_interrupt; /* call remember_intr when set */
#ifdef _WIN32
extern SECURITY_ATTRIBUTES my_dir_security_attributes;
LPSECURITY_ATTRIBUTES my_win_file_secattr();
#endif
extern MYSQL_PLUGIN_IMPORT my_bool my_use_symdir;
extern ulong my_default_record_cache_size;
extern MYSQL_PLUGIN_IMPORT my_bool my_disable_locking;
extern my_bool my_disable_async_io,
my_disable_flush_key_blocks, my_disable_symlinks;
extern my_bool my_disable_sync, my_disable_copystat_in_redel;
extern char wild_many,wild_one,wild_prefix;
extern const char *charsets_dir;
extern size_t my_system_page_size;
enum cache_type
{
TYPE_NOT_SET= 0, READ_CACHE, WRITE_CACHE,
SEQ_READ_APPEND /* sequential read or append */,
READ_FIFO, READ_NET};
enum flush_type
{
FLUSH_KEEP, /* flush block and keep it in the cache */
FLUSH_RELEASE, /* flush block and remove it from the cache */
FLUSH_IGNORE_CHANGED, /* remove block from the cache */
/*
As my_disable_flush_pagecache_blocks is always 0, the following option
is strictly equivalent to FLUSH_KEEP
*/
FLUSH_FORCE_WRITE,
/**
@brief like FLUSH_KEEP but return immediately if file is already being
flushed (even partially) by another thread; only for page cache,
forbidden for key cache.
*/
FLUSH_KEEP_LAZY
};
typedef struct st_record_cache /* Used when caching records */
{
File file;
int rc_seek,error,inited;
uint rc_length,read_length,reclength;
my_off_t rc_record_pos,end_of_file;
uchar *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
enum cache_type type;
} RECORD_CACHE;
enum file_type
{
UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN,
FILE_BY_O_TMPFILE, FILE_BY_MKSTEMP, FILE_BY_DUP
};
struct st_my_file_info
{
char *name;
#ifdef _WIN32
HANDLE fhandle; /* win32 file handle */
int oflag; /* open flags, e.g O_APPEND */
#endif
enum file_type type;
};
extern struct st_my_file_info *my_file_info;
/* Free function pointer */
typedef void (*FREE_FUNC)(void *);
typedef struct st_dynamic_array
{
uchar *buffer;
size_t elements, max_element;
size_t alloc_increment;
size_t size_of_element;
PSI_memory_key m_psi_key;
myf malloc_flags;
} DYNAMIC_ARRAY;
typedef struct st_dynamic_array_append
{
DYNAMIC_ARRAY *array;
uchar *pos, *end;
} DYNAMIC_ARRAY_APPEND;
typedef struct st_my_tmpdir
{
DYNAMIC_ARRAY full_list;
char **list;
size_t cur, max;
mysql_mutex_t mutex;
} MY_TMPDIR;
typedef struct st_dynamic_string
{
char *str;
size_t length,max_length,alloc_increment;
} DYNAMIC_STRING;
struct st_io_cache;
typedef struct st_io_cache_share
{
mysql_mutex_t mutex; /* To sync on reads into buffer. */
mysql_cond_t cond; /* To wait for signals. */
mysql_cond_t cond_writer; /* For a synchronized writer. */
/* Offset in file corresponding to the first byte of buffer. */
my_off_t pos_in_file;
/* If a synchronized write cache is the source of the data. */
struct st_io_cache *source_cache;
uchar *buffer; /* The read buffer. */
uchar *read_end; /* Behind last valid byte of buffer. */
int running_threads; /* threads not in lock. */
int total_threads; /* threads sharing the cache. */
int error; /* Last error. */
#ifdef NOT_YET_IMPLEMENTED
/* whether the structure should be free'd */
my_bool alloced;
#endif
} IO_CACHE_SHARE;
typedef struct st_io_cache /* Used when caching files */
{
/* Offset in file corresponding to the first byte of uchar* buffer. */
my_off_t pos_in_file;
/*
The offset of end of file for READ_CACHE and WRITE_CACHE.
For SEQ_READ_APPEND it the maximum of the actual end of file and
the position represented by read_end.
*/
my_off_t end_of_file;
/* Points to current read position in the buffer */
uchar *read_pos;
/* the non-inclusive boundary in the buffer for the currently valid read */
uchar *read_end;
uchar *buffer; /* The read buffer */
/* Used in ASYNC_IO */
uchar *request_pos;
/* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
uchar *write_buffer;
/*
Only used in SEQ_READ_APPEND, and points to the current read position
in the write buffer. Note that reads in SEQ_READ_APPEND caches can
happen from both read buffer (uchar* buffer) and write buffer
(uchar* write_buffer).
*/
uchar *append_read_pos;
/* Points to current write position in the write buffer */
uchar *write_pos;
/* The non-inclusive boundary of the valid write area */
uchar *write_end;
/*
The lock is for append buffer used in SEQ_READ_APPEND cache
need mutex copying from append buffer to read buffer.
*/
mysql_mutex_t append_buffer_lock;
/*
The following is used when several threads are reading the
same file in parallel. They are synchronized on disk
accesses reading the cached part of the file asynchronously.
It should be set to NULL to disable the feature. Only
READ_CACHE mode is supported.
*/
IO_CACHE_SHARE *share;
/*
A caller will use my_b_read() macro to read from the cache
if the data is already in cache, it will be simply copied with
memcpy() and internal variables will be accordingly updated with
no functions invoked. However, if the data is not fully in the cache,
my_b_read() will call read_function to fetch the data. read_function
must never be invoked directly.
*/
int (*read_function)(struct st_io_cache *,uchar *,size_t);
/*
Same idea as in the case of read_function, except my_b_write() needs to
be replaced with my_b_append() for a SEQ_READ_APPEND cache
*/
int (*write_function)(struct st_io_cache *,const uchar *,size_t);
/*
Specifies the type of the cache. Depending on the type of the cache
certain operations might not be available and yield unpredicatable
results. Details to be documented later
*/
enum cache_type type;
/*
Counts the number of times, when we were forced to use disk. We use it to
increase the binlog_cache_disk_use and binlog_stmt_cache_disk_use status
variables.
*/
ulong disk_writes;
char *file_name; /* if used with 'open_cached_file' */
const char *dir;
char prefix[3];
File file; /* file descriptor */
struct st_io_cache *next_file_user;
/*
seek_not_done is set by my_b_seek() to inform the upcoming read/write
operation that a seek needs to be preformed prior to the actual I/O
error is 0 if the cache operation was successful, -1 if there was a
"hard" error, and the actual number of I/O-ed bytes if the read/write was
partial.
*/
int seek_not_done,error;
/* length of the buffer used for storing un-encrypted data */
size_t buffer_length;
/* read_length is the same as buffer_length except when we use async io */
size_t read_length;
myf myflags; /* Flags used to my_read/my_write */
/*
alloced_buffer is set to the size of the buffer allocated for the IO_CACHE.
Includes the overhead(storing key to encrypt and decrypt) for encryption.
Set to 0 if nothing is allocated.
Currently READ_NET is the only one that will use a buffer allocated
somewhere else
*/
size_t alloced_buffer;
} IO_CACHE;
typedef void (*my_error_reporter)(enum loglevel level, const char *format, ...)
ATTRIBUTE_FORMAT_FPTR(printf, 2, 3);
extern my_error_reporter my_charset_error_reporter;
extern PSI_file_key key_file_io_cache;
/* inline functions for mf_iocache */
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
extern int _my_b_get(IO_CACHE *info);
extern int _my_b_read(IO_CACHE *info,uchar *Buffer,size_t Count);
extern int _my_b_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
/* Test if buffer is inited */
static inline void my_b_clear(IO_CACHE *info) { info->buffer= 0; }
static inline int my_b_inited(IO_CACHE *info) { return MY_TEST(info->buffer); }
#define my_b_EOF INT_MIN
static inline int my_b_read(IO_CACHE *info, uchar *Buffer, size_t Count)
{
if (info->read_pos + Count <= info->read_end)
{
memcpy(Buffer, info->read_pos, Count);
info->read_pos+= Count;
return 0;
}
return _my_b_read(info, Buffer, Count);
}
static inline int my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
MEM_CHECK_DEFINED(Buffer, Count);
if (info->write_pos + Count <= info->write_end)
{
if (Count)
{
memcpy(info->write_pos, Buffer, Count);
info->write_pos+= Count;
}
return 0;
}
return _my_b_write(info, Buffer, Count);
}
static inline int my_b_get(IO_CACHE *info)
{
if (info->read_pos != info->read_end)
{
info->read_pos++;
return info->read_pos[-1];
}
return _my_b_get(info);
}
static inline my_bool my_b_write_byte(IO_CACHE *info, uchar chr)
{
MEM_CHECK_DEFINED(&chr, 1);
if (info->write_pos >= info->write_end)
if (my_b_flush_io_cache(info, 1))
return 1;
*info->write_pos++= chr;
return 0;
}
/**
Fill buffer of the cache.
@note It assumes that you have already used all characters in the CACHE,
independent of the read_pos value!
@returns
0 On error or EOF (info->error = -1 on error)
# Number of characters
*/
static inline size_t my_b_fill(IO_CACHE *info)
{
info->read_pos= info->read_end;
return _my_b_read(info,0,0) ? 0 : (size_t) (info->read_end - info->read_pos);
}
static inline my_off_t my_b_tell(const IO_CACHE *info)
{
if (info->type == WRITE_CACHE) {
return info->pos_in_file + (my_off_t)(info->write_pos - info->request_pos);
}
return info->pos_in_file + (my_off_t) (info->read_pos - info->request_pos);
}
static inline my_off_t my_b_write_tell(const IO_CACHE *info)
{
return info->pos_in_file + (my_off_t) (info->write_pos - info->write_buffer);
}
static inline uchar* my_b_get_buffer_start(const IO_CACHE *info)
{
return info->request_pos;
}
static inline size_t my_b_get_bytes_in_buffer(const IO_CACHE *info)
{
return (size_t) (info->read_end - info->request_pos);
}
static inline my_off_t my_b_get_pos_in_file(const IO_CACHE *info)
{
return info->pos_in_file;
}
static inline size_t my_b_bytes_in_cache(const IO_CACHE *info)
{
if (info->type == WRITE_CACHE) {
return (size_t) (info->write_end - info->write_pos);
}
return (size_t) (info->read_end - info->read_pos);
}
int my_b_copy_to_file (IO_CACHE *cache, FILE *file, size_t count);
int my_b_copy_all_to_file(IO_CACHE *cache, FILE *file);
int my_b_copy_to_cache(IO_CACHE *from_cache, IO_CACHE *to_cache, size_t count);
int my_b_copy_all_to_cache(IO_CACHE *from_cache, IO_CACHE *to_cache);
my_off_t my_b_append_tell(IO_CACHE* info);
my_off_t my_b_safe_tell(IO_CACHE* info); /* picks the correct tell() */
int my_b_pread(IO_CACHE *info, uchar *Buffer, size_t Count, my_off_t pos);
typedef uint32 ha_checksum;
extern int (*mysys_test_invalid_symlink)(const char *filename);
#include
/* Prototypes for mysys and my_func functions */
extern int my_copy(const char *from,const char *to,myf MyFlags);
extern int my_delete(const char *name,myf MyFlags);
extern int my_rmtree(const char *name, myf Myflags);
extern int my_getwd(char * buf,size_t size,myf MyFlags);
extern int my_setwd(const char *dir,myf MyFlags);
extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
extern void *my_once_alloc(size_t Size,myf MyFlags);
extern void my_once_free(void);
extern char *my_once_strdup(const char *src,myf myflags);
extern void *my_once_memdup(const void *src, size_t len, myf myflags);
extern File my_open(const char *FileName,int Flags,myf MyFlags);
extern File my_register_filename(File fd, const char *FileName,
enum file_type type_of_file,
uint error_message_number, myf MyFlags);
extern File my_create(const char *FileName, mode_t CreateFlags,
int AccessFlags, myf MyFlags);
extern int my_close(File Filedes,myf MyFlags);
extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
extern int my_readlink(char *to, const char *filename, myf MyFlags);
extern int my_is_symlink(const char *filename);
extern int my_realpath(char *to, const char *filename, myf MyFlags);
extern File my_create_with_symlink(const char *linkname, const char *filename,
mode_t createflags, int access_flags,
myf MyFlags);
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
extern int my_symlink(const char *content, const char *linkname, myf MyFlags);
extern int my_handler_delete_with_symlink(const char *filename, myf sync_dir);
extern size_t my_read(File Filedes,uchar *Buffer,size_t Count,myf MyFlags);
extern size_t my_pread(File Filedes,uchar *Buffer,size_t Count,my_off_t offset,
myf MyFlags);
extern int my_rename(const char *from,const char *to,myf MyFlags);
extern my_off_t my_seek(File fd,my_off_t pos,int whence,myf MyFlags);
extern my_off_t my_tell(File fd,myf MyFlags);
extern size_t my_write(File Filedes,const uchar *Buffer,size_t Count,
myf MyFlags);
extern size_t my_pwrite(File Filedes,const uchar *Buffer,size_t Count,
my_off_t offset,myf MyFlags);
extern size_t my_fread(FILE *stream,uchar *Buffer,size_t Count,myf MyFlags);
extern size_t my_fwrite(FILE *stream,const uchar *Buffer,size_t Count,
myf MyFlags);
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
extern void (*my_sleep_for_space)(unsigned int seconds);
extern int my_get_exepath(char *buf, size_t size, const char *argv0);
/* implemented in my_memmem.c */
extern void *my_memmem(const void *haystack, size_t haystacklen,
const void *needle, size_t needlelen);
#ifdef _WIN32
extern int my_access(const char *path, int amode);
#define my_check_user(A,B) (NULL)
#define my_set_user(A,B,C) (0)
#else
#define my_access access
struct passwd *my_check_user(const char *user, myf MyFlags);
int my_set_user(const char *user, struct passwd *user_info, myf MyFlags);
#endif
extern int check_if_legal_filename(const char *path);
extern int check_if_legal_tablename(const char *path);
#ifdef _WIN32
extern my_bool is_filename_allowed(const char *name, size_t length,
my_bool allow_current_dir);
#else /* _WIN32 */
# define is_filename_allowed(name, length, allow_cwd) (TRUE)
#endif /* _WIN32 */
#ifdef _WIN32
/* Windows-only functions (CRT equivalents)*/
extern HANDLE my_get_osfhandle(File fd);
extern File my_win_handle2File(HANDLE hFile);
extern void my_osmaperr(unsigned long last_error);
#endif
extern void init_glob_errs(void);
extern const char** get_global_errmsgs(int nr);
extern void wait_for_free_space(const char *filename, int errors);
extern FILE *my_fopen(const char *FileName,int Flags,myf MyFlags);
extern FILE *my_fdopen(File Filedes,const char *name, int Flags,myf MyFlags);
extern FILE *my_freopen(const char *path, const char *mode, FILE *stream);
extern int my_fclose(FILE *fd,myf MyFlags);
extern int my_vfprintf(FILE *stream, const char* format, va_list args);
extern const char* my_strerror(char *buf, size_t len, int nr);
extern int my_fprintf(FILE *stream, const char* format, ...);
extern File my_fileno(FILE *fd);
extern int my_chsize(File fd,my_off_t newlength, int filler, myf MyFlags);
extern int my_chmod(const char *name, mode_t mode, myf my_flags);
extern const char *my_basename(const char *filename);
extern void thr_set_sync_wait_callback(void (*before_sync)(void),
void (*after_sync)(void));
extern int my_sync(File fd, myf my_flags);
extern int my_sync_dir(const char *dir_name, myf my_flags);
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
extern const char *my_get_err_msg(uint nr);
extern int my_error_register(const char** (*get_errmsgs) (int nr),
uint first, uint last);
extern my_bool my_error_unregister(uint first, uint last);
extern void my_message(uint my_err, const char *str,myf MyFlags);
extern void my_message_stderr(uint my_err, const char *str, myf MyFlags);
extern my_bool my_init(void);
extern void my_end(int infoflag);
extern int my_redel(const char *from, const char *to, time_t backup_time_stamp,
myf MyFlags);
void my_create_backup_name(char *to, const char *from,
time_t backup_time_stamp);
extern int my_copystat(const char *from, const char *to, int MyFlags);
extern char * my_filename(File fd);
extern my_bool init_tmpdir(MY_TMPDIR *tmpdir, const char *pathlist);
extern char *my_tmpdir(MY_TMPDIR *tmpdir);
extern void free_tmpdir(MY_TMPDIR *tmpdir);
extern void my_remember_signal(int signal_number,sig_handler (*func)(int));
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
extern size_t dirname_length(const char *name);
#define base_name(A) (A+dirname_length(A))
extern int test_if_hard_path(const char *dir_name);
extern my_bool has_path(const char *name);
extern char *convert_dirname(char *to, const char *from, const char *from_end);
extern void to_unix_path(char * name);
extern char * fn_ext(const char *name);
extern char * fn_ext2(const char *name);
extern char * fn_same(char * toname,const char *name,int flag);
extern char * fn_format(char * to,const char *name,const char *dir,
const char *form, uint flag);
extern size_t strlength(const char *str);
extern void pack_dirname(char * to,const char *from);
extern size_t normalize_dirname(char * to, const char *from);
extern size_t unpack_dirname(char * to,const char *from);
extern size_t cleanup_dirname(char * to,const char *from);
extern size_t system_filename(char * to,const char *from);
extern size_t unpack_filename(char * to,const char *from);
extern char * intern_filename(char * to,const char *from);
extern int pack_filename(char * to, const char *name, size_t max_length);
extern char * my_path(char * to,const char *progname,
const char *own_pathname_part);
extern char * my_load_path(char * to, const char *path,
const char *own_path_prefix);
extern int wild_compare(const char *str,const char *wildstr,
pbool str_is_pattern);
extern my_bool array_append_string_unique(const char *str,
const char **array, size_t size);
extern void get_date(char * to, size_t to_len, int timeflag,
time_t use_time);
extern void soundex(CHARSET_INFO *, char * out_pntr, char * in_pntr,
pbool remove_garbage);
extern int init_record_cache(RECORD_CACHE *info,size_t cachesize,File file,
size_t reclength,enum cache_type type,
pbool use_async_io);
extern int read_cache_record(RECORD_CACHE *info,uchar *to);
extern int end_record_cache(RECORD_CACHE *info);
extern int write_cache_record(RECORD_CACHE *info,my_off_t filepos,
const uchar *record,size_t length);
extern int flush_write_cache(RECORD_CACHE *info);
extern void handle_recived_signals(void);
extern sig_handler my_set_alarm_variable(int signo);
extern my_bool radixsort_is_applicable(uint n_items, size_t size_of_element);
extern void my_string_ptr_sort(uchar *base,uint items,size_t size);
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
size_t size_of_element,uchar *buffer[]);
extern qsort_t my_qsort(void *base_ptr, size_t total_elems, size_t size,
qsort_cmp cmp);
extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size,
qsort_cmp2 cmp, void *cmp_argument);
extern qsort_cmp2 get_ptr_compare(size_t);
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
my_off_t my_get_ptr(uchar *ptr, size_t pack_length);
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
enum cache_type type,my_off_t seek_offset,
my_bool use_async_io, myf cache_myflags);
extern int init_io_cache_ext(IO_CACHE *info, File file, size_t cachesize,
enum cache_type type, my_off_t seek_offset,
pbool use_async_io, myf cache_myflags,
PSI_file_key file_key);
extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
my_off_t seek_offset, my_bool use_async_io,
my_bool clear_cache);
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
IO_CACHE *write_cache, uint num_threads);
extern int init_slave_io_cache(IO_CACHE *master, IO_CACHE *slave);
void end_slave_io_cache(IO_CACHE *cache);
void seek_io_cache(IO_CACHE *cache, my_off_t needed_offset);
extern void remove_io_thread(IO_CACHE *info);
extern int my_b_append(IO_CACHE *info,const uchar *Buffer,size_t Count);
extern int my_b_safe_write(IO_CACHE *info,const uchar *Buffer,size_t Count);
extern int my_block_write(IO_CACHE *info, const uchar *Buffer,
size_t Count, my_off_t pos);
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
extern int end_io_cache(IO_CACHE *info);
extern void my_b_seek(IO_CACHE *info,my_off_t pos);
extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length);
extern my_off_t my_b_filelength(IO_CACHE *info);
extern my_bool my_b_write_backtick_quote(IO_CACHE *info, const char *str,
size_t len);
extern my_bool my_b_printf(IO_CACHE *info, const char* fmt, ...);
extern size_t my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
extern my_bool open_cached_file(IO_CACHE *cache,const char *dir,
const char *prefix, size_t cache_size,
myf cache_myflags);
extern my_bool real_open_cached_file(IO_CACHE *cache);
extern void close_cached_file(IO_CACHE *cache);
File create_temp_file(char *to, const char *dir, const char *pfx,
int mode, myf MyFlags);
#define my_init_dynamic_array(A,B,C,D,E,F) init_dynamic_array2(A,B,C,NULL,D,E,F)
#define my_init_dynamic_array2(A,B,C,D,E,F,G) init_dynamic_array2(A,B,C,D,E,F,G)
extern my_bool init_dynamic_array2(PSI_memory_key psi_key, DYNAMIC_ARRAY *array,
size_t element_size, void *init_buffer,
size_t init_alloc, size_t alloc_increment,
myf my_flags);
extern my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void* element);
extern void *alloc_dynamic(DYNAMIC_ARRAY *array);
extern void *pop_dynamic(DYNAMIC_ARRAY*);
extern my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element,
size_t array_index);
extern my_bool allocate_dynamic(DYNAMIC_ARRAY *array, size_t max_elements);
extern void get_dynamic(DYNAMIC_ARRAY *array, void *element, size_t array_index);
extern void delete_dynamic(DYNAMIC_ARRAY *array);
extern void delete_dynamic_element(DYNAMIC_ARRAY *array, size_t array_index);
extern void delete_dynamic_with_callback(DYNAMIC_ARRAY *array, FREE_FUNC f);
extern void freeze_size(DYNAMIC_ARRAY *array);
#define dynamic_array_ptr(array,array_index) ((array)->buffer+(array_index)*(array)->size_of_element)
#define dynamic_element(array,array_index,type) ((type)((array)->buffer) +(array_index))
#define push_dynamic(A,B) insert_dynamic((A),(B))
#define reset_dynamic(array) ((array)->elements= 0)
#define sort_dynamic(A,cmp) my_qsort((A)->buffer, (A)->elements, (A)->size_of_element, (cmp))
extern void init_append_dynamic(DYNAMIC_ARRAY_APPEND *append,
DYNAMIC_ARRAY *array);
extern my_bool append_dynamic(DYNAMIC_ARRAY_APPEND *append,
const void * element);
extern my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,
size_t init_alloc,size_t alloc_increment);
extern my_bool dynstr_append(DYNAMIC_STRING *str, const char *append);
my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
size_t length) __attribute__((nonnull(2)));
extern my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
...);
extern my_bool dynstr_append_quoted(DYNAMIC_STRING *str,
const char *append, size_t len,
char quote);
extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
extern my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
extern my_bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
extern void dynstr_free(DYNAMIC_STRING *str);
extern uint32 copy_and_convert_extended(char *to, uint32 to_length,
CHARSET_INFO *to_cs,
const char *from, uint32 from_length,
CHARSET_INFO *from_cs, uint *errors);
extern void dynstr_reassociate(DYNAMIC_STRING *str, char **res, size_t *length,
size_t *alloc_length);
extern uint32 copy_and_convert_extended(char *to, uint32 to_length,
CHARSET_INFO *to_cs,
const char *from, uint32 from_length,
CHARSET_INFO *from_cs, uint *errors);
#ifdef HAVE_MLOCK
extern void *my_malloc_lock(size_t length,myf flags);
extern void my_free_lock(void *ptr);
#else
#define my_malloc_lock(A,B) my_malloc(PSI_INSTRUMENT_ME, (A),(B))
#define my_free_lock(A) my_free((A))
#endif
#define alloc_root_inited(A) ((A)->min_malloc != 0)
#define DEFAULT_ROOT_BLOCK_SIZE 1024
#define clear_alloc_root(A) do { (A)->free= (A)->used= (A)->pre_alloc= 0; (A)->min_malloc=0;} while(0)
extern void init_alloc_root(PSI_memory_key key, MEM_ROOT *mem_root,
size_t block_size, size_t pre_alloc_size,
myf my_flags);
extern void *alloc_root(MEM_ROOT *mem_root, size_t Size);
extern void *multi_alloc_root(MEM_ROOT *mem_root, ...);
extern void free_root(MEM_ROOT *root, myf MyFLAGS);
extern void move_root(MEM_ROOT *to, MEM_ROOT *from);
extern void set_prealloc_root(MEM_ROOT *root, char *ptr);
extern void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
size_t prealloc_size);
extern USED_MEM *get_last_memroot_block(MEM_ROOT* root);
extern void free_all_new_blocks(MEM_ROOT *root, USED_MEM *last_block);
extern void protect_root(MEM_ROOT *root, int prot);
extern char *strdup_root(MEM_ROOT *root,const char *str);
static inline char *safe_strdup_root(MEM_ROOT *root, const char *str)
{
return str ? strdup_root(root, str) : 0;
}
extern char *strmake_root(MEM_ROOT *root,const char *str,size_t len);
extern void *memdup_root(MEM_ROOT *root,const void *str, size_t len);
extern LEX_CSTRING safe_lexcstrdup_root(MEM_ROOT *root, const LEX_CSTRING str);
static inline LEX_STRING lex_string_strmake_root(MEM_ROOT *mem_root,
const char *str, size_t length)
{
LEX_STRING tmp;
tmp.str= strmake_root(mem_root, str, length);
tmp.length= tmp.str ? length : 0;
return tmp;
}
extern LEX_STRING lex_string_casedn_root(MEM_ROOT *root,
CHARSET_INFO *cs,
const char *str, size_t length);
extern my_bool my_compress(uchar *, size_t *, size_t *);
extern my_bool my_uncompress(uchar *, size_t , size_t *);
extern uchar *my_compress_alloc(const uchar *packet, size_t *len,
size_t *complen);
extern void *my_az_allocator(void *dummy, unsigned int items, unsigned int size);
extern void my_az_free(void *dummy, void *address);
extern int my_compress_buffer(uchar *dest, size_t *destLen,
const uchar *source, size_t sourceLen);
extern int packfrm(const uchar *, size_t, uchar **, size_t *);
extern int unpackfrm(uchar **, size_t *, const uchar *);
extern uint32 my_checksum(uint32, const void *, size_t);
extern uint32 my_crc32c(uint32, const void *, size_t);
extern const char *my_crc32c_implementation();
#ifdef DBUG_ASSERT_EXISTS
extern void my_debug_put_break_here(void);
#else
#define my_debug_put_break_here() do {} while(0)
#endif
extern void my_sleep(ulong m_seconds);
extern uint my_set_max_open_files(uint files);
void my_free_open_file_info(void);
extern my_bool my_gethwaddr(uchar *to);
extern int my_getncpus(void);
#define HRTIME_RESOLUTION 1000000ULL /* microseconds */
typedef struct {ulonglong val;} my_hrtime_t;
void my_time_init(void);
extern my_hrtime_t my_hrtime(void);
#ifdef _WIN32
extern my_hrtime_t my_hrtime_coarse();
#else
#define my_hrtime_coarse() my_hrtime()
#endif
extern ulonglong my_interval_timer(void);
extern ulonglong my_getcputime(void);
#define microsecond_interval_timer() (my_interval_timer()/1000)
#define hrtime_to_time(X) ((time_t)((X).val/HRTIME_RESOLUTION))
#define hrtime_from_time(X) ((ulonglong)((X)*HRTIME_RESOLUTION))
#define hrtime_to_double(X) ((X).val/(double)HRTIME_RESOLUTION)
#define hrtime_sec_part(X) ((ulong)((X).val % HRTIME_RESOLUTION))
#define my_time(X) hrtime_to_time(my_hrtime_coarse())
/**
Make high resolution time from two parts.
*/
static inline my_hrtime_t make_hr_time(my_time_t time, ulong time_sec_part)
{
my_hrtime_t res= {((ulonglong) time)*1000000 + time_sec_part};
return res;
}
#if STACK_DIRECTION < 0
#define available_stack_size(CUR,END) (long) ((char*)(CUR) - (char*)(END))
#else
#define available_stack_size(CUR,END) (long) ((char*)(END) - (char*)(CUR))
#endif
#ifndef MAP_SYNC
#define MAP_SYNC 0x80000
#endif
#ifndef MAP_SHARED_VALIDATE
#define MAP_SHARED_VALIDATE 0x03
#endif
#ifdef HAVE_SYS_MMAN_H
#ifndef MAP_NOSYNC
#define MAP_NOSYNC 0
#endif
#ifndef MAP_NORESERVE
#define MAP_NORESERVE 0 /* For irix and AIX */
#endif
#ifdef HAVE_MMAP64
#define my_mmap(a,b,c,d,e,f) mmap64(a,b,c,d,e,f)
#else
#define my_mmap(a,b,c,d,e,f) mmap(a,b,c,d,e,f)
#endif
#define my_munmap(a,b) munmap((a),(b))
#else
/* not a complete set of mmap() flags, but only those that necessary */
#define PROT_READ 1
#define PROT_WRITE 2
#define MAP_NORESERVE 0
#define MAP_SHARED 0x0001
#define MAP_PRIVATE 0x0002
#define MAP_NOSYNC 0x0800
#define MAP_FAILED ((void *)-1)
#define MS_SYNC 0x0000
#define HAVE_MMAP
void *my_mmap(void *, size_t, int, int, int, my_off_t);
int my_munmap(void *, size_t);
#endif
#ifdef _WIN32
extern FILE* my_win_popen(const char*, const char*);
extern int my_win_pclose(FILE*);
#define my_popen(A,B) my_win_popen(A,B)
#define my_pclose(A) my_win_pclose(A)
#else
#define my_popen(A,B) popen(A,B)
#define my_pclose(A) pclose(A)
#endif
/* my_getpagesize */
int my_getpagesize(void);
int my_msync(int, void *, size_t, int);
#define MY_UUID_SIZE 16
#define MY_UUID_BARE_STRING_LENGTH (8+4+4+4+12)
#define MY_UUID_SEPARATORS 4
#define MY_UUID_STRING_LENGTH (MY_UUID_BARE_STRING_LENGTH + MY_UUID_SEPARATORS)
void my_uuid_init(ulong seed1, ulong seed2);
void my_uuid(uchar *guid);
void my_uuid_end(void);
static inline void my_uuid2str(const uchar *guid, char *s, int with_separators)
{
int i;
int mask= with_separators ? ((1 << 3) | (1 << 5) | (1 << 7) | (1 << 9)) : 0;
for (i=0; i < MY_UUID_SIZE; i++, mask >>= 1)
{
*s++= _dig_vec_lower[guid[i] >>4];
*s++= _dig_vec_lower[guid[i] & 15];
if (mask & 1)
*s++= '-';
}
}
const char *my_dlerror(const char *dlpath);
/* System timezone handling*/
void my_tzset();
void my_tzname(char *sys_timezone, size_t size);
struct my_tz
{
long seconds_offset;
char abbreviation[64];
};
void my_tzinfo(time_t t, struct my_tz*);
/* character sets */
extern void my_charset_loader_init_mysys(MY_CHARSET_LOADER *loader);
extern uint get_charset_number(const char *cs_name, uint cs_flags, myf flags);
extern uint get_collation_number(const char *name,myf flags);
extern const char *get_charset_name(uint cs_number);
extern CHARSET_INFO *get_charset(uint cs_number, myf flags);
extern CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags);
extern CHARSET_INFO *my_collation_get_by_name(MY_CHARSET_LOADER *loader,
const char *name, myf flags);
extern CHARSET_INFO *get_charset_by_csname(const char *cs_name,
uint cs_flags, myf my_flags);
extern CHARSET_INFO *my_charset_get_by_name(MY_CHARSET_LOADER *loader,
const char *name,
uint cs_flags, myf my_flags);
extern my_bool resolve_charset(const char *cs_name,
CHARSET_INFO *default_cs,
CHARSET_INFO **cs,
myf flags);
extern my_bool resolve_collation(const char *cl_name,
CHARSET_INFO *default_cl,
CHARSET_INFO **cl,
myf my_flags);
extern void free_charsets(void);
extern char *get_charsets_dir(char *buf);
static inline my_bool my_charset_same(CHARSET_INFO *cs1, CHARSET_INFO *cs2)
{
return (cs1->cs_name.str == cs2->cs_name.str);
}
extern my_bool init_compiled_charsets(myf flags);
extern int add_compiled_collation(struct charset_info_st *cs);
extern void add_compiled_extra_collation(struct charset_info_st *cs);
extern size_t escape_string_for_mysql(CHARSET_INFO *charset_info,
char *to, size_t to_length,
const char *from, size_t length,
my_bool *overflow);
extern char *my_get_tty_password(const char *opt_message);
#ifdef _WIN32
#define BACKSLASH_MBTAIL
/* File system character set */
extern CHARSET_INFO *fs_character_set(void);
extern int my_set_console_cp(const char *name);
#else
#define my_set_console_cp(A) do {} while (0)
#endif
extern const char *my_default_csname(void);
extern size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
char *to, size_t to_length,
const char *from, size_t length,
my_bool *overflow);
extern void thd_increment_bytes_sent(void *thd, size_t length);
extern void thd_increment_bytes_received(void *thd, size_t length);
extern void thd_increment_net_big_packet_count(void *thd, size_t length);
#include
#ifdef HAVE_PSI_INTERFACE
extern MYSQL_PLUGIN_IMPORT struct PSI_bootstrap *PSI_hook;
extern void set_psi_server(PSI *psi);
void my_init_mysys_psi_keys(void);
#endif
struct st_mysql_file;
extern struct st_mysql_file *mysql_stdin;
C_MODE_END
#ifdef __cplusplus
class Charset_loader_mysys: public MY_CHARSET_LOADER
{
public:
Charset_loader_mysys()
{
my_charset_loader_init_mysys(this);
}
/**
Get a CHARSET_INFO by a character set name.
@param name Collation name
@param cs_flags e.g. MY_CS_PRIMARY, MY_CS_BINARY
@param my_flags mysys flags (MY_WME, MY_UTF8_IS_UTF8MB3)
@return
@retval NULL on error (e.g. not found)
@retval A CHARSET_INFO pointter on success
*/
CHARSET_INFO *get_charset(const char *cs_name, uint cs_flags, myf my_flags)
{
error[0]= '\0'; // Need to clear in case of the second call
return my_charset_get_by_name(this, cs_name, cs_flags, my_flags);
}
/**
Get a CHARSET_INFO by an exact collation by name.
@param name Collation name
@param my_flags e.g. the utf8 translation flag
@return
@retval NULL on error (e.g. not found)
@retval A CHARSET_INFO pointter on success
*/
CHARSET_INFO *get_exact_collation(const char *name, myf my_flags)
{
error[0]= '\0'; // Need to clear in case of the second call
return my_collation_get_by_name(this, name, my_flags);
}
/**
Get a CHARSET_INFO by a context collation by name.
The returned pointer must be further resolved to a character set.
@param name Collation name
@param utf8_flag The utf8 translation flag
@return
@retval NULL on error (e.g. not found)
@retval A CHARSET_INFO pointter on success
*/
CHARSET_INFO *get_context_collation(const char *name, myf my_flags)
{
return get_exact_collation_by_context_name(&my_charset_utf8mb4_general_ci,
name, my_flags);
}
/**
Get an exact CHARSET_INFO by a contextually typed collation name.
@param name Collation name
@param utf8_flag The utf8 translation flag
@return
@retval NULL on error (e.g. not found)
@retval A CHARSET_INFO pointer on success
*/
CHARSET_INFO *get_exact_collation_by_context_name(CHARSET_INFO *cs,
const char *name,
myf my_flags)
{
char tmp[MY_CS_COLLATION_NAME_SIZE];
my_snprintf(tmp, sizeof(tmp), "%s_%s", cs->cs_name.str, name);
return get_exact_collation(tmp, my_flags);
}
/*
Find a collation with binary comparison rules
*/
CHARSET_INFO *get_bin_collation(CHARSET_INFO *cs, myf my_flags)
{
/*
We don't need to handle old_mode=UTF8_IS_UTF8MB3 here,
This method assumes that "cs" points to a real character set name.
It can be either "utf8mb3" or "utf8mb4". It cannot be "utf8".
No thd->get_utf8_flag() flag passed to get_charset_by_csname().
*/
DBUG_ASSERT(cs->cs_name.length !=4 || memcmp(cs->cs_name.str, "utf8", 4));
/*
CREATE TABLE t1 (a CHAR(10) BINARY)
CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;
Nothing to do, we have the binary collation already.
*/
if (cs->state & MY_CS_BINSORT)
return cs;
// CREATE TABLE t1 (a CHAR(10) BINARY) CHARACTER SET utf8mb4;/
error[0]= '\0'; // Need in case of the second execution
return get_charset(cs->cs_name.str, MY_CS_BINSORT, my_flags);
}
/*
Find the default collation in the given character set
*/
CHARSET_INFO *get_default_collation(CHARSET_INFO *cs, myf my_flags)
{
// See comments in find_bin_collation_or_error()
DBUG_ASSERT(cs->cs_name.length !=4 || memcmp(cs->cs_name.str, "utf8", 4));
/*
CREATE TABLE t1 (a CHAR(10) COLLATE DEFAULT) CHARACTER SET utf8mb4;
Nothing to do, we have the default collation already.
*/
if (cs->state & MY_CS_PRIMARY)
return cs;
/*
CREATE TABLE t1 (a CHAR(10) COLLATE DEFAULT)
CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;
Don't need to handle old_mode=UTF8_IS_UTF8MB3 here.
See comments in find_bin_collation_or_error.
*/
cs= get_charset(cs->cs_name.str, MY_CS_PRIMARY, my_flags);
DBUG_ASSERT(cs);
return cs;
}
};
#endif /*__cplusplus */
#endif /* _my_sys_h */
PK ! Zoi sslopt-longopts.hnu [ #ifndef SSLOPT_LONGOPTS_INCLUDED
#define SSLOPT_LONGOPTS_INCLUDED
/*
Copyright (c) 2000, 2010, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
{"ssl", 0,
"Enable SSL for connection (automatically enabled with other flags).",
&opt_use_ssl, &opt_use_ssl, 0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
{"ssl-ca", OPT_SSL_CA,
"CA file in PEM format (check OpenSSL docs, implies --ssl).",
&opt_ssl_ca, &opt_ssl_ca, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"ssl-capath", OPT_SSL_CAPATH,
"CA directory (check OpenSSL docs, implies --ssl).",
&opt_ssl_capath, &opt_ssl_capath, 0, GET_STR, REQUIRED_ARG,
0, 0, 0, 0, 0, 0},
{"ssl-cert", OPT_SSL_CERT, "X509 cert in PEM format (implies --ssl).",
&opt_ssl_cert, &opt_ssl_cert, 0, GET_STR, REQUIRED_ARG,
0, 0, 0, 0, 0, 0},
{"ssl-cipher", OPT_SSL_CIPHER, "SSL cipher to use (implies --ssl).",
&opt_ssl_cipher, &opt_ssl_cipher, 0, GET_STR, REQUIRED_ARG,
0, 0, 0, 0, 0, 0},
{"ssl-key", OPT_SSL_KEY, "X509 key in PEM format (implies --ssl).",
&opt_ssl_key, &opt_ssl_key, 0, GET_STR, REQUIRED_ARG,
0, 0, 0, 0, 0, 0},
{"ssl-crl", OPT_SSL_CRL, "Certificate revocation list (implies --ssl).",
&opt_ssl_crl, &opt_ssl_crl, 0, GET_STR, REQUIRED_ARG,
0, 0, 0, 0, 0, 0},
{"ssl-crlpath", OPT_SSL_CRLPATH,
"Certificate revocation list path (implies --ssl).",
&opt_ssl_crlpath, &opt_ssl_crlpath, 0, GET_STR, REQUIRED_ARG,
0, 0, 0, 0, 0, 0},
{"tls-version", OPT_TLS_VERSION,
"TLS protocol version for secure connection.",
&opt_tls_version, &opt_tls_version, 0, GET_STR, REQUIRED_ARG,
0, 0, 0, 0, 0, 0},
#ifdef MYSQL_CLIENT
{"ssl-fp", OPT_SSL_FP, "Server certificate fingerprint (implies --ssl).",
&opt_ssl_fp, &opt_ssl_fp, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"ssl-fplist", OPT_SSL_FPLIST, "File with accepted server certificate "
"fingerprints, one per line (implies --ssl).",
&opt_ssl_fplist, &opt_ssl_fplist, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"ssl-verify-server-cert", 0,
"Verify server's certificate to prevent man-in-the-middle attacks",
&opt_ssl_verify_server_cert, &opt_ssl_verify_server_cert,
0, GET_BOOL, OPT_ARG, 2, 0, 0, 0, 0, 0},
#endif
#endif /* HAVE_OPENSSL */
#endif /* SSLOPT_LONGOPTS_INCLUDED */
PK ! b杇a a
sslopt-case.hnu [ #ifndef SSLOPT_CASE_INCLUDED
#define SSLOPT_CASE_INCLUDED
/* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
case OPT_SSL_KEY:
case OPT_SSL_CERT:
case OPT_SSL_CA:
case OPT_SSL_CAPATH:
case OPT_SSL_CIPHER:
case OPT_SSL_CRL:
case OPT_SSL_CRLPATH:
case OPT_TLS_VERSION:
#ifdef MYSQL_CLIENT
case OPT_SSL_FP:
case OPT_SSL_FPLIST:
#endif
/*
Enable use of SSL if we are using any ssl option
One can disable SSL later by using --skip-ssl or --ssl=0
*/
opt_use_ssl= 1;
#if defined (HAVE_WOLFSSL)
#if defined(MYSQL_SERVER)
/* CRL does not work with WolfSSL (server) */
opt_ssl_crl= NULL;
#endif
#if !defined(_WIN32) || !defined(LIBMARIADB)
/* CRL_PATH does not work with WolfSSL (server) and GnuTLS (client) */
opt_ssl_crlpath= NULL;
#endif
#endif
break;
#endif
#endif /* SSLOPT_CASE_INCLUDED */
PK ! E _ _ m_ctype.hnu [ /* Copyright (c) 2000, 2013, Oracle and/or its affiliates.
Copyright (c) 2009, 2020, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/*
A better implementation of the UNIX ctype(3) library.
*/
#ifndef _m_ctype_h
#define _m_ctype_h
#include
#include
enum loglevel {
ERROR_LEVEL= 0,
WARNING_LEVEL= 1,
INFORMATION_LEVEL= 2
};
#ifdef __cplusplus
extern "C" {
#endif
#define MY_CS_CHARACTER_SET_NAME_SIZE 32
#define MY_CS_COLLATION_NAME_SIZE 64
#define MY_CS_CTYPE_TABLE_SIZE 257
#define MY_CS_TO_LOWER_TABLE_SIZE 256
#define MY_CS_TO_UPPER_TABLE_SIZE 256
#define MY_CS_SORT_ORDER_TABLE_SIZE 256
#define MY_CS_TO_UNI_TABLE_SIZE 256
#define CHARSET_DIR "charsets/"
#define my_wc_t ulong
#define MY_CS_REPLACEMENT_CHARACTER 0xFFFD
/**
Maximum character length of a string produced by wc_to_printable().
Note, wc_to_printable() is currently limited to BMP.
One non-printable or non-convertable character can produce a string
with at most 5 characters: \hhhh.
If we ever modify wc_to_printable() to support supplementary characters,
e.g. \+hhhhhh, this constant should be changed to 8.
Note, maximum octet length of a wc_to_printable() result can be calculated
as: (MY_CS_PRINTABLE_CHAR_LENGTH*cs->mbminlen).
*/
#define MY_CS_PRINTABLE_CHAR_LENGTH 5
/*
On i386 we store Unicode->CS conversion tables for
some character sets using Big-endian order,
to copy two bytes at once.
This gives some performance improvement.
*/
#ifdef __i386__
#define MB2(x) (((x) >> 8) + (((x) & 0xFF) << 8))
#define MY_PUT_MB2(s, code) { *((uint16*)(s))= (code); }
#else
#define MB2(x) (x)
#define MY_PUT_MB2(s, code) { (s)[0]= code >> 8; (s)[1]= code & 0xFF; }
#endif
typedef const struct my_charset_handler_st MY_CHARSET_HANDLER;
typedef const struct my_collation_handler_st MY_COLLATION_HANDLER;
typedef const struct casefold_info_st MY_CASEFOLD_INFO;
typedef const struct uni_ctype_st MY_UNI_CTYPE;
typedef const struct my_uni_idx_st MY_UNI_IDX;
typedef uint16 decimal_digits_t;
typedef struct casefold_info_char_t
{
uint32 toupper;
uint32 tolower;
} MY_CASEFOLD_CHARACTER;
struct casefold_info_st
{
my_wc_t maxchar;
const MY_CASEFOLD_CHARACTER * const *page;
const uint16 * const *simple_weight; /* For general_ci-alike collations */
};
#define MY_UCA_MAX_CONTRACTION 6
/*
The DUCET tables in ctype-uca.c are dumped with a limit of 8 weights
per character. cs->strxfrm_multiply is set to 8 for all UCA based collations.
In language-specific UCA collations (with tailorings) we also do not allow
a single character to have more than 8 weights to stay with the same
strxfrm_multiply limit. Note, contractions are allowed to have twice longer
weight strings (up to 16 weights). As a contraction consists of at
least 2 characters, this makes sure that strxfrm_multiply ratio of 8
is respected.
*/
#define MY_UCA_MAX_WEIGHT_SIZE (8+1) /* Including 0 terminator */
#define MY_UCA_CONTRACTION_MAX_WEIGHT_SIZE (2*8+1) /* Including 0 terminator */
#define MY_UCA_WEIGHT_LEVELS 3
typedef struct my_contraction_t
{
my_wc_t ch[MY_UCA_MAX_CONTRACTION]; /* Character sequence */
uint16 weight[MY_UCA_CONTRACTION_MAX_WEIGHT_SIZE];/* Its weight string, 0-terminated */
my_bool with_context;
} MY_CONTRACTION;
typedef struct my_contraction_list_t
{
size_t nitems; /* Number of items in the list */
MY_CONTRACTION *item; /* List of contractions */
char *flags; /* Character flags, e.g. "is contraction head") */
} MY_CONTRACTIONS;
my_bool my_uca_can_be_contraction_head(const MY_CONTRACTIONS *c, my_wc_t wc);
my_bool my_uca_can_be_contraction_tail(const MY_CONTRACTIONS *c, my_wc_t wc);
const uint16 *my_uca_contraction2_weight(const MY_CONTRACTIONS *c,
my_wc_t wc1, my_wc_t wc2);
typedef struct my_uca_weight2_t
{
uint16 weight[2];
} MY_UCA_WEIGHT2;
/*
In DUCET as of Unicode-14.0.0:
- All characters in the range U+0000..U+007F (i.e. using one byte in utf8)
have not more than two weights on all weight levels.
- All characters in the range U+0080..U+07FF (i.e. using two bytes in utf8)
have not more than four weights on all weight levels.
Therefore the limit of 4 weights should cover all byte pairs
(i.e. two ASCII characters or one 2-byte character)
that are a subject for the "process 2 bytes at a time" optimization.
If some collation reorders any character from the mentioned ranges
in the way that it produces more weights, such character will not
be optimized, but will be correctly processed the slower mb_wc-based
method (1 character at a time).
*/
#define MY_UCA_2BYTES_MAX_WEIGHT_SIZE (4+1) /* Including 0 terminator */
typedef struct my_uca_2bytes_item_t
{
uint16 weight[MY_UCA_2BYTES_MAX_WEIGHT_SIZE];
} MY_UCA_2BYTES_ITEM;
typedef struct my_uca_level_booster_t
{
/*
A helper array to process 2 bytes at a time during string comparison.
It maps all 2-bytes sequences that make:
- two ASCII characters or
- one 2-byte character
to their weights. The weight length is limited to
MY_UCA_2BYTES_MAX_WEIGHT_SIZE-1 weights.
This array is used in the main loop optimization.
*/
MY_UCA_2BYTES_ITEM weight_strings_2bytes[0x10000];
/*
A helper array to process 2bytes at a time during string comparison,
with an even more efficient way than the above one.
The weight size is limited to 2 weights, so it's used for the cases
when 2 input bytes produce 1 or 2 weights.
This limit makes the code using this array even simpler and faster.
This array is used for prefix optimization.
*/
MY_UCA_WEIGHT2 weight_strings_2bytes_to_1_or_2_weights[0x10000];
} MY_UCA_LEVEL_BOOSTER;
typedef struct my_uca_contraction_hash_t
{
size_t nitems_alloced;
MY_CONTRACTION *item;
} MY_UCA_CONTRACTION_HASH;
/* Collation weights on a single level (e.g. primary, secondary, tertiary) */
typedef struct my_uca_level_info_st
{
my_wc_t maxchar;
uchar *lengths;
uint16 **weights;
MY_CONTRACTIONS contractions;
uint levelno;
MY_UCA_CONTRACTION_HASH contraction_hash;
MY_UCA_LEVEL_BOOSTER *booster;
} MY_UCA_WEIGHT_LEVEL;
typedef struct uca_info_st
{
MY_UCA_WEIGHT_LEVEL level[MY_UCA_WEIGHT_LEVELS];
/* Logical positions */
my_wc_t first_non_ignorable;
my_wc_t last_non_ignorable;
my_wc_t first_primary_ignorable;
my_wc_t last_primary_ignorable;
my_wc_t first_secondary_ignorable;
my_wc_t last_secondary_ignorable;
my_wc_t first_tertiary_ignorable;
my_wc_t last_tertiary_ignorable;
my_wc_t first_trailing;
my_wc_t last_trailing;
my_wc_t first_variable;
my_wc_t last_variable;
/* Unicode version */
uint version;
} MY_UCA_INFO;
extern MY_UCA_INFO my_uca_v400;
struct uni_ctype_st
{
uchar pctype;
const uchar *ctype;
};
extern MY_UNI_CTYPE my_uni_ctype[256];
/* wm_wc and wc_mb return codes */
#define MY_CS_ILSEQ 0 /* Wrong by sequence: wb_wc */
#define MY_CS_ILUNI 0 /* Cannot encode Unicode to charset: wc_mb */
#define MY_CS_TOOSMALL -101 /* Need at least one byte: wc_mb and mb_wc */
#define MY_CS_TOOSMALL2 -102 /* Need at least two bytes: wc_mb and mb_wc */
#define MY_CS_TOOSMALL3 -103 /* Need at least three bytes: wc_mb and mb_wc */
/* These following three are currently not really used */
#define MY_CS_TOOSMALL4 -104 /* Need at least 4 bytes: wc_mb and mb_wc */
#define MY_CS_TOOSMALL5 -105 /* Need at least 5 bytes: wc_mb and mb_wc */
#define MY_CS_TOOSMALL6 -106 /* Need at least 6 bytes: wc_mb and mb_wc */
/* A helper macros for "need at least n bytes" */
#define MY_CS_TOOSMALLN(n) (-100-(n))
#define MY_CS_MBMAXLEN 6 /* Maximum supported mbmaxlen */
#define MY_CS_IS_TOOSMALL(rc) ((rc) >= MY_CS_TOOSMALL6 && (rc) <= MY_CS_TOOSMALL)
#define MY_SEQ_INTTAIL 1
#define MY_SEQ_SPACES 2
#define MY_SEQ_NONSPACES 3 /* Skip non-space characters, including bad bytes */
/* My charsets_list flags */
#define MY_CS_COMPILED 1 /* compiled-in sets */
#define MY_CS_CONFIG 2 /* sets that have a *.conf file */
#define MY_CS_INDEX 4 /* sets listed in the Index file */
#define MY_CS_LOADED 8 /* sets that are currently loaded */
#define MY_CS_BINSORT 16 /* if binary sort order */
#define MY_CS_PRIMARY 32 /* if primary collation */
#define MY_CS_STRNXFRM 64 /* if strnxfrm is used for sort */
#define MY_CS_UNICODE 128 /* is a charset is BMP Unicode */
#define MY_CS_READY 256 /* if a charset is initialized */
#define MY_CS_AVAILABLE 512 /* If either compiled-in or loaded*/
#define MY_CS_CSSORT 1024 /* if case sensitive sort order */
#define MY_CS_HIDDEN 2048 /* don't display in SHOW */
#define MY_CS_PUREASCII 4096 /* if a charset is pure ascii */
#define MY_CS_NONASCII 8192 /* if not ASCII-compatible */
#define MY_CS_UNICODE_SUPPLEMENT 16384 /* Non-BMP Unicode characters */
#define MY_CS_LOWER_SORT 32768 /* If use lower case as weight */
#define MY_CS_STRNXFRM_BAD_NWEIGHTS 0x10000 /* strnxfrm ignores "nweights" */
#define MY_CS_NOPAD 0x20000 /* if does not ignore trailing spaces */
#define MY_CS_NON1TO1 0x40000 /* Has a complex mapping from characters
to weights, e.g. contractions, expansions,
ignorable characters */
#define MY_CS_UPPER_EQUAL_AS_EQUAL 0x80000 /* (UPPER(x)=UPPER(y)) <=> (x=y)*/
#define MY_CHARSET_UNDEFINED 0
/* Character repertoire flags */
typedef enum enum_repertoire_t
{
MY_REPERTOIRE_NONE= 0,
MY_REPERTOIRE_ASCII= 1, /* Pure ASCII U+0000..U+007F */
MY_REPERTOIRE_EXTENDED= 2, /* Extended characters: U+0080..U+FFFF */
MY_REPERTOIRE_UNICODE30= 3 /* ASCII | EXTENDED: U+0000..U+FFFF */
} my_repertoire_t;
/* ID compatibility */
typedef enum enum_collation_id_type
{
MY_COLLATION_ID_TYPE_PRECISE= 0,
MY_COLLATION_ID_TYPE_COMPAT_100800= 1
} my_collation_id_type_t;
/* Collation name display modes */
typedef enum enum_collation_name_mode
{
MY_COLLATION_NAME_MODE_FULL= 0,
MY_COLLATION_NAME_MODE_CONTEXT= 1
} my_collation_name_mode_t;
/* Level flags */
#define MY_CS_LEVEL_BIT_PRIMARY 0x00
#define MY_CS_LEVEL_BIT_SECONDARY 0x01
#define MY_CS_LEVEL_BIT_TERTIARY 0x02
#define MY_CS_LEVEL_BIT_QUATERNARY 0x03
#define MY_CS_COLL_LEVELS_S1 (1<m_source_end_pos is set to the position where reading stopped.
If a bad byte sequence is found, the function returns immediately and
status->m_well_formed_error_pos is set to the position where a bad byte
sequence was found.
status->m_well_formed_error_pos is set to NULL if no bad bytes were found.
If status->m_well_formed_error_pos is NULL after the call, that means:
- either the function reached the end of the string,
- or all "nchars" characters were read.
The caller can check status->m_source_end_pos to detect which of these two
happened.
*/
size_t (*well_formed_char_length)(CHARSET_INFO *cs,
const char *str, const char *end,
size_t nchars,
MY_STRCOPY_STATUS *status);
/*
copy_fix() - copy a string, replace bad bytes to '?'.
Not more than "nchars" characters are copied.
status->m_source_end_pos is set to a position in the range
between "src" and "src + src_length", where reading stopped.
status->m_well_formed_error_pos is set to NULL if the string
in the range "src" and "status->m_source_end_pos" was well formed,
or is set to a position between "src" and "src + src_length" where
the leftmost bad byte sequence was found.
*/
size_t (*copy_fix)(CHARSET_INFO *,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status);
/**
Write a character to the target string, using its native code.
For Unicode character sets (utf8, ucs2, utf16, utf16le, utf32, filename)
native codes are equivalent to Unicode code points.
For 8bit character sets the native code is just the byte value.
For Asian characters sets:
- MB1 native code is just the byte value (e.g. on the ASCII range)
- MB2 native code is ((b0 << 8) + b1).
- MB3 native code is ((b0 <<16) + (b1 << 8) + b2)
Note, CHARSET_INFO::min_sort_char and CHARSET_INFO::max_sort_char
are defined in native notation and should be written using
my_ci_native_to_mb() rather than my_ci_wc_mb().
*/
my_charset_conv_wc_mb native_to_mb;
my_charset_conv_wc_mb wc_to_printable;
uint (*caseup_multiply)(CHARSET_INFO *cs);
uint (*casedn_multiply)(CHARSET_INFO *cs);
};
extern MY_CHARSET_HANDLER my_charset_8bit_handler;
extern MY_CHARSET_HANDLER my_charset_ucs2_handler;
extern MY_CHARSET_HANDLER my_charset_utf8mb3_handler;
/*
We define this CHARSET_INFO_DEFINED here to prevent a repeat of the
typedef in hash.c, which will cause a compiler error.
*/
#define CHARSET_INFO_DEFINED
/* See strings/CHARSET_INFO.txt about information on this structure */
struct charset_info_st
{
uint number;
uint primary_number;
uint binary_number;
uint state;
LEX_CSTRING cs_name;
LEX_CSTRING coll_name;
const char *comment;
const char *tailoring;
const uchar *m_ctype;
const uchar *to_lower;
const uchar *to_upper;
const uchar *sort_order;
MY_UCA_INFO *uca;
const uint16 *tab_to_uni;
MY_UNI_IDX *tab_from_uni;
MY_CASEFOLD_INFO *casefold;
const uchar *state_map;
const uchar *ident_map;
uint strxfrm_multiply;
uint mbminlen;
uint mbmaxlen;
/*
min_sort_char and max_sort_char represent the minimum
and the maximum character in the collation respectively.
For Unicode collations, these numbers are Unicode code points.
For non-Unicode collations these numbers are native character codes.
For example, in all 8bit collations these numbers are
in the range 0x00..0xFF.
min_sort_char and max_sort_char normally should not be used directly.
They are used internally in the following virtual functions:
- MY_COLLATION_HANDLER::like_range()
- MY_COLLATION_HANDLER::min_str()
- MY_COLLATION_HANDLER::max_str()
*/
my_wc_t min_sort_char;
my_wc_t max_sort_char;
uchar pad_char;
my_bool escape_with_backslash_is_dangerous;
uchar levels_for_order;
MY_CHARSET_HANDLER *cset;
MY_COLLATION_HANDLER *coll;
#ifdef __cplusplus
/* Character set routines */
bool use_mb() const
{
return mbmaxlen > 1;
}
size_t numchars(const char *b, const char *e) const
{
return (cset->numchars)(this, b, e);
}
size_t charpos(const char *b, const char *e, size_t pos) const
{
return (cset->charpos)(this, b, e, pos);
}
size_t charpos(const uchar *b, const uchar *e, size_t pos) const
{
return (cset->charpos)(this, (const char *) b, (const char*) e, pos);
}
size_t lengthsp(const char *str, size_t length) const
{
return (cset->lengthsp)(this, str, length);
}
size_t numcells(const char *b, const char *e) const
{
return (cset->numcells)(this, b, e);
}
size_t caseup(const char *src, size_t srclen,
char *dst, size_t dstlen) const
{
return (cset->caseup)(this, src, srclen, dst, dstlen);
}
size_t casedn(const char *src, size_t srclen,
char *dst, size_t dstlen) const
{
return (cset->casedn)(this, src, srclen, dst, dstlen);
}
uint caseup_multiply() const
{
return (cset->caseup_multiply)(this);
}
uint casedn_multiply() const
{
return (cset->casedn_multiply)(this);
}
size_t long10_to_str(char *dst, size_t dstlen,
int radix, long int val) const
{
return (cset->long10_to_str)(this, dst, dstlen, radix, val);
}
size_t (longlong10_to_str)(char *dst, size_t dstlen,
int radix, longlong val) const
{
return (cset->longlong10_to_str)(this, dst, dstlen, radix, val);
}
int mb_wc(my_wc_t *wc, const uchar *b, const uchar *e) const
{
return (cset->mb_wc)(this, wc, b, e);
}
int wc_mb(my_wc_t wc, uchar *s, uchar *e) const
{
return (cset->wc_mb)(this, wc, s, e);
}
int native_to_mb(my_wc_t wc, uchar *s, uchar *e) const
{
return (cset->native_to_mb)(this, wc, s, e);
}
int wc_to_printable(my_wc_t wc, uchar *s, uchar *e) const
{
return (cset->wc_to_printable)(this, wc, s, e);
}
int ctype(int *to, const uchar *s, const uchar *e) const
{
return (cset->ctype)(this, to, s, e);
}
void fill(char *to, size_t len, int ch) const
{
(cset->fill)(this, to, len, ch);
}
long strntol(const char *str, size_t length,
int base, char **endptr, int *error) const
{
return (cset->strntol)(this, str, length, base, endptr, error);
}
ulong strntoul(const char *str, size_t length,
int base, char **endptr, int *error) const
{
return (cset->strntoul)(this, str, length, base, endptr, error);
}
longlong strntoll(const char *str, size_t length,
int base, char **endptr, int *error) const
{
return (cset->strntoll)(this, str, length, base, endptr, error);
}
ulonglong strntoull(const char *str, size_t length,
int base, char **endptr, int *error) const
{
return (cset->strntoull)(this, str, length, base, endptr, error);
}
double strntod(char *str, size_t length,
char **endptr, int *error) const
{
return (cset->strntod)(this, str, length, endptr, error);
}
longlong strtoll10(const char *str, char **endptr, int *error) const
{
return (cset->strtoll10)(this, str, endptr, error);
}
ulonglong strntoull10rnd(const char *str, size_t length, int unsigned_fl,
char **endptr, int *error) const
{
return (cset->strntoull10rnd)(this, str, length, unsigned_fl, endptr, error);
}
size_t scan(const char *b, const char *e, int seq) const
{
return (cset->scan)(this, b, e, seq);
}
int charlen(const uchar *str, const uchar *end) const
{
return (cset->charlen)(this, str, end);
}
int charlen(const char *str, const char *end) const
{
return (cset->charlen)(this, (const uchar *) str, (const uchar *) end);
}
uint charlen_fix(const uchar *str, const uchar *end) const
{
int char_length= (cset->charlen)(this, str, end);
DBUG_ASSERT(str < end);
return char_length > 0 ? (uint) char_length : (uint) 1U;
}
uint charlen_fix(const char *str, const char *end) const
{
return charlen_fix((const uchar *) str, (const uchar *) end);
}
size_t well_formed_char_length(const char *str, const char *end,
size_t nchars,
MY_STRCOPY_STATUS *status) const
{
return (cset->well_formed_char_length)(this, str, end, nchars, status);
}
size_t copy_fix(char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status) const
{
return (cset->copy_fix)(this, dst, dst_length, src, src_length, nchars,
status);
}
/* Collation routines */
uint default_flag() const
{
return state & MY_CS_PRIMARY;
}
uint binsort_flag() const
{
return state & MY_CS_BINSORT;
}
uint compiled_flag() const
{
return state & MY_CS_COMPILED;
}
int strnncoll(const uchar *a, size_t alen,
const uchar *b, size_t blen, my_bool b_is_prefix= FALSE) const
{
return (coll->strnncoll)(this, a, alen, b, blen, b_is_prefix);
}
int strnncoll(const char *a, size_t alen,
const char *b, size_t blen, my_bool b_is_prefix= FALSE) const
{
return (coll->strnncoll)(this,
(const uchar *) a, alen,
(const uchar *) b, blen, b_is_prefix);
}
int strnncollsp(const uchar *a, size_t alen,
const uchar *b, size_t blen) const
{
return (coll->strnncollsp)(this, a, alen, b, blen);
}
int strnncollsp(const char *a, size_t alen,
const char *b, size_t blen) const
{
return (coll->strnncollsp)(this, (uchar *) a, alen, (uchar *) b, blen);
}
int strnncollsp(const LEX_CSTRING &a, const LEX_CSTRING &b) const
{
return (coll->strnncollsp)(this, (uchar *) a.str, a.length,
(uchar *) b.str, b.length);
}
size_t strnxfrm(char *dst, size_t dstlen, uint nweights,
const char *src, size_t srclen, uint flags) const
{
return (coll->strnxfrm)(this,
(uchar *) dst, dstlen, nweights,
(const uchar *) src, srclen, flags);
}
size_t strnxfrm(uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags) const
{
return (coll->strnxfrm)(this,
dst, dstlen, nweights,
src, srclen, flags);
}
size_t strnxfrm(uchar *dst, size_t dstlen,
const uchar *src, size_t srclen) const
{
return (coll->strnxfrm)(this,
dst, dstlen, (uint) dstlen,
src, srclen, MY_STRXFRM_PAD_WITH_SPACE);
}
size_t strnxfrmlen(size_t length) const
{
return (coll->strnxfrmlen)(this, length);
}
my_bool like_range(const char *s, size_t s_length,
pchar w_prefix, pchar w_one, pchar w_many,
size_t res_length,
char *min_str, char *max_str,
size_t *min_len, size_t *max_len) const
{
return (coll->like_range)(this, s, s_length,
w_prefix, w_one, w_many,
res_length, min_str, max_str,
min_len, max_len);
}
int wildcmp(const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape,int w_one, int w_many) const
{
return (coll->wildcmp)(this, str, str_end, wildstr, wildend, escape, w_one, w_many);
}
uint instr(const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch) const
{
return (coll->instr)(this, b, b_length, s, s_length, match, nmatch);
}
void hash_sort(const uchar *key, size_t len, ulong *nr1, ulong *nr2) const
{
(coll->hash_sort)(this, key, len, nr1, nr2);
}
my_bool propagate(const uchar *str, size_t len) const
{
return (coll->propagate)(this, str, len);
}
size_t min_str(uchar *dst, size_t dstlen, size_t nchars) const
{
return (coll->min_str)(this, dst, dstlen, nchars);
}
size_t max_str(uchar *dst, size_t dstlen, size_t nchars) const
{
return (coll->max_str)(this, dst, dstlen, nchars);
}
uint get_id(my_collation_id_type_t type) const
{
return (coll->get_id)(this, type);
}
LEX_CSTRING get_collation_name(my_collation_name_mode_t mode) const
{
return (coll->get_collation_name)(this, mode);
}
/*
Check if two collations are equally defined. For details
see the definition of eq_collation() in my_collation_handler_st.
@return 0 Different
@return 1 Identical
*/
my_bool eq_collation(CHARSET_INFO *rhs) const
{
return this == rhs || (coll->eq_collation)(this, rhs);
}
#endif /* __cplusplus */
};
/* Character set routines */
static inline my_bool
my_ci_init_charset(struct charset_info_st *ci, MY_CHARSET_LOADER *loader)
{
if (!ci->cset->init)
return FALSE;
return (ci->cset->init)(ci, loader);
}
static inline my_bool
my_ci_use_mb(CHARSET_INFO *ci)
{
return ci->mbmaxlen > 1 ? TRUE : FALSE;
}
static inline size_t
my_ci_numchars(CHARSET_INFO *cs, const char *b, const char *e)
{
return (cs->cset->numchars)(cs, b, e);
}
static inline size_t
my_ci_charpos(CHARSET_INFO *cs, const char *b, const char *e, size_t pos)
{
return (cs->cset->charpos)(cs, b, e, pos);
}
static inline size_t
my_ci_lengthsp(CHARSET_INFO *cs, const char *str, size_t length)
{
return (cs->cset->lengthsp)(cs, str, length);
}
static inline size_t
my_ci_numcells(CHARSET_INFO *cs, const char *b, const char *e)
{
return (cs->cset->numcells)(cs, b, e);
}
static inline size_t
my_ci_caseup(CHARSET_INFO *ci,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
return (ci->cset->caseup)(ci, src, srclen, dst, dstlen);
}
static inline size_t
my_ci_casedn(CHARSET_INFO *ci,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
return (ci->cset->casedn)(ci, src, srclen, dst, dstlen);
}
static inline size_t
my_ci_long10_to_str(CHARSET_INFO *cs, char *dst, size_t dstlen,
int radix, long int val)
{
return (cs->cset->long10_to_str)(cs, dst, dstlen, radix, val);
}
static inline size_t
my_ci_longlong10_to_str(CHARSET_INFO *cs, char *dst, size_t dstlen,
int radix, longlong val)
{
return (cs->cset->longlong10_to_str)(cs, dst, dstlen, radix, val);
}
#define my_ci_mb_wc(s, pwc, b, e) ((s)->cset->mb_wc)(s, pwc, b, e)
#define my_ci_wc_mb(s, wc, b, e) ((s)->cset->wc_mb)(s, wc, b, e)
#define my_ci_native_to_mb(s, wc, b, e) ((s)->cset->native_to_mb)(s, wc, b, e)
#define my_ci_ctype(s, pctype, b, e) ((s)->cset->ctype)(s, pctype, b, e)
static inline void
my_ci_fill(CHARSET_INFO *cs, char *to, size_t len, int ch)
{
(cs->cset->fill)(cs, to, len, ch);
}
static inline long
my_ci_strntol(CHARSET_INFO *cs, const char *str, size_t length,
int base, char **endptr, int *error)
{
return (cs->cset->strntol)(cs, str, length, base, endptr, error);
}
static inline ulong
my_ci_strntoul(CHARSET_INFO *cs, const char *str, size_t length,
int base, char **endptr, int *error)
{
return (cs->cset->strntoul)(cs, str, length, base, endptr, error);
}
static inline longlong
my_ci_strntoll(CHARSET_INFO *cs, const char *str, size_t length,
int base, char **endptr, int *error)
{
return (cs->cset->strntoll)(cs, str, length, base, endptr, error);
}
static inline ulonglong
my_ci_strntoull(CHARSET_INFO *cs, const char *str, size_t length,
int base, char **endptr, int *error)
{
return (cs->cset->strntoull)(cs, str, length, base, endptr, error);
}
static inline double
my_ci_strntod(CHARSET_INFO *cs, char *str, size_t length,
char **endptr, int *error)
{
return (cs->cset->strntod)(cs, str, length, endptr, error);
}
static inline longlong
my_ci_strtoll10(CHARSET_INFO *cs, const char *str, char **endptr, int *error)
{
return (cs->cset->strtoll10)(cs, str, endptr, error);
}
static inline ulonglong
my_ci_strntoull10rnd(CHARSET_INFO *cs,
const char *str, size_t length, int unsigned_fl,
char **endptr, int *error)
{
return (cs->cset->strntoull10rnd)(cs, str, length, unsigned_fl, endptr, error);
}
static inline size_t
my_ci_scan(CHARSET_INFO *cs, const char *b, const char *e, int seq)
{
return (cs->cset->scan)(cs, b, e, seq);
}
/**
Return length of the leftmost character in a string.
@param cs - character set
@param str - the beginning of the string
@param end - the string end (the next byte after the string)
@return <=0 on errors (EOL, wrong byte sequence)
@return 1 on a single byte character
@return >1 on a multi-byte character
Note, inlike my_ismbchar(), 1 is returned for a single byte character.
*/
static inline int
my_ci_charlen(CHARSET_INFO *cs, const uchar *str, const uchar *end)
{
return (cs->cset->charlen)(cs, str, end);
}
static inline size_t
my_ci_well_formed_char_length(CHARSET_INFO *cs,
const char *str, const char *end,
size_t nchars,
MY_STRCOPY_STATUS *status)
{
return (cs->cset->well_formed_char_length)(cs, str, end, nchars, status);
}
static inline size_t
my_ci_copy_fix(CHARSET_INFO *cs,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
return (cs->cset->copy_fix)(cs, dst, dst_length, src, src_length, nchars,
status);
}
/* Collation routines */
static inline my_bool
my_ci_init_collation(struct charset_info_st *ci, MY_CHARSET_LOADER *loader)
{
if (!ci->coll->init)
return FALSE;
return (ci->coll->init)(ci, loader);
}
static inline int
my_ci_strnncoll(CHARSET_INFO *ci,
const uchar *a, size_t alen,
const uchar *b, size_t blen,
my_bool b_is_prefix)
{
return (ci->coll->strnncoll)(ci, a, alen, b, blen, b_is_prefix);
}
static inline int
my_ci_strnncollsp(CHARSET_INFO *ci,
const uchar *a, size_t alen,
const uchar *b, size_t blen)
{
return (ci->coll->strnncollsp)(ci, a, alen, b, blen);
}
static inline my_bool
my_ci_like_range(CHARSET_INFO *ci,
const char *s, size_t s_length,
pchar w_prefix, pchar w_one, pchar w_many,
size_t res_length,
char *min_str, char *max_str,
size_t *min_len, size_t *max_len)
{
return (ci->coll->like_range)(ci, s, s_length,
w_prefix, w_one, w_many,
res_length, min_str, max_str,
min_len, max_len);
}
static inline uint
my_ci_instr(CHARSET_INFO *ci,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch)
{
return (ci->coll->instr)(ci, b, b_length, s, s_length, match, nmatch);
}
static inline void
my_ci_hash_sort(CHARSET_INFO *ci,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
(ci->coll->hash_sort)(ci, key, len, nr1, nr2);
}
#define ILLEGAL_CHARSET_INFO_NUMBER (~0U)
extern MYSQL_PLUGIN_IMPORT struct charset_info_st my_charset_bin;
extern MYSQL_PLUGIN_IMPORT struct charset_info_st my_charset_latin1;
extern MYSQL_PLUGIN_IMPORT struct charset_info_st my_charset_latin1_nopad;
extern MYSQL_PLUGIN_IMPORT struct charset_info_st my_charset_filename;
extern MYSQL_PLUGIN_IMPORT struct charset_info_st my_charset_utf8mb3_general_ci;
extern struct charset_info_st my_charset_big5_bin;
extern struct charset_info_st my_charset_big5_chinese_ci;
extern struct charset_info_st my_charset_big5_nopad_bin;
extern struct charset_info_st my_charset_big5_chinese_nopad_ci;
extern struct charset_info_st my_charset_cp1250_czech_cs;
extern struct charset_info_st my_charset_cp932_bin;
extern struct charset_info_st my_charset_cp932_japanese_ci;
extern struct charset_info_st my_charset_cp932_nopad_bin;
extern struct charset_info_st my_charset_cp932_japanese_nopad_ci;
extern struct charset_info_st my_charset_eucjpms_bin;
extern struct charset_info_st my_charset_eucjpms_japanese_ci;
extern struct charset_info_st my_charset_eucjpms_nopad_bin;
extern struct charset_info_st my_charset_eucjpms_japanese_nopad_ci;
extern struct charset_info_st my_charset_euckr_bin;
extern struct charset_info_st my_charset_euckr_korean_ci;
extern struct charset_info_st my_charset_euckr_nopad_bin;
extern struct charset_info_st my_charset_euckr_korean_nopad_ci;
extern struct charset_info_st my_charset_gb2312_bin;
extern struct charset_info_st my_charset_gb2312_chinese_ci;
extern struct charset_info_st my_charset_gb2312_nopad_bin;
extern struct charset_info_st my_charset_gb2312_chinese_nopad_ci;
extern struct charset_info_st my_charset_gbk_bin;
extern struct charset_info_st my_charset_gbk_chinese_ci;
extern struct charset_info_st my_charset_gbk_nopad_bin;
extern struct charset_info_st my_charset_gbk_chinese_nopad_ci;
extern struct charset_info_st my_charset_latin1_bin;
extern struct charset_info_st my_charset_latin1_nopad_bin;
extern struct charset_info_st my_charset_latin1_german2_ci;
extern struct charset_info_st my_charset_latin2_czech_cs;
extern struct charset_info_st my_charset_sjis_bin;
extern struct charset_info_st my_charset_sjis_japanese_ci;
extern struct charset_info_st my_charset_sjis_nopad_bin;
extern struct charset_info_st my_charset_sjis_japanese_nopad_ci;
extern struct charset_info_st my_charset_tis620_bin;
extern struct charset_info_st my_charset_tis620_thai_ci;
extern struct charset_info_st my_charset_tis620_nopad_bin;
extern struct charset_info_st my_charset_tis620_thai_nopad_ci;
extern struct charset_info_st my_charset_ucs2_bin;
extern struct charset_info_st my_charset_ucs2_general_ci;
extern struct charset_info_st my_charset_ucs2_nopad_bin;
extern struct charset_info_st my_charset_ucs2_general_nopad_ci;
extern struct charset_info_st my_charset_ucs2_general_mysql500_ci;
extern struct charset_info_st my_charset_ucs2_unicode_ci;
extern struct charset_info_st my_charset_ucs2_unicode_nopad_ci;
extern struct charset_info_st my_charset_ucs2_general_mysql500_ci;
extern struct charset_info_st my_charset_ujis_bin;
extern struct charset_info_st my_charset_ujis_japanese_ci;
extern struct charset_info_st my_charset_ujis_nopad_bin;
extern struct charset_info_st my_charset_ujis_japanese_nopad_ci;
extern struct charset_info_st my_charset_utf16_bin;
extern struct charset_info_st my_charset_utf16_general_ci;
extern struct charset_info_st my_charset_utf16_unicode_ci;
extern struct charset_info_st my_charset_utf16_unicode_nopad_ci;
extern struct charset_info_st my_charset_utf16le_bin;
extern struct charset_info_st my_charset_utf16le_general_ci;
extern struct charset_info_st my_charset_utf16_general_nopad_ci;
extern struct charset_info_st my_charset_utf16_nopad_bin;
extern struct charset_info_st my_charset_utf16le_nopad_bin;
extern struct charset_info_st my_charset_utf16le_general_nopad_ci;
extern struct charset_info_st my_charset_utf32_bin;
extern struct charset_info_st my_charset_utf32_general_ci;
extern struct charset_info_st my_charset_utf32_unicode_ci;
extern struct charset_info_st my_charset_utf32_unicode_nopad_ci;
extern struct charset_info_st my_charset_utf32_nopad_bin;
extern struct charset_info_st my_charset_utf32_general_nopad_ci;
extern MYSQL_PLUGIN_IMPORT struct charset_info_st my_charset_utf8mb3_bin;
extern struct charset_info_st my_charset_utf8mb3_nopad_bin;
extern struct charset_info_st my_charset_utf8mb3_general_nopad_ci;
extern struct charset_info_st my_charset_utf8mb3_general_mysql500_ci;
extern struct charset_info_st my_charset_utf8mb3_unicode_ci;
extern struct charset_info_st my_charset_utf8mb3_unicode_nopad_ci;
extern MYSQL_PLUGIN_IMPORT struct charset_info_st my_charset_utf8mb4_bin;
extern struct charset_info_st my_charset_utf8mb4_general_ci;
extern struct charset_info_st my_charset_utf8mb4_nopad_bin;
extern struct charset_info_st my_charset_utf8mb4_general_nopad_ci;
extern struct charset_info_st my_charset_utf8mb4_unicode_ci;
extern struct charset_info_st my_charset_utf8mb4_unicode_nopad_ci;
/*
Contextually typed collations, e.g.:
CHAR(10) COLLATE DEFAULT
CHAR(10) BINARY
*/
extern struct charset_info_st my_collation_contextually_typed_default;
extern struct charset_info_st my_collation_contextually_typed_binary;
#define MY_UTF8MB3 "utf8mb3"
#define MY_UTF8MB4 "utf8mb4"
my_bool my_cs_have_contractions(CHARSET_INFO *cs);
my_bool my_cs_can_be_contraction_head(CHARSET_INFO *cs, my_wc_t wc);
my_bool my_cs_can_be_contraction_tail(CHARSET_INFO *cs, my_wc_t wc);
const uint16 *my_cs_contraction2_weight(CHARSET_INFO *cs, my_wc_t wc1,
my_wc_t wc2);
/* declarations for simple charsets */
extern size_t my_strnxfrm_simple(CHARSET_INFO *,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags);
size_t my_strnxfrmlen_simple(CHARSET_INFO *, size_t);
extern int my_strnncoll_simple(CHARSET_INFO *, const uchar *, size_t,
const uchar *, size_t, my_bool);
extern int my_strnncollsp_simple(CHARSET_INFO *, const uchar *, size_t,
const uchar *, size_t);
extern void my_hash_sort_simple(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2);
extern void my_hash_sort_simple_nopad(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2);
extern void my_hash_sort_bin(CHARSET_INFO *cs,
const uchar *key, size_t len, ulong *nr1,
ulong *nr2);
/**
Compare a string to an array of spaces, for PAD SPACE comparison.
The function iterates through the string and compares every byte to 0x20.
@param - the string
@param - its length
@return <0 - if a byte less than 0x20 was found in the string.
@return 0 - if all bytes in the string were 0x20, or if length was 0.
@return >0 - if a byte greater than 0x20 was found in the string.
*/
extern int my_strnncollsp_padspace_bin(const uchar *str, size_t length);
extern size_t my_lengthsp_8bit(CHARSET_INFO *cs, const char *ptr, size_t length);
extern uint my_instr_simple(CHARSET_INFO *,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch);
size_t my_copy_8bit(CHARSET_INFO *,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *);
size_t my_copy_fix_mb(CHARSET_INFO *cs,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *);
/* Functions for 8bit */
extern size_t my_caseup_str_8bit(CHARSET_INFO *, char *);
extern size_t my_casedn_str_8bit(CHARSET_INFO *, char *);
extern size_t my_caseup_8bit(CHARSET_INFO *,
const char *src, size_t srclen,
char *dst, size_t dstlen);
extern size_t my_casedn_8bit(CHARSET_INFO *,
const char *src, size_t srclen,
char *dst, size_t dstlen);
extern int my_strcasecmp_8bit(CHARSET_INFO * cs, const char *, const char *);
int my_mb_wc_8bit(CHARSET_INFO *cs,my_wc_t *wc, const uchar *s,const uchar *e);
int my_wc_mb_8bit(CHARSET_INFO *cs,my_wc_t wc, uchar *s, uchar *e);
int my_wc_mb_bin(CHARSET_INFO *cs,my_wc_t wc, uchar *s, uchar *e);
int my_mb_ctype_8bit(CHARSET_INFO *,int *, const uchar *,const uchar *);
int my_mb_ctype_mb(CHARSET_INFO *,int *, const uchar *,const uchar *);
size_t my_scan_8bit(CHARSET_INFO *cs, const char *b, const char *e, int sq);
size_t my_snprintf_8bit(CHARSET_INFO *, char *to, size_t n,
const char *fmt, ...)
ATTRIBUTE_FORMAT(printf, 4, 5);
long my_strntol_8bit(CHARSET_INFO *, const char *s, size_t l, int base,
char **e, int *err);
ulong my_strntoul_8bit(CHARSET_INFO *, const char *s, size_t l, int base,
char **e, int *err);
longlong my_strntoll_8bit(CHARSET_INFO *, const char *s, size_t l, int base,
char **e, int *err);
ulonglong my_strntoull_8bit(CHARSET_INFO *, const char *s, size_t l, int base,
char **e, int *err);
double my_strntod_8bit(CHARSET_INFO *, char *s, size_t l,char **e,
int *err);
size_t my_long10_to_str_8bit(CHARSET_INFO *, char *to, size_t l, int radix,
long int val);
size_t my_longlong10_to_str_8bit(CHARSET_INFO *, char *to, size_t l, int radix,
longlong val);
longlong my_strtoll10_8bit(CHARSET_INFO *cs,
const char *nptr, char **endptr, int *error);
longlong my_strtoll10_ucs2(CHARSET_INFO *cs,
const char *nptr, char **endptr, int *error);
ulonglong my_strntoull10rnd_8bit(CHARSET_INFO *cs,
const char *str, size_t length, int
unsigned_fl, char **endptr, int *error);
ulonglong my_strntoull10rnd_ucs2(CHARSET_INFO *cs,
const char *str, size_t length,
int unsigned_fl, char **endptr, int *error);
void my_fill_8bit(CHARSET_INFO *cs, char* to, size_t l, int fill);
/* For 8-bit character set */
my_bool my_like_range_simple(CHARSET_INFO *cs,
const char *ptr, size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length,
char *min_str, char *max_str,
size_t *min_length, size_t *max_length);
/* For ASCII-based multi-byte character sets with mbminlen=1 */
my_bool my_like_range_mb(CHARSET_INFO *cs,
const char *ptr, size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length,
char *min_str, char *max_str,
size_t *min_length, size_t *max_length);
/* For other character sets, with arbitrary mbminlen and mbmaxlen numbers */
my_bool my_like_range_generic(CHARSET_INFO *cs,
const char *ptr, size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length,
char *min_str, char *max_str,
size_t *min_length, size_t *max_length);
int my_wildcmp_8bit(CHARSET_INFO *,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many);
int my_wildcmp_bin(CHARSET_INFO *,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many);
size_t my_numchars_8bit(CHARSET_INFO *, const char *b, const char *e);
size_t my_numcells_8bit(CHARSET_INFO *, const char *b, const char *e);
size_t my_charpos_8bit(CHARSET_INFO *, const char *b, const char *e, size_t pos);
size_t my_well_formed_char_length_8bit(CHARSET_INFO *cs,
const char *b, const char *e,
size_t nchars,
MY_STRCOPY_STATUS *status);
int my_charlen_8bit(CHARSET_INFO *, const uchar *str, const uchar *end);
/* Functions for multibyte charsets */
extern size_t my_caseup_str_mb(CHARSET_INFO *, char *);
extern size_t my_casedn_str_mb(CHARSET_INFO *, char *);
extern size_t my_caseup_mb(CHARSET_INFO *,
const char *src, size_t srclen,
char *dst, size_t dstlen);
extern size_t my_casedn_mb(CHARSET_INFO *,
const char *src, size_t srclen,
char *dst, size_t dstlen);
extern size_t my_caseup_ujis(CHARSET_INFO *,
const char *src, size_t srclen,
char *dst, size_t dstlen);
extern size_t my_casedn_ujis(CHARSET_INFO *,
const char *src, size_t srclen,
char *dst, size_t dstlen);
extern int my_strcasecmp_mb(CHARSET_INFO * cs,const char *, const char *);
int my_wildcmp_mb(CHARSET_INFO *,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many);
size_t my_numchars_mb(CHARSET_INFO *, const char *b, const char *e);
size_t my_numcells_mb(CHARSET_INFO *, const char *b, const char *e);
size_t my_charpos_mb(CHARSET_INFO *, const char *b, const char *e, size_t pos);
uint my_instr_mb(CHARSET_INFO *,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch);
int my_wildcmp_mb_bin(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many);
int my_strcasecmp_mb_bin(CHARSET_INFO * cs __attribute__((unused)),
const char *s, const char *t);
void my_hash_sort_mb_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,ulong *nr1, ulong *nr2);
void my_hash_sort_mb_nopad_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2);
size_t my_strnxfrm_mb(CHARSET_INFO *,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags);
size_t my_strnxfrm_mb_nopad(CHARSET_INFO *,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags);
size_t my_strnxfrmlen_unicode(CHARSET_INFO *, size_t);
size_t my_strnxfrm_unicode_full_bin(CHARSET_INFO *,
uchar *dst, size_t dstlen,
uint nweights, const uchar *src,
size_t srclen, uint flags);
size_t my_strnxfrm_unicode_full_nopad_bin(CHARSET_INFO *,
uchar *dst, size_t dstlen,
uint nweights, const uchar *src,
size_t srclen, uint flags);
size_t my_strnxfrmlen_unicode_full_bin(CHARSET_INFO *, size_t);
int my_wildcmp_unicode(CHARSET_INFO *cs,
const char *str, const char *str_end,
const char *wildstr, const char *wildend,
int escape, int w_one, int w_many,
MY_CASEFOLD_INFO *weights);
extern my_bool my_parse_charset_xml(MY_CHARSET_LOADER *loader,
const char *buf, size_t buflen);
extern char *my_strchr(CHARSET_INFO *cs, const char *str, const char *end,
pchar c);
extern size_t my_strcspn(CHARSET_INFO *cs, const char *str, const char *end,
const char *accept);
my_bool my_propagate_simple(CHARSET_INFO *cs, const uchar *str, size_t len);
my_bool my_propagate_complex(CHARSET_INFO *cs, const uchar *str, size_t len);
uint my_ci_get_id_generic(CHARSET_INFO *cs, my_collation_id_type_t type);
LEX_CSTRING my_ci_get_collation_name_generic(CHARSET_INFO *cs,
my_collation_name_mode_t mode);
typedef struct
{
size_t char_length;
my_repertoire_t repertoire;
} MY_STRING_METADATA;
void my_string_metadata_get(MY_STRING_METADATA *metadata,
CHARSET_INFO *cs, const char *str, size_t len);
my_repertoire_t my_string_repertoire(CHARSET_INFO *cs,
const char *str, size_t len);
my_bool my_charset_is_ascii_based(CHARSET_INFO *cs);
my_repertoire_t my_charset_repertoire(CHARSET_INFO *cs);
uint my_strxfrm_flag_normalize(CHARSET_INFO *cs, uint flags);
void my_strxfrm_desc_and_reverse(uchar *str, uchar *strend,
uint flags, uint level);
size_t my_strxfrm_pad_desc_and_reverse(CHARSET_INFO *cs,
uchar *str, uchar *frmend, uchar *strend,
uint nweights, uint flags, uint level);
size_t my_strxfrm_pad_desc_and_reverse_nopad(CHARSET_INFO *cs,
uchar *str, uchar *frmend,
uchar *strend, uint nweights,
uint flags, uint level);
const MY_CONTRACTIONS *my_charset_get_contractions(CHARSET_INFO *cs,
int level);
extern size_t my_vsnprintf_ex(CHARSET_INFO *cs, char *to, size_t n,
const char* fmt, va_list ap);
/*
Convert a string between two character sets.
Bad byte sequences as well as characters that cannot be
encoded in the destination character set are replaced to '?'.
*/
uint32 my_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
const char *from, uint32 from_length,
CHARSET_INFO *from_cs, uint *errors);
/**
An extended version of my_convert(), to pass non-default mb_wc() and wc_mb().
For example, String::copy_printable() which is used in
Protocol::store_warning() uses this to escape control
and non-convertible characters.
*/
uint32 my_convert_using_func(char *to, size_t to_length, CHARSET_INFO *to_cs,
my_charset_conv_wc_mb mb_wc,
const char *from, size_t from_length,
CHARSET_INFO *from_cs,
my_charset_conv_mb_wc wc_mb,
uint *errors);
/*
Convert a string between two character sets.
Bad byte sequences as well as characters that cannot be
encoded in the destination character set are replaced to '?'.
Not more than "nchars" characters are copied.
Conversion statistics is returned in "status" and is set as follows:
- status->m_native_copy_status.m_source_end_pos - to the position
between (src) and (src+src_length), where the function stopped reading
the source string.
- status->m_native_copy_status.m_well_formed_error_pos - to the position
between (src) and (src+src_length), where the first badly formed byte
sequence was found, or to NULL if the string was well formed in the
given range.
- status->m_cannot_convert_error_pos - to the position
between (src) and (src+src_length), where the first character that
cannot be represented in the destination character set was found,
or to NULL if all characters in the given range were successfully
converted.
"src" is allowed to be a NULL pointer. In this case "src_length" must
be equal to 0. All "status" members are initialized to NULL, and 0 is
returned.
*/
size_t my_convert_fix(CHARSET_INFO *dstcs, char *dst, size_t dst_length,
CHARSET_INFO *srccs, const char *src, size_t src_length,
size_t nchars,
MY_STRCOPY_STATUS *copy_status,
MY_STRCONV_STATUS *conv_status);
#define _MY_U 01 /* Upper case */
#define _MY_L 02 /* Lower case */
#define _MY_NMR 04 /* Numeral (digit) */
#define _MY_SPC 010 /* Spacing character */
#define _MY_PNT 020 /* Punctuation */
#define _MY_CTR 040 /* Control character */
#define _MY_B 0100 /* Blank */
#define _MY_X 0200 /* heXadecimal digit */
#define my_isascii(c) (!((c) & ~0177))
#define my_toascii(c) ((c) & 0177)
#define my_tocntrl(c) ((c) & 31)
#define my_toprint(c) ((c) | 64)
#define my_toupper(s,c) (char) ((s)->to_upper[(uchar) (c)])
#define my_tolower(s,c) (char) ((s)->to_lower[(uchar) (c)])
#define my_isalpha(s, c) (((s)->m_ctype+1)[(uchar) (c)] & (_MY_U | _MY_L))
#define my_isupper(s, c) (((s)->m_ctype+1)[(uchar) (c)] & _MY_U)
#define my_islower(s, c) (((s)->m_ctype+1)[(uchar) (c)] & _MY_L)
#define my_isdigit(s, c) (((s)->m_ctype+1)[(uchar) (c)] & _MY_NMR)
#define my_isxdigit(s, c) (((s)->m_ctype+1)[(uchar) (c)] & _MY_X)
#define my_isalnum(s, c) (((s)->m_ctype+1)[(uchar) (c)] & (_MY_U | _MY_L | _MY_NMR))
#define my_isspace(s, c) (((s)->m_ctype+1)[(uchar) (c)] & _MY_SPC)
#define my_ispunct(s, c) (((s)->m_ctype+1)[(uchar) (c)] & _MY_PNT)
#define my_isprint(s, c) (((s)->m_ctype+1)[(uchar) (c)] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR | _MY_B))
#define my_isgraph(s, c) (((s)->m_ctype+1)[(uchar) (c)] & (_MY_PNT | _MY_U | _MY_L | _MY_NMR))
#define my_iscntrl(s, c) (((s)->m_ctype+1)[(uchar) (c)] & _MY_CTR)
/* Some macros that should be cleaned up a little */
#define my_isvar(s,c) (my_isalnum(s,c) || (c) == '_')
#define my_isvar_start(s,c) (my_isalpha(s,c) || (c) == '_')
#define my_binary_compare(s) ((s)->state & MY_CS_BINSORT)
#define use_strnxfrm(s) ((s)->state & MY_CS_STRNXFRM)
#define my_strnncoll(s, a, b, c, d) ((s)->coll->strnncoll((s), (a), (b), (c), (d), 0))
#define my_strcasecmp(s, a, b) ((s)->coll->strcasecmp((s), (a), (b)))
/**
Detect if the leftmost character in a string is a valid multi-byte character
and return its length, or return 0 otherwise.
@param cs - character set
@param str - the beginning of the string
@param end - the string end (the next byte after the string)
@return >0, for a multi-byte character
@return 0, for a single byte character, broken sequence, empty string.
*/
static inline
uint my_ismbchar(CHARSET_INFO *cs, const char *str, const char *end)
{
int char_length= (cs->cset->charlen)(cs, (const uchar *) str,
(const uchar *) end);
return char_length > 1 ? (uint) char_length : 0U;
}
/**
Convert broken and incomplete byte sequences to 1 byte.
*/
static inline
uint my_ci_charlen_fix(CHARSET_INFO *cs, const uchar *str, const uchar *end)
{
int char_length= my_ci_charlen(cs, str, end);
DBUG_ASSERT(str < end);
return char_length > 0 ? (uint) char_length : (uint) 1U;
}
/*
A compatibility replacement pure C function for the former
cs->cset->well_formed_len().
In C++ code please use Well_formed_prefix::length() instead.
*/
static inline size_t
my_well_formed_length(CHARSET_INFO *cs, const char *b, const char *e,
size_t nchars, int *error)
{
MY_STRCOPY_STATUS status;
(void) my_ci_well_formed_char_length(cs, b, e, nchars, &status);
*error= status.m_well_formed_error_pos == NULL ? 0 : 1;
return (size_t) (status.m_source_end_pos - b);
}
#define my_caseup_str(s, a) ((s)->cset->caseup_str((s), (a)))
#define my_casedn_str(s, a) ((s)->cset->casedn_str((s), (a)))
/* XXX: still need to take care of this one */
#ifdef MY_CHARSET_TIS620
#error The TIS620 charset is broken at the moment. Tell tim to fix it.
#define USE_TIS620
#include "t_ctype.h"
#endif
int my_wc_mb_utf8mb4_bmp_only(CHARSET_INFO *cs, my_wc_t wc, uchar *r,
uchar *e);
#ifdef __cplusplus
}
#endif
#endif /* _m_ctype_h */
PK ! #
my_valgrind.hnu [ /* Copyright (C) 2010, 2022, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef MY_VALGRIND_INCLUDED
#define MY_VALGRIND_INCLUDED
/* clang -> gcc */
#ifndef __has_feature
# define __has_feature(x) 0
#endif
#if __has_feature(address_sanitizer)
# define __SANITIZE_ADDRESS__ 1
#endif
#if __has_feature(memory_sanitizer)
# include
# define HAVE_valgrind
# define HAVE_MEM_CHECK
# define MEM_UNDEFINED(a,len) __msan_allocated_memory(a,len)
# define MEM_MAKE_ADDRESSABLE(a,len) MEM_UNDEFINED(a,len)
# define MEM_MAKE_DEFINED(a,len) __msan_unpoison(a,len)
# define MEM_NOACCESS(a,len) ((void) 0)
# define MEM_CHECK_ADDRESSABLE(a,len) ((void) 0)
# define MEM_CHECK_DEFINED(a,len) __msan_check_mem_is_initialized(a,len)
# define MEM_GET_VBITS(a,b,len) __msan_copy_shadow(b,a,len)
# define MEM_SET_VBITS(a,b,len) __msan_copy_shadow(a,b,len)
# define REDZONE_SIZE 8
#elif defined(HAVE_VALGRIND_MEMCHECK_H) && defined(HAVE_valgrind)
# include
# define HAVE_MEM_CHECK
# define MEM_UNDEFINED(a,len) VALGRIND_MAKE_MEM_UNDEFINED(a,len)
# define MEM_MAKE_ADDRESSABLE(a,len) MEM_UNDEFINED(a,len)
# define MEM_MAKE_DEFINED(a,len) VALGRIND_MAKE_MEM_DEFINED(a,len)
# define MEM_NOACCESS(a,len) VALGRIND_MAKE_MEM_NOACCESS(a,len)
# define MEM_CHECK_ADDRESSABLE(a,len) VALGRIND_CHECK_MEM_IS_ADDRESSABLE(a,len)
# define MEM_CHECK_DEFINED(a,len) VALGRIND_CHECK_MEM_IS_DEFINED(a,len)
# define MEM_GET_VBITS(a,b,len) VALGRIND_GET_VBITS(a,b,len)
# define MEM_SET_VBITS(a,b,len) VALGRIND_SET_VBITS(a,b,len)
# define REDZONE_SIZE 8
#elif defined(__SANITIZE_ADDRESS__) && (!defined(_MSC_VER) || defined (__clang__))
# include
/* How to do manual poisoning:
https://github.com/google/sanitizers/wiki/AddressSanitizerManualPoisoning */
# define MEM_UNDEFINED(a,len) ((void) 0)
# define MEM_MAKE_ADDRESSABLE(a,len) ASAN_UNPOISON_MEMORY_REGION(a,len)
# define MEM_MAKE_DEFINED(a,len) ((void) 0)
# define MEM_NOACCESS(a,len) ASAN_POISON_MEMORY_REGION(a,len)
# define MEM_CHECK_ADDRESSABLE(a,len) \
assert(!__asan_region_is_poisoned((void*) a,len))
# define MEM_CHECK_DEFINED(a,len) ((void) 0)
# define MEM_GET_VBITS(a,b,len) ((void) 0)
# define MEM_SET_VBITS(a,b,len) ((void) 0)
# define REDZONE_SIZE 8
#else
# define MEM_UNDEFINED(a,len) ((void) 0)
# define MEM_MAKE_ADDRESSABLE(a,len) ((void) 0)
# define MEM_MAKE_DEFINED(a,len) ((void) 0)
# define MEM_NOACCESS(a,len) ((void) 0)
# define MEM_CHECK_ADDRESSABLE(a,len) ((void) 0)
# define MEM_CHECK_DEFINED(a,len) ((void) 0)
# define MEM_GET_VBITS(a,b,len) ((void) 0)
# define MEM_SET_VBITS(a,b,len) ((void) 0)
# define REDZONE_SIZE 0
#endif /* __has_feature(memory_sanitizer) */
#ifdef TRASH_FREED_MEMORY
/*
_TRASH_FILL() has to call MEM_MAKE_ADDRESSABLE() to cancel any effect of
TRASH_FREE().
This can happen in the case one does
TRASH_ALLOC(A,B) ; TRASH_FREE(A,B) ; TRASH_ALLOC(A,B)
to reuse the same memory in an internal memory allocator like MEM_ROOT.
_TRASH_FILL() is an internal function and should not be used externally.
*/
#define _TRASH_FILL(A,B,C) do { const size_t trash_tmp= (B); MEM_MAKE_ADDRESSABLE(A, trash_tmp); memset(A, C, trash_tmp); } while (0)
#else
#define _TRASH_FILL(A,B,C) do { MEM_UNDEFINED((A), (B)); } while (0)
#endif
/** Note that some memory became allocated and/or uninitialized. */
#define TRASH_ALLOC(A,B) do { _TRASH_FILL(A,B,0xA5); MEM_MAKE_ADDRESSABLE(A,B); } while(0)
/** Note that some memory became freed. (Prohibit further access to it.) */
#define TRASH_FREE(A,B) do { _TRASH_FILL(A,B,0x8F); MEM_NOACCESS(A,B); } while(0)
#endif /* MY_VALGRIND_INCLUDED */
PK ! `mG my_list.hnu [ /* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _list_h_
#define _list_h_
#ifdef __cplusplus
extern "C" {
#endif
typedef struct st_list {
struct st_list *prev,*next;
void *data;
} LIST;
typedef int (*list_walk_action)(void *,void *);
extern LIST *list_add(LIST *root,LIST *element);
extern LIST *list_delete(LIST *root,LIST *element);
extern LIST *list_cons(void *data,LIST *root);
extern LIST *list_reverse(LIST *root);
extern void list_free(LIST *root,unsigned int free_data);
extern unsigned int list_length(LIST *);
extern int list_walk(LIST *,list_walk_action action,unsigned char * argument);
#define list_rest(a) ((a)->next)
#define list_push(a,b) (a)=list_cons((b),(a))
#define list_pop(A) {LIST *old=(A); (A)=list_delete(old,old); my_free(old); }
#ifdef __cplusplus
}
#endif
#endif
PK ! k k my_pthread.hnu [ /* Copyright (c) 2000, 2014, Oracle and/or its affiliates.
Copyright (c) 2009, 2020, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/* Defines to make different thread packages compatible */
#ifndef _my_pthread_h
#define _my_pthread_h
#ifndef ETIME
#define ETIME ETIMEDOUT /* For FreeBSD */
#endif
#ifdef __cplusplus
#define EXTERNC extern "C"
extern "C" {
#else
#define EXTERNC
#endif /* __cplusplus */
#if defined(_WIN32)
typedef CRITICAL_SECTION pthread_mutex_t;
typedef DWORD pthread_t;
typedef struct thread_attr {
DWORD dwStackSize ;
DWORD dwCreatingFlag ;
} pthread_attr_t ;
typedef struct { int dummy; } pthread_condattr_t;
/* Implementation of posix conditions */
typedef struct st_pthread_link {
DWORD thread_id;
struct st_pthread_link *next;
} pthread_link;
/**
Implementation of Windows condition variables.
We use native conditions on Vista and later, and fallback to own
implementation on earlier OS version.
*/
typedef CONDITION_VARIABLE pthread_cond_t;
typedef int pthread_mutexattr_t;
#define pthread_self() GetCurrentThreadId()
#define pthread_handler_t EXTERNC void * __cdecl
typedef void * (__cdecl *pthread_handler)(void *);
typedef INIT_ONCE my_pthread_once_t;
#define MY_PTHREAD_ONCE_INIT INIT_ONCE_STATIC_INIT;
#if !STRUCT_TIMESPEC_HAS_TV_SEC || !STRUCT_TIMESPEC_HAS_TV_NSEC
struct timespec {
time_t tv_sec;
long tv_nsec;
};
#endif
int win_pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_create(pthread_t *, const pthread_attr_t *, pthread_handler, void *);
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
const struct timespec *abstime);
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_attr_init(pthread_attr_t *connect_att);
int pthread_attr_setstacksize(pthread_attr_t *connect_att,size_t stack);
int pthread_attr_destroy(pthread_attr_t *connect_att);
int my_pthread_once(my_pthread_once_t *once_control,void (*init_routine)(void));
static inline struct tm *localtime_r(const time_t *timep, struct tm *tmp)
{
localtime_s(tmp, timep);
return tmp;
}
static inline struct tm *gmtime_r(const time_t *clock, struct tm *res)
{
gmtime_s(res, clock);
return res;
}
void pthread_exit(void *a);
int pthread_join(pthread_t thread, void **value_ptr);
int pthread_cancel(pthread_t thread);
#ifndef ETIMEDOUT
#define ETIMEDOUT 145 /* Win32 doesn't have this */
#endif
#define HAVE_LOCALTIME_R 1
#define _REENTRANT 1
#define HAVE_PTHREAD_ATTR_SETSTACKSIZE 1
#undef SAFE_MUTEX /* This will cause conflicts */
#define pthread_key(T,V) DWORD V
#define pthread_key_create(A,B) ((*A=TlsAlloc())==0xFFFFFFFF)
#define pthread_key_delete(A) TlsFree(A)
#define my_pthread_setspecific_ptr(T,V) (!TlsSetValue((T),(V)))
#define pthread_setspecific(A,B) (!TlsSetValue((A),(LPVOID)(B)))
#define pthread_getspecific(A) (TlsGetValue(A))
#define my_pthread_getspecific(T,A) ((T) TlsGetValue(A))
#define my_pthread_getspecific_ptr(T,V) ((T) TlsGetValue(V))
#define pthread_equal(A,B) ((A) == (B))
#define pthread_mutex_init(A,B) (InitializeCriticalSection(A),0)
#define pthread_mutex_lock(A) (EnterCriticalSection(A),0)
#define pthread_mutex_trylock(A) win_pthread_mutex_trylock((A))
#define pthread_mutex_unlock(A) (LeaveCriticalSection(A), 0)
#define pthread_mutex_destroy(A) (DeleteCriticalSection(A), 0)
#define pthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
/* Dummy defines for easier code */
#define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
#define pthread_attr_setscope(A,B)
#define pthread_detach_this_thread()
#define pthread_condattr_init(A)
#define pthread_condattr_destroy(A)
#define pthread_yield() SwitchToThread()
#define my_sigset(A,B) signal(A,B)
#else /* Normal threads */
#ifdef HAVE_rts_threads
#define sigwait org_sigwait
#include
#undef sigwait
#endif
#include
#ifndef _REENTRANT
#define _REENTRANT
#endif
#ifdef HAVE_SCHED_H
#include
#endif
#ifdef HAVE_SYNCH_H
#include
#endif
#define pthread_key(T,V) pthread_key_t V
#define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,(V))
#define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,(void*) (V))
#define pthread_detach_this_thread()
#define pthread_handler_t EXTERNC void *
typedef void *(* pthread_handler)(void *);
#define my_pthread_once_t pthread_once_t
#if defined(PTHREAD_ONCE_INITIALIZER)
#define MY_PTHREAD_ONCE_INIT PTHREAD_ONCE_INITIALIZER
#else
#define MY_PTHREAD_ONCE_INIT PTHREAD_ONCE_INIT
#endif
#define my_pthread_once(C,F) pthread_once(C,F)
/* Test first for RTS or FSU threads */
#if defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM)
#define HAVE_rts_threads
extern int my_pthread_create_detached;
#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
#define PTHREAD_CREATE_DETACHED &my_pthread_create_detached
#define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_GLOBAL
#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_LOCAL
#endif /* defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM) */
#if defined(_BSDI_VERSION) && _BSDI_VERSION < 199910
int sigwait(sigset_t *set, int *sig);
#endif
static inline int my_sigwait(sigset_t *set, int *sig, int *code)
{
#ifdef HAVE_SIGWAITINFO
siginfo_t siginfo;
*sig= sigwaitinfo(set, &siginfo);
*code= siginfo.si_code;
return *sig < 0 ? errno : 0;
#else
*code= 0;
return sigwait(set, sig);
#endif
}
#if defined(HAVE_SIGTHREADMASK) && !defined(HAVE_PTHREAD_SIGMASK)
#define pthread_sigmask(A,B,C) sigthreadmask((A),(B),(C))
#endif
#if !defined(HAVE_SIGWAIT) && !defined(HAVE_rts_threads) && !defined(sigwait) && !defined(alpha_linux_port) && !defined(_AIX)
int sigwait(sigset_t *setp, int *sigp); /* Use our implementation */
#endif
/*
We define my_sigset() and use that instead of the system sigset() so that
we can favor an implementation based on sigaction(). On some systems, such
as Mac OS X, sigset() results in flags such as SA_RESTART being set, and
we want to make sure that no such flags are set.
*/
#if defined(HAVE_SIGACTION) && !defined(my_sigset)
#define my_sigset(A,B) do { struct sigaction l_s; sigset_t l_set; \
DBUG_ASSERT((A) != 0); \
sigemptyset(&l_set); \
l_s.sa_handler = (B); \
l_s.sa_mask = l_set; \
l_s.sa_flags = 0; \
sigaction((A), &l_s, NULL); \
} while (0)
#elif defined(HAVE_SIGSET) && !defined(my_sigset)
#define my_sigset(A,B) sigset((A),(B))
#elif !defined(my_sigset)
#define my_sigset(A,B) signal((A),(B))
#endif
#if !defined(HAVE_PTHREAD_ATTR_SETSCOPE)
#define pthread_attr_setscope(A,B)
#undef HAVE_GETHOSTBYADDR_R /* No definition */
#endif
#define my_pthread_getspecific(A,B) ((A) pthread_getspecific(B))
#ifndef HAVE_LOCALTIME_R
struct tm *localtime_r(const time_t *clock, struct tm *res);
#endif
#ifndef HAVE_GMTIME_R
struct tm *gmtime_r(const time_t *clock, struct tm *res);
#endif
#ifdef HAVE_PTHREAD_CONDATTR_CREATE
/* DCE threads on HPUX 10.20 */
#define pthread_condattr_init pthread_condattr_create
#define pthread_condattr_destroy pthread_condattr_delete
#endif
/* FSU THREADS */
#if !defined(HAVE_PTHREAD_KEY_DELETE) && !defined(pthread_key_delete)
#define pthread_key_delete(A) pthread_dummy(0)
#endif
#if defined(HAVE_PTHREAD_ATTR_CREATE) && !defined(HAVE_SIGWAIT)
/* This is set on AIX_3_2 and Siemens unix (and DEC OSF/1 3.2 too) */
#define pthread_key_create(A,B) \
pthread_keycreate(A,(B) ?\
(pthread_destructor_t) (B) :\
(pthread_destructor_t) pthread_dummy)
#define pthread_attr_init(A) pthread_attr_create(A)
#define pthread_attr_destroy(A) pthread_attr_delete(A)
#define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
#define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
#ifndef pthread_sigmask
#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
#endif
#define pthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
#undef pthread_detach_this_thread
#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
#else /* HAVE_PTHREAD_ATTR_CREATE && !HAVE_SIGWAIT */
#define HAVE_PTHREAD_KILL 1
#endif
#endif /* defined(_WIN32) */
#if defined(HPUX10) && !defined(DONT_REMAP_PTHREAD_FUNCTIONS)
#undef pthread_cond_timedwait
#define pthread_cond_timedwait(a,b,c) my_pthread_cond_timedwait((a),(b),(c))
int my_pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
struct timespec *abstime);
#endif
#if defined(HPUX10)
#define pthread_attr_getstacksize(A,B) my_pthread_attr_getstacksize(A,B)
void my_pthread_attr_getstacksize(pthread_attr_t *attrib, size_t *size);
#endif
#if defined(HAVE_POSIX1003_4a_MUTEX) && !defined(DONT_REMAP_PTHREAD_FUNCTIONS)
#undef pthread_mutex_trylock
#define pthread_mutex_trylock(a) my_pthread_mutex_trylock((a))
int my_pthread_mutex_trylock(pthread_mutex_t *mutex);
#endif
#ifdef HAVE_SCHED_YIELD
#define pthread_yield() sched_yield()
#else
#if !defined(HAVE_PTHREAD_YIELD_ZERO_ARG)
/* no pthread_yield() available */
#if defined(HAVE_PTHREAD_YIELD_NP) /* can be Mac OS X */
#define pthread_yield() pthread_yield_np()
#elif defined(HAVE_THR_YIELD)
#define pthread_yield() thr_yield()
#endif //defined(HAVE_PTHREAD_YIELD_NP)
#endif //!defined(HAVE_PTHREAD_YIELD_ZERO_ARG)
#endif //HAVE_SCHED_YIELD
size_t my_setstacksize(pthread_attr_t *attr, size_t stacksize);
/*
The defines set_timespec and set_timespec_nsec should be used
for calculating an absolute time at which
pthread_cond_timedwait should timeout
*/
#define set_timespec(ABSTIME,SEC) set_timespec_nsec((ABSTIME),(SEC)*1000000000ULL)
#ifndef set_timespec_nsec
#define set_timespec_nsec(ABSTIME,NSEC) \
set_timespec_time_nsec((ABSTIME), my_hrtime_coarse().val*1000 + (NSEC))
#endif /* !set_timespec_nsec */
/* adapt for two different flavors of struct timespec */
#ifdef HAVE_TIMESPEC_TS_SEC
#define MY_tv_sec ts_sec
#define MY_tv_nsec ts_nsec
#else
#define MY_tv_sec tv_sec
#define MY_tv_nsec tv_nsec
#endif /* HAVE_TIMESPEC_TS_SEC */
/**
Compare two timespec structs.
@retval 1 If TS1 ends after TS2.
@retval 0 If TS1 is equal to TS2.
@retval -1 If TS1 ends before TS2.
*/
#ifndef cmp_timespec
#define cmp_timespec(TS1, TS2) \
((TS1.MY_tv_sec > TS2.MY_tv_sec || \
(TS1.MY_tv_sec == TS2.MY_tv_sec && TS1.MY_tv_nsec > TS2.MY_tv_nsec)) ? 1 : \
((TS1.MY_tv_sec < TS2.MY_tv_sec || \
(TS1.MY_tv_sec == TS2.MY_tv_sec && TS1.MY_tv_nsec < TS2.MY_tv_nsec)) ? -1 : 0))
#endif /* !cmp_timespec */
#ifndef set_timespec_time_nsec
#define set_timespec_time_nsec(ABSTIME,NSEC) do { \
ulonglong _now_= (NSEC); \
(ABSTIME).MY_tv_sec= (time_t) (_now_ / 1000000000ULL); \
(ABSTIME).MY_tv_nsec= (ulong) (_now_ % 1000000000UL); \
} while(0)
#endif /* !set_timespec_time_nsec */
#ifdef MYSQL_CLIENT
#define _current_thd() NULL
#else
MYSQL_THD _current_thd();
#endif
/* safe_mutex adds checking to mutex for easier debugging */
struct st_hash;
typedef struct st_safe_mutex_t
{
pthread_mutex_t global,mutex;
const char *file, *name;
uint line,count;
myf create_flags, active_flags;
ulong id;
pthread_t thread;
struct st_hash *locked_mutex, *used_mutex;
struct st_safe_mutex_t *prev, *next;
#ifdef SAFE_MUTEX_DETECT_DESTROY
struct st_safe_mutex_info_t *info; /* to track destroying of mutexes */
#endif
} safe_mutex_t;
typedef struct st_safe_mutex_deadlock_t
{
const char *file, *name;
safe_mutex_t *mutex;
uint line;
ulong count;
ulong id;
my_bool warning_only;
} safe_mutex_deadlock_t;
#ifdef SAFE_MUTEX_DETECT_DESTROY
/*
Used to track the destroying of mutexes. This needs to be a separate
structure because the safe_mutex_t structure could be freed before
the mutexes are destroyed.
*/
typedef struct st_safe_mutex_info_t
{
struct st_safe_mutex_info_t *next;
struct st_safe_mutex_info_t *prev;
const char *init_file;
uint32 init_line;
} safe_mutex_info_t;
#endif /* SAFE_MUTEX_DETECT_DESTROY */
int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr,
const char *name, const char *file, uint line);
int safe_mutex_lock(safe_mutex_t *mp, myf my_flags, const char *file,
uint line);
int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line);
int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint line);
int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file,
uint line);
int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
const struct timespec *abstime,
const char *file, uint line);
void safe_mutex_global_init(void);
void safe_mutex_end(FILE *file);
void safe_mutex_free_deadlock_data(safe_mutex_t *mp);
/* Wrappers if safe mutex is actually used */
#define MYF_TRY_LOCK 1
#define MYF_NO_DEADLOCK_DETECTION 2
#ifdef SAFE_MUTEX
#define safe_mutex_is_owner(mp) ((mp)->count > 0 && \
pthread_equal(pthread_self(), (mp)->thread))
#define safe_mutex_assert_owner(mp) DBUG_ASSERT(safe_mutex_is_owner(mp))
#define safe_mutex_assert_not_owner(mp) DBUG_ASSERT(!safe_mutex_is_owner(mp))
#define safe_mutex_setflags(mp, F) do { (mp)->create_flags|= (F); } while (0)
#define my_cond_timedwait(A,B,C) safe_cond_timedwait((A),(B),(C),__FILE__,__LINE__)
#define my_cond_wait(A,B) safe_cond_wait((A), (B), __FILE__, __LINE__)
#else
#define safe_mutex_is_owner(mp) (1)
#define safe_mutex_assert_owner(mp) do {} while (0)
#define safe_mutex_assert_not_owner(mp) do {} while (0)
#define safe_mutex_setflags(mp, F) do {} while (0)
#define my_cond_timedwait(A,B,C) pthread_cond_timedwait((A),(B),(C))
#define my_cond_wait(A,B) pthread_cond_wait((A), (B))
#endif /* !SAFE_MUTEX */
/* READ-WRITE thread locking */
#if defined(USE_MUTEX_INSTEAD_OF_RW_LOCKS)
/* use these defs for simple mutex locking */
#define rw_lock_t pthread_mutex_t
#define my_rwlock_init(A,B) pthread_mutex_init((A),(B))
#define rw_rdlock(A) pthread_mutex_lock((A))
#define rw_wrlock(A) pthread_mutex_lock((A))
#define rw_tryrdlock(A) pthread_mutex_trylock((A))
#define rw_trywrlock(A) pthread_mutex_trylock((A))
#define rw_unlock(A) pthread_mutex_unlock((A))
#define rwlock_destroy(A) pthread_mutex_destroy((A))
#elif defined(HAVE_PTHREAD_RWLOCK_RDLOCK)
#define rw_lock_t pthread_rwlock_t
#define my_rwlock_init(A,B) pthread_rwlock_init((A),(B))
#define rw_rdlock(A) pthread_rwlock_rdlock(A)
#define rw_wrlock(A) pthread_rwlock_wrlock(A)
#define rw_tryrdlock(A) pthread_rwlock_tryrdlock((A))
#define rw_trywrlock(A) pthread_rwlock_trywrlock((A))
#define rw_unlock(A) pthread_rwlock_unlock(A)
#define rwlock_destroy(A) pthread_rwlock_destroy(A)
#elif defined(HAVE_RWLOCK_INIT)
#ifdef HAVE_RWLOCK_T /* For example Solaris 2.6-> */
#define rw_lock_t rwlock_t
#endif
#define my_rwlock_init(A,B) rwlock_init((A),USYNC_THREAD,0)
#else
/* Use our own version of read/write locks */
#define NEED_MY_RW_LOCK 1
#define rw_lock_t my_rw_lock_t
#define my_rwlock_init(A,B) my_rw_init((A))
#define rw_rdlock(A) my_rw_rdlock((A))
#define rw_wrlock(A) my_rw_wrlock((A))
#define rw_tryrdlock(A) my_rw_tryrdlock((A))
#define rw_trywrlock(A) my_rw_trywrlock((A))
#define rw_unlock(A) my_rw_unlock((A))
#define rwlock_destroy(A) my_rw_destroy((A))
#define rw_lock_assert_write_owner(A) my_rw_lock_assert_write_owner((A))
#define rw_lock_assert_not_write_owner(A) my_rw_lock_assert_not_write_owner((A))
#endif /* USE_MUTEX_INSTEAD_OF_RW_LOCKS */
/**
Portable implementation of special type of read-write locks.
These locks have two properties which are unusual for rwlocks:
1) They "prefer readers" in the sense that they do not allow
situations in which rwlock is rd-locked and there is a
pending rd-lock which is blocked (e.g. due to pending
request for wr-lock).
This is a stronger guarantee than one which is provided for
PTHREAD_RWLOCK_PREFER_READER_NP rwlocks in Linux.
MDL subsystem deadlock detector relies on this property for
its correctness.
2) They are optimized for uncontended wr-lock/unlock case.
This is a scenario in which they are most often used
within MDL subsystem. Optimizing for it gives significant
performance improvements in some of the tests involving many
connections.
Another important requirement imposed on this type of rwlock
by the MDL subsystem is that it should be OK to destroy rwlock
object which is in unlocked state even though some threads might
have not yet fully left unlock operation for it (of course there
is an external guarantee that no thread will try to lock rwlock
which is destroyed).
Putting it another way the unlock operation should not access
rwlock data after changing its state to unlocked.
TODO/FIXME: We should consider alleviating this requirement as
it blocks us from doing certain performance optimizations.
*/
typedef struct st_rw_pr_lock_t {
/**
Lock which protects the structure.
Also held for the duration of wr-lock.
*/
pthread_mutex_t lock;
/**
Condition variable which is used to wake-up
writers waiting for readers to go away.
*/
pthread_cond_t no_active_readers;
/** Number of active readers. */
uint active_readers;
/** Number of writers waiting for readers to go away. */
uint writers_waiting_readers;
/** Indicates whether there is an active writer. */
my_bool active_writer;
#ifdef SAFE_MUTEX
/** Thread holding wr-lock (for debug purposes only). */
pthread_t writer_thread;
#endif
} rw_pr_lock_t;
extern int rw_pr_init(rw_pr_lock_t *);
extern int rw_pr_rdlock(rw_pr_lock_t *);
extern int rw_pr_wrlock(rw_pr_lock_t *);
extern int rw_pr_unlock(rw_pr_lock_t *);
extern int rw_pr_destroy(rw_pr_lock_t *);
#ifdef SAFE_MUTEX
#define rw_pr_lock_assert_write_owner(A) \
DBUG_ASSERT((A)->active_writer && pthread_equal(pthread_self(), \
(A)->writer_thread))
#define rw_pr_lock_assert_not_write_owner(A) \
DBUG_ASSERT(! (A)->active_writer || ! pthread_equal(pthread_self(), \
(A)->writer_thread))
#else
#define rw_pr_lock_assert_write_owner(A)
#define rw_pr_lock_assert_not_write_owner(A)
#endif /* SAFE_MUTEX */
#ifdef NEED_MY_RW_LOCK
#ifdef _WIN32
/**
Implementation of Windows rwlock.
We use native (slim) rwlocks on Windows, which requires Win7
or later.
*/
typedef struct _my_rwlock_t
{
SRWLOCK srwlock; /* native reader writer lock */
BOOL have_exclusive_srwlock; /* used for unlock */
} my_rw_lock_t;
#else /* _WIN32 */
/*
On systems which don't support native read/write locks we have
to use own implementation.
*/
typedef struct st_my_rw_lock_t {
pthread_mutex_t lock; /* lock for structure */
pthread_cond_t readers; /* waiting readers */
pthread_cond_t writers; /* waiting writers */
int state; /* -1:writer,0:free,>0:readers */
int waiters; /* number of waiting writers */
#ifdef SAFE_MUTEX
pthread_t write_thread;
#endif
} my_rw_lock_t;
#endif /*! _WIN32 */
extern int my_rw_init(my_rw_lock_t *);
extern int my_rw_destroy(my_rw_lock_t *);
extern int my_rw_rdlock(my_rw_lock_t *);
extern int my_rw_wrlock(my_rw_lock_t *);
extern int my_rw_unlock(my_rw_lock_t *);
extern int my_rw_tryrdlock(my_rw_lock_t *);
extern int my_rw_trywrlock(my_rw_lock_t *);
#ifdef SAFE_MUTEX
#define my_rw_lock_assert_write_owner(A) \
DBUG_ASSERT((A)->state == -1 && pthread_equal(pthread_self(), \
(A)->write_thread))
#define my_rw_lock_assert_not_write_owner(A) \
DBUG_ASSERT((A)->state >= 0 || ! pthread_equal(pthread_self(), \
(A)->write_thread))
#else
#define my_rw_lock_assert_write_owner(A)
#define my_rw_lock_assert_not_write_owner(A)
#endif
#endif /* NEED_MY_RW_LOCK */
#define GETHOSTBYADDR_BUFF_SIZE 2048
#if !defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) && ! defined(pthread_attr_setstacksize)
#define pthread_attr_setstacksize(A,B) pthread_dummy(0)
#endif
/* Define mutex types, see my_thr_init.c */
#define MY_MUTEX_INIT_SLOW NULL
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
extern pthread_mutexattr_t my_fast_mutexattr;
#define MY_MUTEX_INIT_FAST &my_fast_mutexattr
#else
#define MY_MUTEX_INIT_FAST NULL
#endif
#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
extern pthread_mutexattr_t my_errorcheck_mutexattr;
#define MY_MUTEX_INIT_ERRCHK &my_errorcheck_mutexattr
#else
#define MY_MUTEX_INIT_ERRCHK NULL
#endif
#ifndef ESRCH
/* Define it to something */
#define ESRCH 1
#endif
typedef uint64 my_thread_id;
/**
Long-standing formats (such as the client-server protocol and the binary log)
hard-coded `my_thread_id` to 32 bits in practice. (Though not all
`thread_id`s are typed as such, @ref my_thread_id itself among those.)
@see MDEV-35706
*/
#define MY_THREAD_ID_MAX UINT32_MAX
extern void my_threadattr_global_init(void);
extern my_bool my_thread_global_init(void);
extern void my_thread_global_reinit(void);
extern void my_thread_global_end(void);
extern my_bool my_thread_init(void);
extern void my_thread_end(void);
extern const char *my_thread_name(void);
extern my_thread_id my_thread_dbug_id(void);
extern int pthread_dummy(int);
extern void my_mutex_init(void);
extern void my_mutex_end(void);
/* All thread specific variables are in the following struct */
#define THREAD_NAME_SIZE 10
#ifndef DEFAULT_THREAD_STACK
/*
We need to have at least 256K stack to handle calls to myisamchk_init()
with the current number of keys and key parts.
*/
#if !defined(__has_feature)
#define __has_feature(x) 0
#endif
#if defined(__clang__) && __has_feature(memory_sanitizer) && !defined(DBUG_OFF)
/*
MSAN in Debug with clang-20.1 required more memory to complete
mtr begin/end checks. The result without increase was MSAN
errors triggered on a call instruction.
*/
# define DEFAULT_THREAD_STACK (2L<<20)
# elif defined(__SANITIZE_ADDRESS__) || defined(WITH_UBSAN)
/*
Optimized WITH_ASAN=ON executables produced
by GCC 12.3.0, GCC 13.2.0, or clang 16.0.6
would fail ./mtr main.1st when the stack size is 5 MiB.
The minimum is more than 6 MiB for CMAKE_BUILD_TYPE=RelWithDebInfo and
more than 10 MiB for CMAKE_BUILD_TYPE=Debug.
Let us add some safety margin.
*/
# define DEFAULT_THREAD_STACK (11L<<20)
# else
# define DEFAULT_THREAD_STACK (292*1024L) /* 299008 */
# endif
#endif
#define MY_PTHREAD_LOCK_READ 0
#define MY_PTHREAD_LOCK_WRITE 1
#include
#define INSTRUMENT_ME 0
/*
Thread specific variables
Aria key cache is using the following variables for keeping track of
state:
suspend, next, prev, keycache_link, keycache_file, suspend, lock_type
MariaDB uses the following to
mutex, current_mutex, current_cond, abort
*/
struct st_my_thread_var
{
int thr_errno;
mysql_cond_t suspend;
mysql_mutex_t mutex;
struct st_my_thread_var *next,**prev;
mysql_mutex_t * volatile current_mutex;
mysql_cond_t * volatile current_cond;
void *keycache_link;
void *keycache_file;
void *stack_ends_here;
safe_mutex_t *mutex_in_use;
pthread_t pthread_self;
my_thread_id id, dbug_id;
int volatile abort;
uint lock_type; /* used by conditional release the queue */
my_bool init;
#ifndef DBUG_OFF
void *dbug;
char name[THREAD_NAME_SIZE+1];
#endif
};
struct st_my_thread_var *_my_thread_var(void);
extern void **my_thread_var_dbug(void);
extern safe_mutex_t **my_thread_var_mutex_in_use(void);
extern uint my_thread_end_wait_time;
extern my_bool safe_mutex_deadlock_detector;
#define my_thread_var (_my_thread_var())
#define my_errno my_thread_var->thr_errno
int set_mysys_var(struct st_my_thread_var *mysys_var);
/*
thread_safe_xxx functions are for critical statistic or counters.
The implementation is guaranteed to be thread safe, on all platforms.
Note that the calling code should *not* assume the counter is protected
by the mutex given, as the implementation of these helpers may change
to use my_atomic operations instead.
*/
#ifndef thread_safe_increment
#ifdef _WIN32
#define thread_safe_increment(V,L) InterlockedIncrement((long*) &(V))
#define thread_safe_decrement(V,L) InterlockedDecrement((long*) &(V))
#else
#define thread_safe_increment(V,L) \
(mysql_mutex_lock((L)), (V)++, mysql_mutex_unlock((L)))
#define thread_safe_decrement(V,L) \
(mysql_mutex_lock((L)), (V)--, mysql_mutex_unlock((L)))
#endif
#endif
#ifndef thread_safe_add
#ifdef _WIN32
#define thread_safe_add(V,C,L) InterlockedExchangeAdd((long*) &(V),(C))
#define thread_safe_sub(V,C,L) InterlockedExchangeAdd((long*) &(V),-(long) (C))
#else
#define thread_safe_add(V,C,L) \
(mysql_mutex_lock((L)), (V)+=(C), mysql_mutex_unlock((L)))
#define thread_safe_sub(V,C,L) \
(mysql_mutex_lock((L)), (V)-=(C), mysql_mutex_unlock((L)))
#endif
#endif
/*
statistics_xxx functions are for non critical statistic,
maintained in global variables.
When compiling with SAFE_STATISTICS:
- race conditions can not occur.
- some locking occurs, which may cause performance degradation.
When compiling without SAFE_STATISTICS:
- race conditions can occur, making the result slightly inaccurate.
- the lock given is not honored.
*/
#ifdef SAFE_STATISTICS
#define statistic_increment(V,L) thread_safe_increment((V),(L))
#define statistic_decrement(V,L) thread_safe_decrement((V),(L))
#define statistic_add(V,C,L) thread_safe_add((V),(C),(L))
#define statistic_sub(V,C,L) thread_safe_sub((V),(C),(L))
#else
#define statistic_decrement(V,L) (V)--
#define statistic_increment(V,L) (V)++
#define statistic_add(V,C,L) (V)+=(C)
#define statistic_sub(V,C,L) (V)-=(C)
#endif /* SAFE_STATISTICS */
/*
No locking needed, the counter is owned by the thread
*/
#define status_var_increment(V) (V)++
#define status_var_decrement(V) (V)--
#define status_var_add(V,C) (V)+=(C)
#define status_var_sub(V,C) (V)-=(C)
#ifdef SAFE_MUTEX
#define mysql_mutex_record_order(A,B) \
do { \
mysql_mutex_lock(A); mysql_mutex_lock(B); \
mysql_mutex_unlock(B); mysql_mutex_unlock(A); \
} while(0)
#else
#define mysql_mutex_record_order(A,B) do { } while(0)
#endif
/* At least Windows and NetBSD do not have this definition */
#ifndef PTHREAD_STACK_MIN
#define PTHREAD_STACK_MIN 65536
#endif
#ifdef __cplusplus
}
#endif
#endif /* _my_ptread_h */
PK ! g g my_xml.hnu [ /* Copyright (c) 2000, 2002, 2003, 2005, 2007 MySQL AB
Use is subject to license terms
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _my_xml_h
#define _my_xml_h
#ifdef __cplusplus
extern "C" {
#endif
#define MY_XML_OK 0
#define MY_XML_ERROR 1
/*
A flag whether to use absolute tag names in call-back functions,
like "a", "a.b" and "a.b.c" (used in character set file parser),
or relative names like "a", "b" and "c".
*/
#define MY_XML_FLAG_RELATIVE_NAMES 1
/*
A flag whether to skip normalization of text values before calling
call-back functions: i.e. skip leading/trailing spaces,
\r, \n, \t characters.
*/
#define MY_XML_FLAG_SKIP_TEXT_NORMALIZATION 2
enum my_xml_node_type
{
MY_XML_NODE_TAG, /* can have TAG, ATTR and TEXT children */
MY_XML_NODE_ATTR, /* can have TEXT children */
MY_XML_NODE_TEXT /* cannot have children */
};
typedef struct xml_stack_st
{
int flags;
enum my_xml_node_type current_node_type;
char errstr[128];
struct {
char static_buffer[128];
char *buffer;
size_t buffer_size;
char *start;
char *end;
} attr;
const char *beg;
const char *cur;
const char *end;
void *user_data;
int (*enter)(struct xml_stack_st *st,const char *val, size_t len);
int (*value)(struct xml_stack_st *st,const char *val, size_t len);
int (*leave_xml)(struct xml_stack_st *st,const char *val, size_t len);
int (*processing_instruction)(struct xml_stack_st *st,
const char *target, size_t target_len,
const char *value, size_t value_len);
} MY_XML_PARSER;
void my_xml_parser_create(MY_XML_PARSER *st);
void my_xml_parser_free(MY_XML_PARSER *st);
int my_xml_parse(MY_XML_PARSER *st,const char *str, size_t len);
void my_xml_set_value_handler(MY_XML_PARSER *st, int (*)(MY_XML_PARSER *,
const char *,
size_t len));
void my_xml_set_enter_handler(MY_XML_PARSER *st, int (*)(MY_XML_PARSER *,
const char *,
size_t len));
void my_xml_set_leave_handler(MY_XML_PARSER *st, int (*)(MY_XML_PARSER *,
const char *,
size_t len));
void my_xml_set_processing_instruction_handler(MY_XML_PARSER *st,
int (*)(MY_XML_PARSER *, const char *, size_t, const char *, size_t));
void my_xml_set_user_data(MY_XML_PARSER *st, void *);
size_t my_xml_error_pos(MY_XML_PARSER *st);
uint my_xml_error_lineno(MY_XML_PARSER *st);
const char *my_xml_error_string(MY_XML_PARSER *st);
#ifdef __cplusplus
}
#endif
#endif /* _my_xml_h */
PK ! _) *9 9 decimal.hnu [ /* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _decimal_h
#define _decimal_h
#ifdef __cplusplus
extern "C" {
#endif
typedef enum
{TRUNCATE=0, HALF_EVEN, HALF_UP, CEILING, FLOOR}
decimal_round_mode;
typedef int32 decimal_digit_t;
/**
intg is the number of *decimal* digits (NOT number of decimal_digit_t's !)
before the point
frac is the number of decimal digits after the point
len is the length of buf (length of allocated space) in decimal_digit_t's,
not in bytes
sign false means positive, true means negative
buf is an array of decimal_digit_t's
*/
typedef struct st_decimal_t {
int intg, frac, len;
my_bool sign;
decimal_digit_t *buf;
} decimal_t;
int internal_str2dec(const char *from, decimal_t *to, char **end,
my_bool fixed);
int decimal2string(const decimal_t *from, char *to, int *to_len,
decimal_digits_t fixed_precision,
decimal_digits_t fixed_decimals,
char filler);
int decimal2ulonglong(const decimal_t *from, ulonglong *to);
int ulonglong2decimal(ulonglong from, decimal_t *to);
int decimal2longlong(const decimal_t *from, longlong *to);
int longlong2decimal(longlong from, decimal_t *to);
int decimal2double(const decimal_t *from, double *to);
int double2decimal(double from, decimal_t *to);
decimal_digits_t decimal_actual_fraction(const decimal_t *from);
int decimal2bin(const decimal_t *from, uchar *to, decimal_digits_t precision,
decimal_digits_t scale);
int bin2decimal(const uchar *from, decimal_t *to, decimal_digits_t precision,
decimal_digits_t scale);
uint decimal_size(decimal_digits_t precision, decimal_digits_t scale);
uint decimal_bin_size(decimal_digits_t precision, decimal_digits_t scale);
uint decimal_result_size(decimal_t *from1, decimal_t *from2, char op,
int param);
decimal_digits_t decimal_intg(const decimal_t *from);
int decimal_add(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_sub(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_cmp(const decimal_t *from1, const decimal_t *from2);
int decimal_mul(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_div(const decimal_t *from1, const decimal_t *from2, decimal_t *to,
int scale_incr);
int decimal_mod(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_round(const decimal_t *from, decimal_t *to, int new_scale,
decimal_round_mode mode);
int decimal_is_zero(const decimal_t *from);
void max_decimal(decimal_digits_t precision, decimal_digits_t frac,
decimal_t *to);
#define string2decimal(A,B,C) internal_str2dec((A), (B), (C), 0)
#define string2decimal_fixed(A,B,C) internal_str2dec((A), (B), (C), 1)
/* set a decimal_t to zero */
#define decimal_make_zero(dec) do { \
(dec)->buf[0]=0; \
(dec)->intg=1; \
(dec)->frac=0; \
(dec)->sign=0; \
} while(0)
/*
returns the length of the buffer to hold string representation
of the decimal (including decimal dot, possible sign and \0)
*/
#define decimal_string_size(dec) (((dec)->intg ? (dec)->intg : 1) + \
(dec)->frac + ((dec)->frac > 0) + 2)
/* negate a decimal */
#define decimal_neg(dec) do { (dec)->sign^=1; } while(0)
/*
conventions:
decimal_smth() == 0 -- everything's ok
decimal_smth() <= 1 -- result is usable, but precision loss is possible
decimal_smth() <= 2 -- result can be unusable, most significant digits
could've been lost
decimal_smth() > 2 -- no result was generated
*/
#define E_DEC_OK 0
#define E_DEC_TRUNCATED 1
#define E_DEC_OVERFLOW 2
#define E_DEC_DIV_ZERO 4
#define E_DEC_BAD_NUM 8
#define E_DEC_OOM 16
#define E_DEC_ERROR 31
#define E_DEC_FATAL_ERROR 30
#ifdef __cplusplus
}
#endif
#endif
PK ! EC my_decimal_limits.hnu [ #ifndef MY_DECIMAL_LIMITS_INCLUDED
#define MY_DECIMAL_LIMITS_INCLUDED
/* Copyright (c) 2011 Monty Program Ab
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#define DECIMAL_LONGLONG_DIGITS 22
#define DECIMAL_LONG_DIGITS 10
#define DECIMAL_LONG3_DIGITS 8
/** maximum length of buffer in our big digits (uint32). */
#define DECIMAL_BUFF_LENGTH 9
/* the number of digits that my_decimal can possibly contain */
#define DECIMAL_MAX_POSSIBLE_PRECISION (DECIMAL_BUFF_LENGTH * 9)
/**
maximum guaranteed precision of number in decimal digits (number of our
digits * number of decimal digits in one our big digit - number of decimal
digits in one our big digit decreased by 1 (because we always put decimal
point on the border of our big digits))
With normal precision we can handle 65 digits. MariaDB can store in
the .frm up to 63 digits. By default we use DECIMAL_NOT_SPECIFIED digits
when converting strings to decimal, so we don't want to set this too high.
To not use up all digits for the scale we limit the number of decimals to
38.
*/
#define DECIMAL_MAX_PRECISION (DECIMAL_MAX_POSSIBLE_PRECISION - 8*2)
#define DECIMAL_MAX_SCALE 38
#define DECIMAL_NOT_SPECIFIED 39
/**
maximum length of string representation (number of maximum decimal
digits + 1 position for sign + 1 position for decimal point, no terminator)
*/
#define DECIMAL_MAX_STR_LENGTH (DECIMAL_MAX_POSSIBLE_PRECISION + 2)
#endif /* MY_DECIMAL_LIMITS_INCLUDED */
PK ! +1g sql_common.hnu [ #ifndef SQL_COMMON_INCLUDED
#define SQL_COMMON_INCLUDED
/* Copyright (c) 2003, 2018, Oracle and/or its affiliates.
Copyright (c) 2010, 2018, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifdef __cplusplus
extern "C" {
#endif
#include
#include
extern const char *unknown_sqlstate;
extern const char *cant_connect_sqlstate;
extern const char *not_error_sqlstate;
struct st_mysql_options_extention {
char *plugin_dir;
char *default_auth;
char *ssl_crl; /* PEM CRL file */
char *ssl_crlpath; /* PEM directory of CRL-s? */
void (*report_progress)(const MYSQL *mysql,
unsigned int stage,
unsigned int max_stage,
double progress,
const char *proc_info,
uint proc_info_length);
HASH connection_attributes;
size_t connection_attributes_length;
my_bool tls_allow_invalid_server_cert;
};
typedef struct st_mysql_methods
{
my_bool (*read_query_result)(MYSQL *mysql);
my_bool (*advanced_command)(MYSQL *mysql,
enum enum_server_command command,
const unsigned char *header,
unsigned long header_length,
const unsigned char *arg,
unsigned long arg_length,
my_bool skip_check,
MYSQL_STMT *stmt);
MYSQL_DATA *(*read_rows)(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
unsigned int fields);
MYSQL_RES * (*use_result)(MYSQL *mysql);
void (*fetch_lengths)(unsigned long *to,
MYSQL_ROW column, unsigned int field_count);
void (*flush_use_result)(MYSQL *mysql, my_bool flush_all_results);
int (*read_change_user_result)(MYSQL *mysql);
void (*on_close_free)(MYSQL *mysql);
#if !defined(MYSQL_SERVER) || defined(EMBEDDED_LIBRARY)
MYSQL_FIELD * (*list_fields)(MYSQL *mysql);
my_bool (*read_prepare_result)(MYSQL *mysql, MYSQL_STMT *stmt);
int (*stmt_execute)(MYSQL_STMT *stmt);
int (*read_binary_rows)(MYSQL_STMT *stmt);
int (*unbuffered_fetch)(MYSQL *mysql, char **row);
const char *(*read_statistics)(MYSQL *mysql);
my_bool (*next_result)(MYSQL *mysql);
int (*read_rows_from_cursor)(MYSQL_STMT *stmt);
#endif
} MYSQL_METHODS;
#ifdef LIBMARIADB
#define simple_command(mysql, command, arg, length, skip_check) ma_simple_command(mysql, command, (char *)arg, length, skip_check, NULL)
#else
#define simple_command(mysql, command, arg, length, skip_check) \
(*(mysql)->methods->advanced_command)(mysql, command, 0, \
0, arg, length, skip_check, NULL)
#endif
#define stmt_command(mysql, command, arg, length, stmt) \
(*(mysql)->methods->advanced_command)(mysql, command, 0, \
0, arg, length, 1, stmt)
extern CHARSET_INFO *default_client_charset_info;
MYSQL_FIELD *unpack_fields(MYSQL *mysql, MYSQL_DATA *data,MEM_ROOT *alloc,
uint fields, my_bool default_value,
uint server_capabilities);
void free_rows(MYSQL_DATA *cur);
void free_old_query(MYSQL *mysql);
void end_server(MYSQL *mysql);
my_bool mysql_reconnect(MYSQL *mysql);
void mysql_read_default_options(struct st_mysql_options *options,
const char *filename,const char *group);
my_bool
cli_advanced_command(MYSQL *mysql, enum enum_server_command command,
const unsigned char *header, ulong header_length,
const unsigned char *arg, ulong arg_length,
my_bool skip_check, MYSQL_STMT *stmt);
unsigned long cli_safe_read(MYSQL *mysql);
unsigned long cli_safe_read_reallen(MYSQL *mysql, ulong* reallen);
void net_clear_error(NET *net);
void set_stmt_errmsg(MYSQL_STMT *stmt, NET *net);
void set_stmt_error(MYSQL_STMT *stmt, int errcode, const char *sqlstate,
const char *err);
void set_mysql_error(MYSQL *mysql, int errcode, const char *sqlstate);
void set_mysql_extended_error(MYSQL *mysql, int errcode, const char *sqlstate,
const char *format, ...);
/* client side of the pluggable authentication */
struct st_vio;
struct st_plugin_vio_info;
void mpvio_info(struct st_vio *vio, struct st_plugin_vio_info *info);
int run_plugin_auth(MYSQL *mysql, char *data, uint data_len,
const char *data_plugin, const char *db);
int mysql_client_plugin_init();
void mysql_client_plugin_deinit();
struct st_mysql_client_plugin;
extern struct st_mysql_client_plugin *mysql_client_builtins[];
uchar * send_client_connect_attrs(MYSQL *mysql, uchar *buf);
#ifdef __cplusplus
}
#endif
#define protocol_41(A) ((A)->server_capabilities & CLIENT_PROTOCOL_41)
#endif /* SQL_COMMON_INCLUDED */
PK ! ؇m
typelib.hnu [ /* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
Copyright (c) 2017, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _typelib_h
#define _typelib_h
#include "my_alloc.h"
typedef struct st_typelib { /* Different types saved here */
unsigned int count; /* How many types */
const char *name; /* Name of typelib */
const char **type_names;
unsigned int *type_lengths;
/*
An array of indexes of enum values that are no longer supported and so are
hidden. One cannot specify hidden values, an attempt to do so will produce
a warning (while an attempt to use a name that was never part of this set
will produce an error).
*/
const int *hidden_values;
} TYPELIB;
#define CREATE_TYPELIB_FOR(X) { (unsigned int)(sizeof(X)/sizeof(X[0])) - 1, "", X, NULL, NULL }
extern my_ulonglong find_typeset(const char *x, TYPELIB *typelib,
int *error_position);
extern int find_type_with_warning(const char *x, TYPELIB *typelib,
const char *option);
#define FIND_TYPE_BASIC 0
/** makes @c find_type() require the whole name, no prefix */
#define FIND_TYPE_NO_PREFIX (1U << 0)
/** always implicitly on, so unused, but old code may pass it */
#define FIND_TYPE_NO_OVERWRITE 0
/** makes @c find_type() accept a number. Not used either */
#define FIND_TYPE_ALLOW_NUMBER 0
/** makes @c find_type() treat ',' and '=' as terminators */
#define FIND_TYPE_COMMA_TERM (1U << 3)
extern int find_type(const char *x, const TYPELIB *typelib, unsigned int flags);
extern void make_type(char *to,unsigned int nr,TYPELIB *typelib);
extern const char *get_type(TYPELIB *typelib,unsigned int nr);
extern TYPELIB *copy_typelib(MEM_ROOT *root, const TYPELIB *from);
extern TYPELIB sql_protocol_typelib;
my_ulonglong find_set_from_flags(const TYPELIB *lib, unsigned int default_name,
my_ulonglong cur_set, my_ulonglong default_set,
const char *str, unsigned int length,
char **err_pos, unsigned int *err_len);
#endif /* _typelib_h */
PK ! hX my_net.hnu [ /* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/*
This file is also used to make handling of sockets and ioctl()
portable across systems.
*/
#ifndef _my_net_h
#define _my_net_h
C_MODE_START
#include
#ifdef HAVE_SYS_SOCKET_H
#include
#endif
#ifdef HAVE_NETINET_IN_H
#include
#endif
#ifdef HAVE_ARPA_INET_H
#include
#endif
#if defined(HAVE_POLL_H)
#include
#elif defined(HAVE_SYS_POLL_H)
#include
#endif /* defined(HAVE_POLL_H) */
#ifdef HAVE_SYS_IOCTL_H
#include
#endif
#if !defined(_WIN32)
#include
#include
#include
#if !defined(alpha_linux_port)
#include
#endif
#endif
#if defined(_WIN32)
#define O_NONBLOCK 1 /* For emulation of fcntl() */
/*
SHUT_RDWR is called SD_BOTH in windows and
is defined to 2 in winsock2.h
#define SD_BOTH 0x02
*/
#define SHUT_RDWR 0x02
#else
#include /* getaddrinfo() & co */
#endif
/*
On OSes which don't have the in_addr_t, we guess that using uint32
is the best possible choice. We guess this from the fact that on
HP-UX64bit & FreeBSD64bit & Solaris64bit, in_addr_t is equivalent to
uint32. And on Linux32bit too.
*/
#ifndef HAVE_IN_ADDR_T
#define in_addr_t uint32
#endif
C_MODE_END
#endif
PK ! @! ! mysql_com_server.hnu [ /* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/*
Definitions private to the server,
used in the networking layer to notify specific events.
*/
#ifndef _mysql_com_server_h
#define _mysql_com_server_h
struct st_net_server;
typedef void (*before_header_callback_fn)
(struct st_net *net, void *user_data, size_t count);
typedef void (*after_header_callback_fn)
(struct st_net *net, void *user_data, size_t count, my_bool rc);
struct st_net_server
{
before_header_callback_fn m_before_header;
after_header_callback_fn m_after_header;
void *m_user_data;
};
typedef struct st_net_server NET_SERVER;
#endif
PK ! Nk9 9 errmsg.hnu [ #ifndef ERRMSG_INCLUDED
#define ERRMSG_INCLUDED
/* Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/*
Error messages numbers for MySQL clients.
The error messages itself are in libmysql/errmsg.c
Error messages for the mysqld daemon are in sql/share/errmsg.txt
*/
#ifdef __cplusplus
extern "C" {
#endif
void init_client_errs(void);
void finish_client_errs(void);
extern const char *client_errors[]; /* Error messages */
#ifdef __cplusplus
}
#endif
#define CR_MIN_ERROR 2000 /* For easier client code */
#define CR_MAX_ERROR 2999
#if !defined(ER)
#define ER(X) (((X) >= CR_ERROR_FIRST && (X) <= CR_ERROR_LAST) \
? client_errors[(X)-CR_ERROR_FIRST] \
: client_errors[CR_UNKNOWN_ERROR-CR_ERROR_FIRST])
#endif
#define CLIENT_ERRMAP 2 /* Errormap used by my_error() */
/* Do not add error numbers before CR_ERROR_FIRST. */
/* If necessary to add lower numbers, change CR_ERROR_FIRST accordingly. */
#define CR_ERROR_FIRST 2000 /*Copy first error nr.*/
#define CR_UNKNOWN_ERROR 2000
#define CR_SOCKET_CREATE_ERROR 2001
#define CR_CONNECTION_ERROR 2002
#define CR_CONN_HOST_ERROR 2003
#define CR_IPSOCK_ERROR 2004
#define CR_UNKNOWN_HOST 2005
#define CR_SERVER_GONE_ERROR 2006
#define CR_VERSION_ERROR 2007
#define CR_OUT_OF_MEMORY 2008
#define CR_WRONG_HOST_INFO 2009
#define CR_LOCALHOST_CONNECTION 2010
#define CR_TCP_CONNECTION 2011
#define CR_SERVER_HANDSHAKE_ERR 2012
#define CR_SERVER_LOST 2013
#define CR_COMMANDS_OUT_OF_SYNC 2014
#define CR_NAMEDPIPE_CONNECTION 2015
#define CR_NAMEDPIPEWAIT_ERROR 2016
#define CR_NAMEDPIPEOPEN_ERROR 2017
#define CR_NAMEDPIPESETSTATE_ERROR 2018
#define CR_CANT_READ_CHARSET 2019
#define CR_NET_PACKET_TOO_LARGE 2020
#define CR_EMBEDDED_CONNECTION 2021
#define CR_PROBE_SLAVE_STATUS 2022
#define CR_PROBE_SLAVE_HOSTS 2023
#define CR_PROBE_SLAVE_CONNECT 2024
#define CR_PROBE_MASTER_CONNECT 2025
#define CR_SSL_CONNECTION_ERROR 2026
#define CR_MALFORMED_PACKET 2027
#define CR_WRONG_LICENSE 2028
/* new 4.1 error codes */
#define CR_NULL_POINTER 2029
#define CR_NO_PREPARE_STMT 2030
#define CR_PARAMS_NOT_BOUND 2031
#define CR_DATA_TRUNCATED 2032
#define CR_NO_PARAMETERS_EXISTS 2033
#define CR_INVALID_PARAMETER_NO 2034
#define CR_INVALID_BUFFER_USE 2035
#define CR_UNSUPPORTED_PARAM_TYPE 2036
#define CR_SHARED_MEMORY_CONNECTION 2037
#define CR_SHARED_MEMORY_CONNECT_REQUEST_ERROR 2038
#define CR_SHARED_MEMORY_CONNECT_ANSWER_ERROR 2039
#define CR_SHARED_MEMORY_CONNECT_FILE_MAP_ERROR 2040
#define CR_SHARED_MEMORY_CONNECT_MAP_ERROR 2041
#define CR_SHARED_MEMORY_FILE_MAP_ERROR 2042
#define CR_SHARED_MEMORY_MAP_ERROR 2043
#define CR_SHARED_MEMORY_EVENT_ERROR 2044
#define CR_SHARED_MEMORY_CONNECT_ABANDONED_ERROR 2045
#define CR_SHARED_MEMORY_CONNECT_SET_ERROR 2046
#define CR_CONN_UNKNOW_PROTOCOL 2047
#define CR_INVALID_CONN_HANDLE 2048
#define CR_SECURE_AUTH 2049
#define CR_FETCH_CANCELED 2050
#define CR_NO_DATA 2051
#define CR_NO_STMT_METADATA 2052
#define CR_NO_RESULT_SET 2053
#define CR_NOT_IMPLEMENTED 2054
#define CR_SERVER_LOST_EXTENDED 2055
#define CR_STMT_CLOSED 2056
#define CR_NEW_STMT_METADATA 2057
#define CR_ALREADY_CONNECTED 2058
#define CR_AUTH_PLUGIN_CANNOT_LOAD 2059
#define CR_DUPLICATE_CONNECTION_ATTR 2060
#define CR_AUTH_PLUGIN_ERR 2061
#define CR_ERROR_LAST /*Copy last error nr:*/ 2061
/* Add error numbers before CR_ERROR_LAST and change it accordingly. */
#endif /* ERRMSG_INCLUDED */
PK ! KĆ
sslopt-vars.hnu [ #ifndef SSLOPT_VARS_INCLUDED
#define SSLOPT_VARS_INCLUDED
/* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
#ifdef SSL_VARS_NOT_STATIC
#define SSL_STATIC
#else
#define SSL_STATIC static
#endif
SSL_STATIC my_bool opt_use_ssl = 1;
SSL_STATIC char *opt_ssl_ca = 0;
SSL_STATIC char *opt_ssl_capath = 0;
SSL_STATIC char *opt_ssl_cert = 0;
SSL_STATIC char *opt_ssl_cipher = 0;
SSL_STATIC char *opt_ssl_key = 0;
SSL_STATIC char *opt_ssl_crl = 0;
SSL_STATIC char *opt_ssl_crlpath = 0;
SSL_STATIC char *opt_tls_version = 0;
#ifdef MYSQL_CLIENT
SSL_STATIC char *opt_ssl_fp = 0;
SSL_STATIC char *opt_ssl_fplist = 0;
SSL_STATIC my_bool opt_ssl_verify_server_cert= 2;
#define SET_SSL_OPTS(M) \
do { \
if (opt_use_ssl) \
{ \
mysql_ssl_set((M), opt_ssl_key, opt_ssl_cert, opt_ssl_ca, \
opt_ssl_capath, opt_ssl_cipher); \
mysql_options((M), MYSQL_OPT_SSL_CRL, opt_ssl_crl); \
mysql_options((M), MYSQL_OPT_SSL_CRLPATH, opt_ssl_crlpath); \
mysql_options((M), MARIADB_OPT_TLS_VERSION, opt_tls_version); \
mysql_options((M), MARIADB_OPT_TLS_PEER_FP, opt_ssl_fp); \
mysql_options((M), MARIADB_OPT_TLS_PEER_FP_LIST, opt_ssl_fplist); \
} \
else \
opt_ssl_verify_server_cert= 0; \
mysql_options((M),MYSQL_OPT_SSL_VERIFY_SERVER_CERT, \
&opt_ssl_verify_server_cert); \
} while(0)
/*
let's disable opt_ssl_verify_server_cert if neither CA nor FP and
nor password were specified and the protocol is TCP.
*/
#define SET_SSL_OPTS_WITH_CHECK(M) \
do { \
if (opt_use_ssl && opt_ssl_verify_server_cert==2 && \
!(opt_ssl_ca && opt_ssl_ca[0]) && \
!(opt_ssl_capath && opt_ssl_capath[0]) && \
!(opt_ssl_fp && opt_ssl_fp[0]) && \
!(opt_ssl_fplist && opt_ssl_fplist[0]) && \
!(opt_password && opt_password[0]) && \
opt_protocol == MYSQL_PROTOCOL_TCP) \
{ \
fprintf(stderr, "WARNING: option --ssl-verify-server-cert is " \
"disabled, because of an insecure passwordless login.\n");\
opt_ssl_verify_server_cert= 0; \
} \
SET_SSL_OPTS(M); \
} while (0)
#endif
#else
#define SET_SSL_OPTS(M) do { } while(0)
#define SET_SSL_OPTS_WITH_CHECK(M) do { } while(0)
#endif
#endif /* SSLOPT_VARS_INCLUDED */
PK ! J6& & my_dbug.hnu [ /* Copyright (c) 2000, 2010, Oracle and/or its affiliates.
Copyright (C) 2000, 2019, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _my_dbug_h
#define _my_dbug_h
#ifndef _WIN32
#include
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if !defined(DBUG_OFF)
struct _db_stack_frame_ {
const char *func; /* function name of the previous stack frame */
const char *file; /* filename of the function of previous frame */
uint level; /* this nesting level, highest bit enables tracing */
int line; /* line of DBUG_RETURN */
struct _db_stack_frame_ *prev; /* pointer to the previous frame */
};
struct _db_code_state_;
extern my_bool _dbug_on_;
extern my_bool _db_keyword_(struct _db_code_state_ *, const char *, int);
extern int _db_explain_(struct _db_code_state_ *cs, char *buf, size_t len);
extern int _db_explain_init_(char *buf, size_t len);
extern int _db_is_pushed_(void);
extern void _db_setjmp_(void);
extern void _db_longjmp_(void);
extern void _db_process_(const char *name);
extern void _db_push_(const char *control);
extern void _db_pop_(void);
extern void _db_set_(const char *control);
extern void _db_set_init_(const char *control);
extern void _db_enter_(const char *_func_, const char *_file_, uint _line_,
struct _db_stack_frame_ *_stack_frame_);
extern void _db_return_(struct _db_stack_frame_ *_stack_frame_);
extern int _db_pargs_(uint _line_,const char *keyword);
extern void _db_doprnt_(const char *format,...)
#ifdef WAITING_FOR_BUGFIX_TO_VSPRINTF
ATTRIBUTE_FORMAT(printf, 1, 2)
#endif
;
extern void _db_dump_(uint _line_,const char *keyword,
const unsigned char *memory, size_t length);
extern void _db_end_(void);
extern void _db_lock_file_(void);
extern void _db_unlock_file_(void);
ATTRIBUTE_COLD
extern my_bool _db_my_assert(const char *file, int line, const char *msg);
extern FILE *_db_fp_(void);
extern void _db_flush_(void);
extern void dbug_swap_code_state(void **code_state_store);
extern void dbug_free_code_state(void **code_state_store);
extern const char* _db_get_func_(void);
extern int (*dbug_sanity)(void);
#ifdef DBUG_TRACE
#define DBUG_LEAVE do { \
_db_stack_frame_.line= __LINE__; \
_db_return_ (&_db_stack_frame_); \
_db_stack_frame_.line= 0; \
} while(0)
#define DBUG_PRINT(keyword,arglist) \
do if (_db_pargs_(__LINE__,keyword)) _db_doprnt_ arglist; while(0)
#define DBUG_DUMP(keyword,a1,a2) _db_dump_(__LINE__,keyword,a1,a2)
#ifdef HAVE_ATTRIBUTE_CLEANUP
#define DBUG_ENTER(a) struct _db_stack_frame_ _db_stack_frame_ __attribute__((cleanup(_db_return_))); \
_db_enter_ (a,__FILE__,__LINE__,&_db_stack_frame_)
#define DBUG_RETURN(a1) do { _db_stack_frame_.line=__LINE__; return(a1);} while(0)
#define DBUG_VOID_RETURN do { _db_stack_frame_.line=__LINE__; return;} while(0)
#else
#define DBUG_ENTER(a) struct _db_stack_frame_ _db_stack_frame_; \
_db_enter_ (a,__FILE__,__LINE__,&_db_stack_frame_)
#define DBUG_RETURN(a1) do {DBUG_LEAVE; return(a1);} while(0)
#define DBUG_VOID_RETURN do {DBUG_LEAVE; return;} while(0)
#endif
#else
#define DBUG_LEAVE
#define DBUG_ENTER(a)
#define DBUG_RETURN(a1) return(a1)
#define DBUG_VOID_RETURN return
#define DBUG_PRINT(keyword,arglist) do{} while(0)
#define DBUG_DUMP(keyword,a1,a2) do{} while(0)
#endif
#define DBUG_EXECUTE(keyword,a1) \
do {if (_db_keyword_(0, (keyword), 0)) { a1 }} while(0)
#define DBUG_EXECUTE_IF(keyword,a1) \
do {if (_db_keyword_(0, (keyword), 1)) { a1 }} while(0)
#define DBUG_IF(keyword) _db_keyword_(0, (keyword), 1)
#define DBUG_PUSH_EMPTY if (_dbug_on_) { DBUG_PUSH(""); }
#define DBUG_POP_EMPTY if (_dbug_on_) { DBUG_POP(); }
#define DBUG_PUSH(a1) _db_push_ (a1)
#define DBUG_POP() _db_pop_ ()
#define DBUG_SET(a1) _db_set_ (a1)
#define DBUG_SET_INITIAL(a1) _db_set_init_ (a1)
#define DBUG_PROCESS(a1) _db_process_(a1)
#define DBUG_FILE _db_fp_()
#define DBUG_END() _db_end_ ()
#define DBUG_LOCK_FILE _db_lock_file_()
#define DBUG_UNLOCK_FILE _db_unlock_file_()
#define DBUG_ASSERT(A) do { \
if (unlikely(!(A)) && _db_my_assert(__FILE__, __LINE__, #A)) assert(A); \
} while (0)
#define DBUG_SLOW_ASSERT(A) DBUG_ASSERT(A)
#define DBUG_ASSERT_EXISTS
#define DBUG_EXPLAIN(buf,len) _db_explain_(0, (buf),(len))
#define DBUG_EXPLAIN_INITIAL(buf,len) _db_explain_init_((buf),(len))
#define DEBUGGER_OFF do { _dbug_on_= 0; } while(0)
#define DEBUGGER_ON do { _dbug_on_= 1; } while(0)
#define IF_DBUG(A,B) A
#define IF_DBUG_ASSERT(A,B) A
#define DBUG_SWAP_CODE_STATE(arg) dbug_swap_code_state(arg)
#define DBUG_FREE_CODE_STATE(arg) dbug_free_code_state(arg)
#undef DBUG_ASSERT_AS_PRINTF
#ifndef _WIN32
#define DBUG_ABORT() (_db_flush_(), abort())
#else
/*
Avoid popup with abort/retry/ignore buttons. When BUG#31745 is fixed we can
call abort() instead of _exit(3) (now it would cause a "test signal" popup).
*/
#include
#define DBUG_ABORT() (_db_flush_(),\
(void)_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE),\
(void)_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR),\
TerminateProcess(GetCurrentProcess(),3))
#endif
/*
Make the program fail, without creating a core file.
abort() will send SIGABRT which (most likely) generates core.
Use SIGKILL instead, which cannot be caught.
We also pause the current thread, until the signal is actually delivered.
An alternative would be to use _exit(EXIT_FAILURE),
but then valgrind would report lots of memory leaks.
*/
#ifdef _WIN32
#define DBUG_SUICIDE() DBUG_ABORT()
#else
extern void _db_suicide_(void);
#define DBUG_SUICIDE() (_db_flush_(), _db_suicide_())
#endif /* _WIN32 */
#else /* No debugger */
#define DBUG_ENTER(a1)
#define DBUG_VIOLATION_HELPER_LEAVE do { } while(0)
#define DBUG_LEAVE
#define DBUG_RETURN(a1) do { return(a1); } while(0)
#define DBUG_VOID_RETURN do { return; } while(0)
#define DBUG_PRINT(keyword, arglist) do { } while(0)
#define DBUG_EXECUTE(keyword,a1) do { } while(0)
#define DBUG_EXECUTE_IF(keyword,a1) do { } while(0)
#define DBUG_IF(keyword) 0
#define DBUG_PRINT(keyword,arglist) do { } while(0)
#define DBUG_PUSH_EMPTY do { } while(0)
#define DBUG_POP_EMPTY do { } while(0)
#define DBUG_PUSH(a1) do { } while(0)
#define DBUG_SET(a1) do { } while(0)
#define DBUG_SET_INITIAL(a1) do { } while(0)
#define DBUG_POP() do { } while(0)
#define DBUG_PROCESS(a1) do { } while(0)
#define DBUG_DUMP(keyword,a1,a2) do { } while(0)
#define DBUG_END() do { } while(0)
#define DBUG_SLOW_ASSERT(A) do { } while(0)
#define DBUG_LOCK_FILE do { } while(0)
#define DBUG_FILE (stderr)
#define DBUG_UNLOCK_FILE do { } while(0)
#define DBUG_EXPLAIN(buf,len)
#define DBUG_EXPLAIN_INITIAL(buf,len)
#define DEBUGGER_OFF do { } while(0)
#define DEBUGGER_ON do { } while(0)
#define IF_DBUG(A,B) B
#define DBUG_SWAP_CODE_STATE(arg) do { } while(0)
#define DBUG_FREE_CODE_STATE(arg) do { } while(0)
#define DBUG_ABORT() do { } while(0)
#define DBUG_CRASH_ENTER(func)
#define DBUG_CRASH_RETURN(val) do { return(val); } while(0)
#define DBUG_CRASH_VOID_RETURN do { return; } while(0)
#define DBUG_SUICIDE() ((void) 0)
#ifdef DBUG_ASSERT_AS_PRINTF
extern void (*my_dbug_assert_failed)(const char *assert_expr, const char* file, unsigned long line);
#define DBUG_ASSERT(assert_expr) do { if (!(assert_expr)) { my_dbug_assert_failed(#assert_expr, __FILE__, __LINE__); }} while (0)
#define DBUG_ASSERT_EXISTS
#define IF_DBUG_ASSERT(A,B) A
#else
#define DBUG_ASSERT(A) do { } while(0)
#define IF_DBUG_ASSERT(A,B) B
#endif /* DBUG_ASSERT_AS_PRINTF */
#endif /* !defined(DBUG_OFF) */
#ifdef EXTRA_DEBUG
/**
Sync points allow us to force the server to reach a certain line of code
and block there until the client tells the server it is ok to go on.
The client tells the server to block with SELECT GET_LOCK()
and unblocks it with SELECT RELEASE_LOCK(). Used for debugging difficult
concurrency problems
*/
#define DBUG_SYNC_POINT(lock_name,lock_timeout) \
debug_sync_point(lock_name,lock_timeout)
void debug_sync_point(const char* lock_name, uint lock_timeout);
#else
#define DBUG_SYNC_POINT(lock_name,lock_timeout)
#endif /* EXTRA_DEBUG */
#ifdef __cplusplus
}
/*
DBUG_LOG() was initially intended for InnoDB. To be able to use it elsewhere
one should #include . We intentionally avoid including it here to save
compilation time.
*/
# if defined DBUG_OFF || !defined DBUG_TRACE
# define DBUG_LOG(keyword, v) do {} while (0)
# else
# define DBUG_LOG(keyword, v) do { \
if (_db_pargs_(__LINE__, keyword)) { \
std::ostringstream _db_s; _db_s << v; \
_db_doprnt_("%s", _db_s.str().c_str()); \
}} while (0)
# endif
#endif
#endif /* _my_dbug_h */
PK ! *;2
my_alloc.hnu [ /* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/*
Data structures for mysys/my_alloc.c (root memory allocator)
*/
#ifndef _my_alloc_h
#define _my_alloc_h
#include "mysql/psi/psi_base.h"
#define ALLOC_MAX_BLOCK_TO_DROP 4096
#define ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP 10
#define ROOT_FLAG_READ_ONLY 4
#ifdef __cplusplus
extern "C" {
#endif
typedef struct st_used_mem
{ /* struct for once_alloc (block) */
struct st_used_mem *next; /* Next block in use */
size_t left; /* memory left in block */
size_t size; /* size of block */
} USED_MEM;
typedef struct st_mem_root
{
USED_MEM *free; /* blocks with free memory in it */
USED_MEM *used; /* blocks almost without free memory */
USED_MEM *pre_alloc; /* preallocated block */
/* if block have less memory it will be put in 'used' list */
size_t min_malloc;
size_t block_size; /* initial block size */
unsigned int block_num; /* allocated blocks counter */
/*
first free block in queue test counter (if it exceed
MAX_BLOCK_USAGE_BEFORE_DROP block will be dropped in 'used' list)
*/
unsigned short first_block_usage;
unsigned short flags;
void (*error_handler)(void);
PSI_memory_key psi_key;
} MEM_ROOT;
#ifdef __cplusplus
}
#endif
#endif
PK ! *$ my_getopt.hnu [ /*
Copyright (c) 2002, 2013, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _my_getopt_h
#define _my_getopt_h
#include "my_sys.h" /* loglevel */
/* my_getopt and my_default are almost always used together */
#include
C_MODE_START
#define GET_NO_ARG 1
#define GET_BOOL 2
#define GET_INT 3
#define GET_UINT 4
#define GET_LONG 5
#define GET_ULONG 6
#define GET_LL 7
#define GET_ULL 8
#define GET_STR 9
#define GET_STR_ALLOC 10
#define GET_DISABLED 11
#define GET_ENUM 12
#define GET_SET 13
#define GET_DOUBLE 14
#define GET_FLAGSET 15
#define GET_BIT 16
#define GET_ASK_ADDR 128
#define GET_AUTO 64
#define GET_TYPE_MASK 63
/**
Enumeration of the my_option::arg_type attributes.
It should be noted that for historical reasons variables with the combination
arg_type=NO_ARG, my_option::var_type=GET_BOOL still accepts
arguments. This is someone counter intuitive and care should be taken
if the code is refactored.
*/
enum get_opt_arg_type { NO_ARG, OPT_ARG, REQUIRED_ARG };
struct st_typelib;
struct my_option
{
const char *name; /**< Name of the option. name=NULL
marks the end of the my_option[]
array.
*/
int id; /**< For 0255 no short option
is created, but a long option still
can be identified uniquely in the
my_get_one_option() callback.
If an opton needs neither special
treatment in the my_get_one_option()
nor one-letter short equivalent
use id=0
*/
const char *comment; /**< option comment, for autom. --help.
if it's NULL the option is not
visible in --help.
*/
void *value; /**< A pointer to the variable value */
void *u_max_value; /**< The user def. max variable value */
struct st_typelib *typelib; /**< Pointer to possible values */
ulong var_type; /**< GET_BOOL, GET_ULL, etc */
enum get_opt_arg_type arg_type; /**< e.g. REQUIRED_ARG or OPT_ARG */
longlong def_value; /**< Default value */
longlong min_value; /**< Min allowed value (for numbers) */
ulonglong max_value; /**< Max allowed value (for numbers) */
longlong sub_size; /**< Unused */
long block_size; /**< Value should be a mult. of this (for numbers) */
void *app_type; /**< To be used by an application */
};
typedef my_bool (*my_get_one_option)(const struct my_option *, const char *, const char *);
/**
Used to retrieve a reference to the object (variable) that holds the value
for the given option. For example, if var_type is GET_UINT, the function
must return a pointer to a variable of type uint. A argument is stored in
the location pointed to by the returned pointer.
*/
typedef void *(*my_getopt_value)(const char *, uint, const struct my_option *,
int *);
extern char *disabled_my_option;
extern char *autoset_my_option;
extern my_bool my_getopt_print_errors;
extern my_bool my_getopt_skip_unknown;
extern my_bool my_getopt_prefix_matching;
extern my_bool my_handle_options_init_variables;
extern my_error_reporter my_getopt_error_reporter;
extern my_getopt_value my_getopt_get_addr;
extern int handle_options (int *argc, char ***argv,
const struct my_option *longopts, my_get_one_option)
__attribute__((nonnull));
extern void my_cleanup_options(const struct my_option *options);
extern void my_print_help(const struct my_option *options);
extern void my_print_variables(const struct my_option *options);
ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp,
my_bool *fix);
longlong getopt_ll_limit_value(longlong, const struct my_option *,
my_bool *fix);
double getopt_double_limit_value(double num, const struct my_option *optp,
my_bool *fix);
ulonglong getopt_double2ulonglong(double);
double getopt_ulonglong2double(ulonglong);
C_MODE_END
#endif /* _my_getopt_h */
PK ! Ow/ / private/sql_trigger.hnu [ #ifndef SQL_TRIGGER_INCLUDED
#define SQL_TRIGGER_INCLUDED
/*
Copyright (c) 2004, 2011, Oracle and/or its affiliates.
Copyright (c) 2017, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#include
/* Forward declarations */
class Item_trigger_field;
class sp_head;
class sp_name;
class Query_tables_list;
struct TABLE_LIST;
class Query_tables_list;
typedef struct st_ddl_log_state DDL_LOG_STATE;
/** Event on which trigger is invoked. */
enum trg_event_type
{
TRG_EVENT_INSERT= 0,
TRG_EVENT_UPDATE= 1,
TRG_EVENT_DELETE= 2,
TRG_EVENT_MAX
};
static inline uint8 trg2bit(enum trg_event_type trg)
{ return static_cast(1 << static_cast(trg)); }
#include "table.h" /* GRANT_INFO */
/*
We need this two enums here instead of sql_lex.h because
at least one of them is used by Item_trigger_field interface.
Time when trigger is invoked (i.e. before or after row actually
inserted/updated/deleted).
*/
enum trg_action_time_type
{
TRG_ACTION_BEFORE= 0, TRG_ACTION_AFTER= 1, TRG_ACTION_MAX
};
enum trigger_order_type
{
TRG_ORDER_NONE= 0,
TRG_ORDER_FOLLOWS= 1,
TRG_ORDER_PRECEDES= 2
};
struct st_trg_execution_order
{
/**
FOLLOWS or PRECEDES as specified in the CREATE TRIGGER statement.
*/
enum trigger_order_type ordering_clause;
/**
Trigger name referenced in the FOLLOWS/PRECEDES clause of the
CREATE TRIGGER statement.
*/
LEX_CSTRING anchor_trigger_name;
};
/*
Parameter to change_table_name_in_triggers()
*/
class TRIGGER_RENAME_PARAM
{
public:
TABLE table;
bool upgrading50to51;
bool got_error;
TRIGGER_RENAME_PARAM()
{
upgrading50to51= got_error= 0;
table.reset();
}
~TRIGGER_RENAME_PARAM()
{
reset();
}
void reset();
};
class Table_triggers_list;
/**
The trigger object
*/
class Trigger :public Sql_alloc
{
public:
Trigger(Table_triggers_list *base_arg, sp_head *code):
base(base_arg), body(code), next(0), action_order(0)
{
bzero((char *)&subject_table_grants, sizeof(subject_table_grants));
}
~Trigger();
Table_triggers_list *base;
sp_head *body;
Trigger *next; /* Next trigger of same type */
LEX_CSTRING name;
LEX_CSTRING on_table_name; /* Raw table name */
LEX_CSTRING definition;
LEX_CSTRING definer;
/* Character sets used */
LEX_CSTRING client_cs_name;
LEX_CSTRING connection_cl_name;
LEX_CSTRING db_cl_name;
GRANT_INFO subject_table_grants;
sql_mode_t sql_mode;
/* Store create time. Can't be mysql_time_t as this holds also sub seconds */
my_hrtime_t hr_create_time; // Create time timestamp in microseconds
trg_event_type event;
trg_action_time_type action_time;
uint action_order;
void get_trigger_info(LEX_CSTRING *stmt, LEX_CSTRING *body,
LEX_STRING *definer);
/* Functions executed over each active trigger */
bool change_on_table_name(void* param_arg);
bool change_table_name(void* param_arg);
bool add_to_file_list(void* param_arg);
};
typedef bool (Trigger::*Triggers_processor)(void *arg);
/**
This class holds all information about triggers of table.
*/
class Table_triggers_list: public Sql_alloc
{
friend class Trigger;
/* Points to first trigger for a certain type */
Trigger *triggers[TRG_EVENT_MAX][TRG_ACTION_MAX];
/**
Copy of TABLE::Field array which all fields made nullable
(using extra_null_bitmap, if needed). Used for NEW values in
BEFORE INSERT/UPDATE triggers.
*/
Field **record0_field;
uchar *extra_null_bitmap, *extra_null_bitmap_init;
/**
Copy of TABLE::Field array with field pointers set to TABLE::record[1]
buffer instead of TABLE::record[0] (used for OLD values in on UPDATE
trigger and DELETE trigger when it is called for REPLACE).
*/
Field **record1_field;
/**
During execution of trigger new_field and old_field should point to the
array of fields representing new or old version of row correspondingly
(so it can point to TABLE::field or to Tale_triggers_list::record1_field)
*/
Field **new_field;
Field **old_field;
/* TABLE instance for which this triggers list object was created */
TABLE *trigger_table;
/**
This flag indicates that one of the triggers was not parsed successfully,
and as a precaution the object has entered a state where all trigger
access results in errors until all such triggers are dropped. It is not
safe to add triggers since we don't know if the broken trigger has the
same name or event type. Nor is it safe to invoke any trigger for the
aforementioned reasons. The only safe operations are drop_trigger and
drop_all_triggers.
@see Table_triggers_list::set_parse_error
*/
bool m_has_unparseable_trigger;
/**
This error will be displayed when the user tries to manipulate or invoke
triggers on a table that has broken triggers. It will get set only once
per statement and thus will contain the first parse error encountered in
the trigger file.
*/
char m_parse_error_message[MYSQL_ERRMSG_SIZE];
uint count; /* Number of triggers */
public:
/**
Field responsible for storing triggers definitions in file.
It have to be public because we are using it directly from parser.
*/
List definitions_list;
/**
List of sql modes for triggers
*/
List definition_modes_list;
/** Create times for triggers */
List hr_create_times;
List definers_list;
/* Character set context, used for parsing and executing triggers. */
List client_cs_names;
List connection_cl_names;
List db_cl_names;
/* End of character ser context. */
Table_triggers_list(TABLE *table_arg)
:record0_field(0), extra_null_bitmap(0), extra_null_bitmap_init(0),
record1_field(0), trigger_table(table_arg),
m_has_unparseable_trigger(false), count(0)
{
bzero((char *) triggers, sizeof(triggers));
}
~Table_triggers_list();
bool create_trigger(THD *thd, TABLE_LIST *table, String *stmt_query,
DDL_LOG_STATE *ddl_log_state,
DDL_LOG_STATE *ddl_log_state_tmp_file);
bool drop_trigger(THD *thd, TABLE_LIST *table,
LEX_CSTRING *sp_name,
String *stmt_query, DDL_LOG_STATE *ddl_log_state);
bool process_triggers(THD *thd, trg_event_type event,
trg_action_time_type time_type,
bool old_row_is_record1);
void empty_lists();
bool create_lists_needed_for_files(MEM_ROOT *root);
bool save_trigger_file(THD *thd, const LEX_CSTRING *db, const LEX_CSTRING *table_name);
static bool check_n_load(THD *thd, const LEX_CSTRING *db, const LEX_CSTRING *table_name,
TABLE *table, bool names_only);
static bool drop_all_triggers(THD *thd, const LEX_CSTRING *db,
const LEX_CSTRING *table_name, myf MyFlags);
static bool prepare_for_rename(THD *thd, TRIGGER_RENAME_PARAM *param,
const LEX_CSTRING *db,
const LEX_CSTRING *old_alias,
const LEX_CSTRING *old_table,
const LEX_CSTRING *new_db,
const LEX_CSTRING *new_table);
static bool change_table_name(THD *thd, TRIGGER_RENAME_PARAM *param,
const LEX_CSTRING *db,
const LEX_CSTRING *old_alias,
const LEX_CSTRING *old_table,
const LEX_CSTRING *new_db,
const LEX_CSTRING *new_table);
void add_trigger(trg_event_type event_type,
trg_action_time_type action_time,
trigger_order_type ordering_clause,
LEX_CSTRING *anchor_trigger_name,
Trigger *trigger);
Trigger *get_trigger(trg_event_type event_type,
trg_action_time_type action_time)
{
return triggers[event_type][action_time];
}
/* Simpler version of the above, to avoid casts in the code */
Trigger *get_trigger(uint event_type, uint action_time)
{
return get_trigger((trg_event_type) event_type,
(trg_action_time_type) action_time);
}
bool has_triggers(trg_event_type event_type,
trg_action_time_type action_time)
{
return get_trigger(event_type,action_time) != 0;
}
bool has_delete_triggers()
{
return (has_triggers(TRG_EVENT_DELETE,TRG_ACTION_BEFORE) ||
has_triggers(TRG_EVENT_DELETE,TRG_ACTION_AFTER));
}
void mark_fields_used(trg_event_type event);
void set_parse_error_message(char *error_message);
friend class Item_trigger_field;
bool add_tables_and_routines_for_triggers(THD *thd,
Query_tables_list *prelocking_ctx,
TABLE_LIST *table_list);
Field **nullable_fields() { return record0_field; }
void clear_extra_null_bitmap()
{
if (size_t null_bytes= extra_null_bitmap_init - extra_null_bitmap)
bzero(extra_null_bitmap, null_bytes);
}
void default_extra_null_bitmap()
{
if (size_t null_bytes= extra_null_bitmap_init - extra_null_bitmap)
memcpy(extra_null_bitmap, extra_null_bitmap_init, null_bytes);
}
Trigger *find_trigger(const LEX_CSTRING *name, bool remove_from_list);
Trigger* for_all_triggers(Triggers_processor func, void *arg);
private:
bool prepare_record_accessors(TABLE *table);
Trigger *change_table_name_in_trignames(const LEX_CSTRING *old_db_name,
const LEX_CSTRING *new_db_name,
const LEX_CSTRING *new_table_name,
Trigger *trigger);
bool change_table_name_in_triggers(THD *thd,
const LEX_CSTRING *old_db_name,
const LEX_CSTRING *new_db_name,
const LEX_CSTRING *old_table_name,
const LEX_CSTRING *new_table_name);
bool check_for_broken_triggers()
{
if (m_has_unparseable_trigger)
{
my_message(ER_PARSE_ERROR, m_parse_error_message, MYF(0));
return true;
}
return false;
}
public:
TABLE *get_subject_table()
{
return trigger_table;
}
};
bool add_table_for_trigger(THD *thd,
const sp_name *trg_name,
bool continue_if_not_exist,
TABLE_LIST **table);
void build_trn_path(THD *thd, const sp_name *trg_name, LEX_STRING *trn_path);
bool check_trn_exists(const LEX_CSTRING *trn_path);
bool load_table_name_for_trigger(THD *thd,
const sp_name *trg_name,
const LEX_CSTRING *trn_path,
LEX_CSTRING *tbl_name);
bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create);
bool rm_trigname_file(char *path, const LEX_CSTRING *db,
const LEX_CSTRING *trigger_name, myf MyFlags);
extern const char * const TRG_EXT;
extern const char * const TRN_EXT;
#endif /* SQL_TRIGGER_INCLUDED */
PK ! \9ޝ private/sql_crypt.hnu [ #ifndef SQL_CRYPT_INCLUDED
#define SQL_CRYPT_INCLUDED
/* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifdef USE_PRAGMA_INTERFACE
#pragma interface /* gcc class implementation */
#endif
#include "sql_alloc.h" /* Sql_alloc */
#include "my_rnd.h" /* rand_struct */
class SQL_CRYPT :public Sql_alloc
{
struct my_rnd_struct rand,org_rand;
char decode_buff[256],encode_buff[256];
uint shift;
public:
SQL_CRYPT() = default;
SQL_CRYPT(ulong *seed)
{
init(seed);
}
~SQL_CRYPT() = default;
void init(ulong *seed);
void reinit() { shift=0; rand=org_rand; }
void encode(char *str, uint length);
void decode(char *str, uint length);
};
#endif /* SQL_CRYPT_INCLUDED */
PK ! : private/sql_profile.hnu [ /* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _SQL_PROFILE_H
#define _SQL_PROFILE_H
class Item;
struct TABLE_LIST;
class THD;
class ST_FIELD_INFO;
typedef struct st_schema_table ST_SCHEMA_TABLE;
namespace Show {
extern ST_FIELD_INFO query_profile_statistics_info[];
} // namespace Show
int fill_query_profile_statistics_info(THD *thd, TABLE_LIST *tables, Item *cond);
int make_profile_table_for_show(THD *thd, ST_SCHEMA_TABLE *schema_table);
#define PROFILE_NONE (uint)0
#define PROFILE_CPU (uint)(1<<0)
#define PROFILE_MEMORY (uint)(1<<1)
#define PROFILE_BLOCK_IO (uint)(1<<2)
#define PROFILE_CONTEXT (uint)(1<<3)
#define PROFILE_PAGE_FAULTS (uint)(1<<4)
#define PROFILE_IPC (uint)(1<<5)
#define PROFILE_SWAPS (uint)(1<<6)
#define PROFILE_SOURCE (uint)(1<<16)
#define PROFILE_ALL (uint)(~0)
#if defined(ENABLED_PROFILING)
#include "sql_priv.h"
#include "unireg.h"
#ifdef _WIN32
#include
#endif
#ifdef HAVE_SYS_RESOURCE_H
#include
#endif
extern PSI_memory_key key_memory_queue_item;
class PROF_MEASUREMENT;
class QUERY_PROFILE;
class PROFILING;
/**
Implements a persistent FIFO using server List method names. Not
thread-safe. Intended to be used on thread-local data only.
*/
template class Queue
{
private:
struct queue_item
{
T *payload;
struct queue_item *next, *previous;
};
struct queue_item *first, *last;
public:
Queue()
{
elements= 0;
first= last= NULL;
}
void empty()
{
struct queue_item *i, *after_i;
for (i= first; i != NULL; i= after_i)
{
after_i= i->next;
my_free(i);
}
elements= 0;
}
ulong elements; /* The count of items in the Queue */
void push_back(T *payload)
{
struct queue_item *new_item;
new_item= (struct queue_item *) my_malloc(key_memory_queue_item,
sizeof(struct queue_item), MYF(0));
if (!new_item)
return;
new_item->payload= payload;
if (first == NULL)
first= new_item;
if (last != NULL)
{
DBUG_ASSERT(last->next == NULL);
last->next= new_item;
}
new_item->previous= last;
new_item->next= NULL;
last= new_item;
elements++;
}
T *pop()
{
struct queue_item *old_item= first;
T *ret= NULL;
if (first == NULL)
{
DBUG_PRINT("warning", ("tried to pop nonexistent item from Queue"));
return NULL;
}
ret= old_item->payload;
if (first->next != NULL)
first->next->previous= NULL;
else
last= NULL;
first= first->next;
my_free(old_item);
elements--;
return ret;
}
bool is_empty()
{
DBUG_ASSERT(((elements > 0) && (first != NULL)) || ((elements == 0) || (first == NULL)));
return (elements == 0);
}
void *new_iterator()
{
return first;
}
void *iterator_next(void *current)
{
return ((struct queue_item *) current)->next;
}
T *iterator_value(void *current)
{
return ((struct queue_item *) current)->payload;
}
};
/**
A single entry in a single profile.
*/
class PROF_MEASUREMENT
{
private:
friend class QUERY_PROFILE;
friend class PROFILING;
QUERY_PROFILE *profile;
char *status;
#ifdef HAVE_GETRUSAGE
struct rusage rusage;
#elif defined(_WIN32)
FILETIME ftKernel, ftUser;
IO_COUNTERS io_count;
PROCESS_MEMORY_COUNTERS mem_count;
#endif
char *function;
char *file;
unsigned int line;
ulong m_seq;
double time_usecs;
char *allocated_status_memory;
void set_label(const char *status_arg, const char *function_arg,
const char *file_arg, unsigned int line_arg);
void clean_up();
PROF_MEASUREMENT();
PROF_MEASUREMENT(QUERY_PROFILE *profile_arg, const char *status_arg);
PROF_MEASUREMENT(QUERY_PROFILE *profile_arg, const char *status_arg,
const char *function_arg,
const char *file_arg, unsigned int line_arg);
~PROF_MEASUREMENT();
void collect();
};
/**
The full profile for a single query, and includes multiple PROF_MEASUREMENT
objects.
*/
class QUERY_PROFILE
{
private:
friend class PROFILING;
PROFILING *profiling;
query_id_t profiling_query_id; /* Session-specific id. */
char *query_source;
double m_start_time_usecs;
double m_end_time_usecs;
ulong m_seq_counter;
Queue entries;
QUERY_PROFILE(PROFILING *profiling_arg, const char *status_arg);
~QUERY_PROFILE();
void set_query_source(char *query_source_arg, size_t query_length_arg);
/* Add a profile status change to the current profile. */
void new_status(const char *status_arg,
const char *function_arg,
const char *file_arg, unsigned int line_arg);
/* Reset the contents of this profile entry. */
void reset();
/* Show this profile. This is called by PROFILING. */
bool show(uint options);
};
/**
Profiling state for a single THD; contains multiple QUERY_PROFILE objects.
*/
class PROFILING
{
private:
friend class PROF_MEASUREMENT;
friend class QUERY_PROFILE;
/*
Not the system query_id, but a counter unique to profiling.
*/
query_id_t profile_id_counter;
THD *thd;
bool keeping;
bool enabled;
QUERY_PROFILE *current;
QUERY_PROFILE *last;
Queue history;
query_id_t next_profile_id() { return(profile_id_counter++); }
public:
PROFILING();
~PROFILING();
/**
At a point in execution where we know the query source, save the text
of it in the query profile.
This must be called exactly once per descrete statement.
*/
void set_query_source(char *query_source_arg, size_t query_length_arg)
{
if (unlikely(current))
current->set_query_source(query_source_arg, query_length_arg);
}
/**
Prepare to start processing a new query. It is an error to do this
if there's a query already in process; nesting is not supported.
@param initial_state (optional) name of period before first state change
*/
void start_new_query(const char *initial_state= "Starting")
{
DBUG_ASSERT(!current);
if (unlikely(enabled))
{
QUERY_PROFILE *new_profile= new QUERY_PROFILE(this, initial_state);
if (new_profile)
current= new_profile;
}
}
void discard_current_query();
void finish_current_query()
{
if (unlikely(current))
finish_current_query_impl();
}
void finish_current_query_impl();
void status_change(const char *status_arg,
const char *function_arg,
const char *file_arg, unsigned int line_arg)
{
if (unlikely(current))
current->new_status(status_arg, function_arg, file_arg, line_arg);
}
inline void set_thd(THD *thd_arg)
{
thd= thd_arg;
reset();
}
/* SHOW PROFILES */
bool show_profiles();
/* ... from INFORMATION_SCHEMA.PROFILING ... */
int fill_statistics_info(THD *thd, TABLE_LIST *tables, Item *cond);
void reset();
void restart();
};
# endif /* ENABLED_PROFILING */
#endif /* _SQL_PROFILE_H */
PK ! p 4 private/sql_servers.hnu [ #ifndef SQL_SERVERS_INCLUDED
#define SQL_SERVERS_INCLUDED
/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#include "slave.h" // for tables_ok(), rpl_filter
class THD;
typedef struct st_lex_server_options LEX_SERVER_OPTIONS;
typedef struct st_mem_root MEM_ROOT;
/* structs */
typedef struct st_federated_server
{
const char *server_name;
long port;
size_t server_name_length;
const char *db, *scheme, *username, *password, *socket, *owner, *host, *sport;
} FOREIGN_SERVER;
/* cache handlers */
bool servers_init(bool dont_read_server_table);
bool servers_reload(THD *thd);
void servers_free(bool end=0);
/* insert functions */
int create_server(THD *thd, LEX_SERVER_OPTIONS *server_options);
/* drop functions */
int drop_server(THD *thd, LEX_SERVER_OPTIONS *server_options);
/* update functions */
int alter_server(THD *thd, LEX_SERVER_OPTIONS *server_options);
/* lookup functions */
FOREIGN_SERVER *get_server_by_name(MEM_ROOT *mem, const char *server_name,
FOREIGN_SERVER *server_buffer);
#endif /* SQL_SERVERS_INCLUDED */
PK ! ! private/threadpool_winsockets.hnu [ /* Copyright (C) 2020 Monty Program Ab
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
*/
#pragma once
#include
#include
struct st_vio;
struct win_aiosocket
{
/** OVERLAPPED is needed by all Windows AIO*/
OVERLAPPED m_overlapped{};
/** Handle to pipe, or socket */
HANDLE m_handle{};
/** Whether the m_handle refers to pipe*/
bool m_is_pipe{};
/* Read buffer handling */
/** Pointer to buffer of size READ_BUFSIZ. Can be NULL.*/
char *m_buf_ptr{};
/** Offset to current buffer position*/
size_t m_buf_off{};
/** Size of valid data in the buffer*/
size_t m_buf_datalen{};
/* Vio handling */
/** Pointer to original vio->vio_read/vio->has_data function */
size_t (*m_orig_vio_read)(st_vio *, unsigned char *, size_t){};
char (*m_orig_vio_has_data)(st_vio *){};
/**
Begins asynchronnous reading from socket/pipe.
On IO completion, pre-read some bytes into internal buffer
*/
DWORD begin_read();
/**
Update number of bytes returned, and IO error status
Should be called right after IO is completed
GetQueuedCompletionStatus() , or threadpool IO completion
callback would return nbytes and the error.
Sets the valid data length in the read buffer.
*/
void end_read(ULONG nbytes, DWORD err);
/**
Override VIO routines with ours, accounting for
one-shot buffering.
*/
void init(st_vio *vio);
/** Return number of unread bytes.*/
size_t buffer_remaining();
/* Frees the read buffer.*/
~win_aiosocket();
};
/* Functions related to IO buffers caches.*/
extern void init_win_aio_buffers(unsigned int n_buffers);
extern void destroy_win_aio_buffers();
PK ! P~>' ' private/sql_type_int.hnu [ /* Copyright (c) 2018, 2021, MariaDB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef SQL_TYPE_INT_INCLUDED
#define SQL_TYPE_INT_INCLUDED
#include "my_bit.h" // my_count_bits()
class Null_flag
{
protected:
bool m_is_null;
public:
bool is_null() const { return m_is_null; }
Null_flag(bool is_null) :m_is_null(is_null) { }
};
class Longlong
{
protected:
longlong m_value;
public:
longlong value() const { return m_value; }
Longlong(longlong nr) :m_value(nr) { }
ulonglong abs()
{
if (m_value == LONGLONG_MIN) // avoid undefined behavior
return ((ulonglong) LONGLONG_MAX) + 1;
return m_value < 0 ? -m_value : m_value;
}
};
class Longlong_null: public Longlong, public Null_flag
{
public:
Longlong_null(longlong nr, bool is_null)
:Longlong(nr), Null_flag(is_null)
{ }
explicit Longlong_null()
:Longlong(0), Null_flag(true)
{ }
explicit Longlong_null(longlong nr)
:Longlong(nr), Null_flag(false)
{ }
Longlong_null operator|(const Longlong_null &other) const
{
if (is_null() || other.is_null())
return Longlong_null();
return Longlong_null(value() | other.value());
}
Longlong_null operator&(const Longlong_null &other) const
{
if (is_null() || other.is_null())
return Longlong_null();
return Longlong_null(value() & other.value());
}
Longlong_null operator^(const Longlong_null &other) const
{
if (is_null() || other.is_null())
return Longlong_null();
return Longlong_null((longlong) (value() ^ other.value()));
}
Longlong_null operator~() const
{
if (is_null())
return *this;
return Longlong_null((longlong) ~ (ulonglong) value());
}
Longlong_null operator<<(const Longlong_null &llshift) const
{
ulonglong res;
uint shift;
if (is_null() || llshift.is_null())
return Longlong_null();
shift= (uint) llshift.value();
res= 0;
if (shift < sizeof(longlong) * 8)
res= ((ulonglong) value()) << shift;
return Longlong_null((longlong) res);
}
Longlong_null operator>>(const Longlong_null &llshift) const
{
ulonglong res;
uint shift;
if (is_null() || llshift.is_null())
return Longlong_null();
shift= (uint) llshift.value();
res= 0;
if (shift < sizeof(longlong) * 8)
res= ((ulonglong) value()) >> shift;
return Longlong_null(res);
}
Longlong_null bit_count() const
{
if (is_null())
return *this;
return Longlong_null((longlong) my_count_bits((ulonglong) value()));
}
};
class ULonglong
{
protected:
ulonglong m_value;
public:
ulonglong value() const { return m_value; }
explicit ULonglong(ulonglong nr) :m_value(nr) { }
static bool test_if_sum_overflows_ull(ulonglong arg1, ulonglong arg2)
{
return ULONGLONG_MAX - arg1 < arg2;
}
Longlong_null operator-() const
{
if (m_value > (ulonglong) LONGLONG_MAX) // Avoid undefined behaviour
{
return m_value == (ulonglong) LONGLONG_MAX + 1 ?
Longlong_null(LONGLONG_MIN, false) :
Longlong_null(0, true);
}
return Longlong_null(-(longlong) m_value, false);
}
// Convert to Longlong_null with the range check
Longlong_null to_longlong_null() const
{
if (m_value > (ulonglong) LONGLONG_MAX)
return Longlong_null(0, true);
return Longlong_null((longlong) m_value, false);
}
};
class ULonglong_null: public ULonglong, public Null_flag
{
public:
ULonglong_null(ulonglong nr, bool is_null)
:ULonglong(nr), Null_flag(is_null)
{ }
/*
Multiply two ulonglong values.
Let a = a1 * 2^32 + a0 and b = b1 * 2^32 + b0. Then
a * b = (a1 * 2^32 + a0) * (b1 * 2^32 + b0) = a1 * b1 * 2^64 +
+ (a1 * b0 + a0 * b1) * 2^32 + a0 * b0;
We can determine if the above sum overflows the ulonglong range by
sequentially checking the following conditions:
1. If both a1 and b1 are non-zero.
2. Otherwise, if (a1 * b0 + a0 * b1) is greater than ULONG_MAX.
3. Otherwise, if (a1 * b0 + a0 * b1) * 2^32 + a0 * b0 is greater than
ULONGLONG_MAX.
*/
static ULonglong_null ullmul(ulonglong a, ulonglong b)
{
ulong a1= (ulong)(a >> 32);
ulong b1= (ulong)(b >> 32);
if (a1 && b1)
return ULonglong_null(0, true);
ulong a0= (ulong)(0xFFFFFFFFUL & a);
ulong b0= (ulong)(0xFFFFFFFFUL & b);
ulonglong res1= (ulonglong) a1 * b0 + (ulonglong) a0 * b1;
if (res1 > 0xFFFFFFFFUL)
return ULonglong_null(0, true);
res1= res1 << 32;
ulonglong res0= (ulonglong) a0 * b0;
if (test_if_sum_overflows_ull(res1, res0))
return ULonglong_null(0, true);
return ULonglong_null(res1 + res0, false);
}
};
// A longlong/ulonglong hybrid. Good to store results of val_int().
class Longlong_hybrid: public Longlong
{
protected:
bool m_unsigned;
int cmp_signed(const Longlong_hybrid& other) const
{
return m_value < other.m_value ? -1 : m_value == other.m_value ? 0 : 1;
}
int cmp_unsigned(const Longlong_hybrid& other) const
{
return (ulonglong) m_value < (ulonglong) other.m_value ? -1 :
m_value == other.m_value ? 0 : 1;
}
public:
Longlong_hybrid(longlong nr, bool unsigned_flag)
:Longlong(nr), m_unsigned(unsigned_flag)
{ }
bool is_unsigned() const { return m_unsigned; }
bool is_unsigned_outside_of_signed_range() const
{
return m_unsigned && ((ulonglong) m_value) > (ulonglong) LONGLONG_MAX;
}
bool neg() const { return m_value < 0 && !m_unsigned; }
ulonglong abs() const
{
if (m_unsigned)
return (ulonglong) m_value;
return Longlong(m_value).abs();
}
/*
Convert to an unsigned number:
- Negative numbers are converted to 0.
- Positive numbers bigger than upper_bound are converted to upper_bound.
- Other numbers are returned as is.
*/
ulonglong to_ulonglong(ulonglong upper_bound) const
{
return neg() ? 0 :
(ulonglong) m_value > upper_bound ? upper_bound :
(ulonglong) m_value;
}
uint to_uint(uint upper_bound) const
{
return (uint) to_ulonglong(upper_bound);
}
Longlong_null val_int_signed() const
{
if (m_unsigned)
return ULonglong((ulonglong) m_value).to_longlong_null();
return Longlong_null(m_value, false);
}
Longlong_null val_int_unsigned() const
{
if (!m_unsigned && m_value < 0)
return Longlong_null(0, true);
return Longlong_null(m_value, false);
}
/*
Return in Item compatible val_int() format:
- signed numbers as a straight longlong value
- unsigned numbers as a ulonglong value reinterpreted to longlong
*/
Longlong_null val_int(bool want_unsigned_value) const
{
return want_unsigned_value ? val_int_unsigned() :
val_int_signed();
}
int cmp(const Longlong_hybrid& other) const
{
if (m_unsigned == other.m_unsigned)
return m_unsigned ? cmp_unsigned(other) : cmp_signed(other);
if (is_unsigned_outside_of_signed_range())
return 1;
if (other.is_unsigned_outside_of_signed_range())
return -1;
/*
The unsigned argument is in the range 0..LONGLONG_MAX.
The signed argument is in the range LONGLONG_MIN..LONGLONG_MAX.
Safe to compare as signed.
*/
return cmp_signed(other);
}
bool operator==(const Longlong_hybrid &nr) const
{
return cmp(nr) == 0;
}
bool operator==(ulonglong nr) const
{
return cmp(Longlong_hybrid((longlong) nr, true)) == 0;
}
bool operator==(uint nr) const
{
return cmp(Longlong_hybrid((longlong) nr, true)) == 0;
}
bool operator==(longlong nr) const
{
return cmp(Longlong_hybrid(nr, false)) == 0;
}
bool operator==(int nr) const
{
return cmp(Longlong_hybrid(nr, false)) == 0;
}
};
class Longlong_hybrid_null: public Longlong_hybrid,
public Null_flag
{
public:
Longlong_hybrid_null(const Longlong_null &nr, bool unsigned_flag)
:Longlong_hybrid(nr.value(), unsigned_flag),
Null_flag(nr.is_null())
{ }
};
/*
Stores the absolute value of a number, and the sign.
Value range: -ULONGLONG_MAX .. +ULONGLONG_MAX.
Provides a wider range for negative numbers than Longlong_hybrid does.
Usefull to store intermediate results of an expression whose value
is further needed to be negated. For example, these methods:
- Item_func_mul::int_op()
- Item_func_int_div::val_int()
- Item_func_mod::int_op()
calculate the result of absolute values of the arguments,
then optionally negate the result.
*/
class ULonglong_hybrid: public ULonglong
{
bool m_neg;
public:
ULonglong_hybrid(ulonglong value, bool neg)
:ULonglong(value), m_neg(neg)
{
if (m_neg && !m_value)
m_neg= false; // convert -0 to +0
}
Longlong_null val_int_unsigned() const
{
return m_neg ? Longlong_null(0, true) :
Longlong_null((longlong) m_value, false);
}
Longlong_null val_int_signed() const
{
return m_neg ? -ULonglong(m_value) : ULonglong::to_longlong_null();
}
/*
Return in Item compatible val_int() format:
- signed numbers as a straight longlong value
- unsigned numbers as a ulonglong value reinterpreted to longlong
*/
Longlong_null val_int(bool want_unsigned_value) const
{
return want_unsigned_value ? val_int_unsigned() :
val_int_signed();
}
};
#endif // SQL_TYPE_INT_INCLUDED
PK ! toW private/keycaches.hnu [ #ifndef KEYCACHES_INCLUDED
#define KEYCACHES_INCLUDED
/* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#include "sql_list.h"
#include
#include
extern "C"
{
typedef int (*process_key_cache_t) (const char *, KEY_CACHE *, void *);
}
class NAMED_ILINK;
class NAMED_ILIST: public I_List
{
public:
void delete_elements(void (*free_element)(const char*, void*));
bool delete_element(const char *name, size_t length, void (*free_element)(const char*, void*));
};
/* For key cache */
extern LEX_CSTRING default_base;
extern KEY_CACHE zero_key_cache;
extern NAMED_ILIST key_caches;
KEY_CACHE *create_key_cache(const char *name, size_t length);
KEY_CACHE *get_key_cache(const LEX_CSTRING *cache_name);
KEY_CACHE *get_or_create_key_cache(const char *name, size_t length);
void free_key_cache(const char *name, void *key_cache);
bool process_key_caches(process_key_cache_t func, void *param);
/* For Rpl_filter */
extern LEX_CSTRING default_rpl_filter_base;
extern NAMED_ILIST rpl_filters;
Rpl_filter *create_rpl_filter(const char *name, size_t length);
Rpl_filter *get_rpl_filter(LEX_CSTRING *filter_name);
Rpl_filter *get_or_create_rpl_filter(const char *name, size_t length);
void free_all_rpl_filters(void);
#endif /* KEYCACHES_INCLUDED */
PK ! Ak0 0 private/sql_update.hnu [ /* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef SQL_UPDATE_INCLUDED
#define SQL_UPDATE_INCLUDED
#include "sql_class.h" /* enum_duplicates */
#include "sql_cmd.h" // Sql_cmd_dml
#include "sql_base.h"
class Item;
struct TABLE_LIST;
class THD;
typedef class st_select_lex SELECT_LEX;
typedef class st_select_lex_unit SELECT_LEX_UNIT;
bool check_unique_table(THD *thd, TABLE_LIST *table_list);
bool records_are_comparable(const TABLE *table);
bool compare_record(const TABLE *table);
/**
@class Sql_cmd_update - class used for any UPDATE statements
This class is derived from Sql_cmd_dml and contains implementations
for abstract virtual function of the latter such as precheck() and
prepare_inner(). It also overrides the implementation of execute_inner()
providing a special handling for single-table update statements that
are not converted to multi-table updates.
The class provides an object of the Multiupdate_prelocking_strategy class
for the virtual function get_dml_prelocking_strategy().
*/
class Sql_cmd_update final : public Sql_cmd_dml
{
public:
ha_rows found{0}, updated{0};
Sql_cmd_update(bool multitable_arg)
: orig_multitable(multitable_arg), multitable(multitable_arg)
{}
enum_sql_command sql_command_code() const override
{
return orig_multitable ? SQLCOM_UPDATE_MULTI : SQLCOM_UPDATE;
}
DML_prelocking_strategy *get_dml_prelocking_strategy() override
{
return &multiupdate_prelocking_strategy;
}
bool processing_as_multitable_update_prohibited(THD *thd);
bool is_multitable() const { return multitable; }
void set_as_multitable() { multitable= true; }
void get_dml_stat (ha_rows &found, ha_rows &changed) override
{
found= this->found;
changed= this->updated;
}
protected:
/**
@brief Perform precheck of table privileges for update statements
*/
bool precheck(THD *thd) override;
/**
@brief Perform context analysis for update statements
*/
bool prepare_inner(THD *thd) override;
/**
@brief Perform optimization and execution actions needed for updates
*/
bool execute_inner(THD *thd) override;
private:
/**
@brief Special handling of single-table updates after prepare phase
*/
bool update_single_table(THD *thd);
/* Original value of the 'multitable' flag set by constructor */
const bool orig_multitable;
/*
True if the statement is a multi-table update or converted to such.
For a single-table update this flag is set to true if the statement
is supposed to be converted to multi-table update.
*/
bool multitable;
/* The prelocking strategy used when opening the used tables */
Multiupdate_prelocking_strategy multiupdate_prelocking_strategy;
public:
/* The list of the updating expressions used in the set clause */
List- *update_value_list;
};
#endif /* SQL_UPDATE_INCLUDED */
PK ! #3bb b private/wsrep_priv.hnu [ /* Copyright 2010-2023 Codership Oy
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
*/
//! @file declares symbols private to wsrep integration layer
#ifndef WSREP_PRIV_H
#define WSREP_PRIV_H
#include "wsrep_api.h"
#include "wsrep/server_state.hpp"
ssize_t wsrep_sst_prepare (void** msg);
wsrep_cb_status wsrep_sst_donate_cb (void* app_ctx,
void* recv_ctx,
const wsrep_buf_t* msg,
const wsrep_gtid_t* state_id,
const wsrep_buf_t* state,
bool bypass);
extern wsrep_uuid_t local_uuid;
extern wsrep_seqno_t local_seqno;
// a helper function
bool wsrep_sst_received(THD*, const wsrep_uuid_t&, wsrep_seqno_t,
const void*, size_t);
void wsrep_notify_status(enum wsrep::server_state::state status,
const wsrep::view* view= 0);
#endif /* WSREP_PRIV_H */
PK ! Fpj j private/pfs_metadata_provider.hnu [ /* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
#ifndef PFS_METADATA_PROVIDER_H
#define PFS_METADATA_PROVIDER_H
/**
@file include/pfs_metadata_provider.h
Performance schema instrumentation (declarations).
*/
#ifdef HAVE_PSI_METADATA_INTERFACE
#ifdef MYSQL_SERVER
#ifndef EMBEDDED_LIBRARY
#ifndef MYSQL_DYNAMIC_PLUGIN
#include "mysql/psi/psi.h"
#define PSI_METADATA_CALL(M) pfs_ ## M ## _v1
C_MODE_START
PSI_metadata_lock* pfs_create_metadata_lock_v1
(void *identity,
const MDL_key *key,
opaque_mdl_type mdl_type,
opaque_mdl_duration mdl_duration,
opaque_mdl_status mdl_status,
const char *src_file,
uint src_line);
void pfs_set_metadata_lock_status_v1
(PSI_metadata_lock *lock,
opaque_mdl_status mdl_status);
void pfs_destroy_metadata_lock_v1(PSI_metadata_lock *lock);
struct PSI_metadata_locker*
pfs_start_metadata_wait_v1
(struct PSI_metadata_locker_state_v1 *state,
struct PSI_metadata_lock *mdl,
const char *src_file, uint src_line);
void pfs_end_metadata_wait_v1
(struct PSI_metadata_locker *locker, int rc);
C_MODE_END
#endif /* MYSQL_DYNAMIC_PLUGIN */
#endif /* EMBEDDED_LIBRARY */
#endif /* MYSQL_SERVER */
#endif /* HAVE_PSI_METADATA_INTERFACE */
#endif
PK ! Be private/maria.hnu [ /* Copyright (C) 2006-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
Copyright (c) 2009, 2019, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/* This file should be included when using maria functions */
#ifndef _maria_h
#define _maria_h
#include
#include
#include "my_compare.h"
#include "ft_global.h"
#include
#ifdef __cplusplus
extern "C" {
#endif
#define MARIA_UNIQUE_HASH_LENGTH 4
extern my_bool maria_delay_key_write;
uint maria_max_key_length(void);
#define maria_max_key_segments() HA_MAX_KEY_SEG
struct st_maria_bit_buff;
struct st_maria_page;
struct st_maria_s_param;
struct st_maria_share;
typedef struct st_maria_decode_tree MARIA_DECODE_TREE;
typedef struct st_maria_handler MARIA_HA;
typedef struct st_maria_key MARIA_KEY;
typedef ulonglong MARIA_RECORD_POS;
typedef struct st_maria_keydef /* Key definition with open & info */
{
struct st_maria_share *share; /* Pointer to base (set in open) */
mysql_rwlock_t root_lock; /* locking of tree */
uint16 keysegs; /* Number of key-segment */
uint16 flag; /* NOSAME, PACK_USED */
uint8 key_alg; /* BTREE, RTREE */
uint8 key_nr; /* key number (auto) */
uint16 block_length; /* Length of keyblock (auto) */
uint16 underflow_block_length; /* When to execute underflow */
uint16 keylength; /* Tot length of keyparts (auto) */
uint16 minlength; /* min length of (packed) key (auto) */
uint16 maxlength; /* max length of (packed) key (auto) */
uint16 max_store_length; /* Size to store key + overhead */
uint32 write_comp_flag; /* compare flag for write key (auto) */
uint32 version; /* For concurrent read/write */
uint32 ftkey_nr; /* full-text index number */
HA_KEYSEG *seg, *end;
struct st_mysql_ftparser *parser; /* Fulltext [pre]parser */
int (*bin_search)(const MARIA_KEY *key, const struct st_maria_page *page,
uint32 comp_flag, uchar **ret_pos, uchar *buff,
my_bool *was_last_key);
uint (*get_key)(MARIA_KEY *key, uint page_flag, uint nod_flag,
uchar **page);
uchar *(*skip_key)(MARIA_KEY *key, uint page_flag, uint nod_flag,
uchar *page);
int (*pack_key)(const MARIA_KEY *key, uint nod_flag,
uchar *next_key, uchar *org_key, uchar *prev_key,
struct st_maria_s_param *s_temp);
void (*store_key)(struct st_maria_keydef *keyinfo, uchar *key_pos,
struct st_maria_s_param *s_temp);
my_bool (*ck_insert)(MARIA_HA *inf, MARIA_KEY *key);
my_bool (*ck_delete)(MARIA_HA *inf, MARIA_KEY *klen);
MARIA_KEY *(*make_key)(MARIA_HA *info, MARIA_KEY *int_key, uint keynr,
uchar *key, const uchar *record,
MARIA_RECORD_POS filepos, ulonglong trid);
} MARIA_KEYDEF;
typedef struct st_maria_unique_def /* Segment definition of unique */
{
uint16 keysegs; /* Number of key-segment */
uint8 key; /* Mapped to which key */
uint8 null_are_equal;
HA_KEYSEG *seg, *end;
} MARIA_UNIQUEDEF;
/*
Note that null markers should always be first in a row !
When creating a column, one should only specify:
type, length, null_bit and null_pos
*/
typedef struct st_maria_columndef /* column information */
{
enum en_fieldtype type;
uint32 offset; /* Offset to position in row */
uint16 length; /* length of field */
uint16 column_nr;
/* Intern variable (size of total storage area for the row) */
uint16 fill_length;
uint16 null_pos; /* Position for null marker */
uint16 empty_pos; /* Position for empty marker */
uint8 null_bit; /* If column may be NULL */
/* Intern. Set if column should be zero packed (part of empty_bits) */
uint8 empty_bit;
#ifndef NOT_PACKED_DATABASES
void(*unpack)(struct st_maria_columndef *rec,
struct st_maria_bit_buff *buff,
uchar *start, uchar *end);
enum en_fieldtype base_type;
uint space_length_bits, pack_type;
MARIA_DECODE_TREE *huff_tree;
#endif
} MARIA_COLUMNDEF;
typedef struct st_maria_create_info
{
const char *index_file_name, *data_file_name; /* If using symlinks */
ha_rows max_rows;
ha_rows reloc_rows;
ulonglong auto_increment;
ulonglong data_file_length;
ulonglong key_file_length;
ulong s3_block_size;
/* Size of null bitmap at start of row */
uint null_bytes;
uint old_options;
uint compression_algorithm;
enum data_file_type org_data_file_type;
uint16 language;
my_bool with_auto_increment, transactional, encrypted;
} MARIA_CREATE_INFO;
extern int maria_create(const char *name, enum data_file_type record_type,
uint keys, MARIA_KEYDEF *keydef,
uint columns, MARIA_COLUMNDEF *columndef,
uint uniques, MARIA_UNIQUEDEF *uniquedef,
MARIA_CREATE_INFO *create_info, uint flags);
#ifdef __cplusplus
}
#endif
#endif
PK ! Vb, , private/sql_union.hnu [ /* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef SQL_UNION_INCLUDED
#define SQL_UNION_INCLUDED
class THD;
class select_result;
struct LEX;
typedef class st_select_lex_unit SELECT_LEX_UNIT;
bool mysql_union(THD *thd, LEX *lex, select_result *result,
SELECT_LEX_UNIT *unit, ulonglong setup_tables_done_option);
#endif /* SQL_UNION_INCLUDED */
PK ! cX X private/spatial.hnu [ /*
Copyright (c) 2002, 2013, Oracle and/or its affiliates.
Copyright (c) 2009, 2013, Monty Program Ab.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#ifndef _spatial_h
#define _spatial_h
#include "sql_string.h" /* String, LEX_STRING */
#include
#include
#ifdef HAVE_SPATIAL
class Gis_read_stream;
#include "gcalc_tools.h"
const uint SRID_SIZE= 4;
const uint SIZEOF_STORED_DOUBLE= 8;
const uint POINT_DATA_SIZE= (SIZEOF_STORED_DOUBLE * 2);
const uint WKB_HEADER_SIZE= 1+4;
const uint32 GET_SIZE_ERROR= ((uint32) -1);
struct st_point_2d
{
double x;
double y;
};
struct st_linear_ring
{
uint32 n_points;
st_point_2d points;
};
/***************************** MBR *******************************/
/*
It's ok that a lot of the functions are inline as these are only used once
in MySQL
*/
struct MBR
{
double xmin, ymin, xmax, ymax;
MBR()
{
xmin= ymin= DBL_MAX;
xmax= ymax= -DBL_MAX;
}
MBR(const double xmin_arg, const double ymin_arg,
const double xmax_arg, const double ymax_arg)
:xmin(xmin_arg), ymin(ymin_arg), xmax(xmax_arg), ymax(ymax_arg)
{}
MBR(const st_point_2d &min, const st_point_2d &max)
:xmin(min.x), ymin(min.y), xmax(max.x), ymax(max.y)
{}
MBR(const MBR &mbr1, const MBR &mbr2)
:xmin(mbr1.xmin), ymin(mbr1.ymin), xmax(mbr1.xmax), ymax(mbr1.ymax)
{ add_mbr(&mbr2); }
inline void add_xy(double x, double y)
{
/* Not using "else" for proper one point MBR calculation */
if (x < xmin)
xmin= x;
if (x > xmax)
xmax= x;
if (y < ymin)
ymin= y;
if (y > ymax)
ymax= y;
}
void add_xy(const char *px, const char *py)
{
double x, y;
float8get(x, px);
float8get(y, py);
add_xy(x,y);
}
void add_mbr(const MBR *mbr)
{
if (mbr->xmin < xmin)
xmin= mbr->xmin;
if (mbr->xmax > xmax)
xmax= mbr->xmax;
if (mbr->ymin < ymin)
ymin= mbr->ymin;
if (mbr->ymax > ymax)
ymax= mbr->ymax;
}
void buffer(double d)
{
xmin-= d;
ymin-= d;
xmax+= d;
ymax+= d;
}
int equals(const MBR *mbr)
{
/* The following should be safe, even if we compare doubles */
return ((mbr->xmin == xmin) && (mbr->ymin == ymin) &&
(mbr->xmax == xmax) && (mbr->ymax == ymax));
}
int disjoint(const MBR *mbr)
{
/* The following should be safe, even if we compare doubles */
return ((mbr->xmin > xmax) || (mbr->ymin > ymax) ||
(mbr->xmax < xmin) || (mbr->ymax < ymin));
}
int intersects(const MBR *mbr)
{
return !disjoint(mbr);
}
int touches(const MBR *mbr)
{
/* The following should be safe, even if we compare doubles */
return ((mbr->xmin == xmax || mbr->xmax == xmin) &&
((mbr->ymin >= ymin && mbr->ymin <= ymax) ||
(mbr->ymax >= ymin && mbr->ymax <= ymax))) ||
((mbr->ymin == ymax || mbr->ymax == ymin) &&
((mbr->xmin >= xmin && mbr->xmin <= xmax) ||
(mbr->xmax >= xmin && mbr->xmax <= xmax)));
}
int within(const MBR *mbr);
int contains(const MBR *mbr)
{
/* The following should be safe, even if we compare doubles */
return ((mbr->xmin >= xmin) && (mbr->ymin >= ymin) &&
(mbr->xmax <= xmax) && (mbr->ymax <= ymax));
}
bool inner_point(double x, double y) const
{
/* The following should be safe, even if we compare doubles */
return (xminx) && (yminy);
}
/**
The dimension maps to an integer as:
- Polygon -> 2
- Horizontal or vertical line -> 1
- Point -> 0
- Invalid MBR -> -1
*/
int dimension() const
{
int d= 0;
if (xmin > xmax)
return -1;
else if (xmin < xmax)
d++;
if (ymin > ymax)
return -1;
else if (ymin < ymax)
d++;
return d;
}
int overlaps(const MBR *mbr)
{
/*
overlaps() requires that some point inside *this is also inside
*mbr, and that both geometries and their intersection are of the
same dimension.
*/
int d = dimension();
if (d != mbr->dimension() || d <= 0 || contains(mbr) || within(mbr))
return 0;
MBR intersection(MY_MAX(xmin, mbr->xmin), MY_MAX(ymin, mbr->ymin),
MY_MIN(xmax, mbr->xmax), MY_MIN(ymax, mbr->ymax));
return (d == intersection.dimension());
}
int valid() const
{ return xmin <= xmax && ymin <= ymax; }
};
/***************************** Geometry *******************************/
struct Geometry_buffer;
class Geometry
{
public:
Geometry() = default; /* Remove gcc warning */
virtual ~Geometry() = default; /* Remove gcc warning */
static void *operator new(size_t size, void *buffer)
{
return buffer;
}
static void operator delete(void *ptr, void *buffer)
{}
static void operator delete(void *buffer)
{}
enum wkbType
{
wkb_point= 1,
wkb_linestring= 2,
wkb_polygon= 3,
wkb_multipoint= 4,
wkb_multilinestring= 5,
wkb_multipolygon= 6,
wkb_geometrycollection= 7,
wkb_last=7
};
enum wkbByteOrder
{
wkb_xdr= 0, /* Big Endian */
wkb_ndr= 1 /* Little Endian */
};
enum geojson_errors
{
GEOJ_INCORRECT_GEOJSON= 1,
GEOJ_TOO_FEW_POINTS= 2,
GEOJ_POLYGON_NOT_CLOSED= 3,
GEOJ_DIMENSION_NOT_SUPPORTED= 4,
GEOJ_EMPTY_COORDINATES= 5,
};
/** Callback which creates Geometry objects on top of a given placement. */
typedef Geometry *(*create_geom_t)(char *);
class Class_info
{
public:
LEX_STRING m_name;
LEX_STRING m_geojson_name;
int m_type_id;
create_geom_t m_create_func;
Class_info(const char *name, const char *gejson_name,
int type_id, create_geom_t create_func);
};
virtual const Class_info *get_class_info() const=0;
virtual uint32 get_data_size() const=0;
/*
The 'binary_valid' spatial object can be stored in the database
and be the correct argument to the spatial functions.
It can still be not valid by the OPENGIS standard like
having self-intersecting borders.
*/
bool is_binary_valid() const
{
uint32 data_size= get_data_size();
return (data_size == GET_SIZE_ERROR) ? false : !no_data(m_data, data_size);
}
virtual bool init_from_wkt(Gis_read_stream *trs, String *wkb)=0;
/* returns the length of the wkb that was read */
virtual uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo,
String *res)=0;
virtual uint init_from_opresult(String *bin,
const char *opres, uint res_len)
{ return init_from_wkb(opres + 4, UINT_MAX32, wkb_ndr, bin) + 4; }
virtual bool init_from_json(json_engine_t *je, bool er_on_3D, String *wkb)
{ return true; }
virtual bool get_data_as_wkt(String *txt, const char **end) const=0;
virtual bool get_data_as_json(String *txt, uint max_dec_digits,
const char **end) const=0;
virtual bool get_mbr(MBR *mbr, const char **end) const=0;
virtual bool dimension(uint32 *dim, const char **end) const=0;
virtual int get_x(double *x) const { return -1; }
virtual int get_y(double *y) const { return -1; }
virtual int geom_length(double *len, const char **end) const { return -1; }
virtual int area(double *ar, const char **end) const { return -1;}
virtual int is_closed(int *closed) const { return -1; }
virtual int num_interior_ring(uint32 *n_int_rings) const { return -1; }
virtual int num_points(uint32 *n_points) const { return -1; }
virtual int num_geometries(uint32 *num) const { return -1; }
virtual int start_point(String *point) const { return -1; }
virtual int end_point(String *point) const { return -1; }
virtual int exterior_ring(String *ring) const { return -1; }
virtual int centroid(String *point) const { return -1; }
virtual int point_n(uint32 num, String *result) const { return -1; }
virtual int interior_ring_n(uint32 num, String *result) const { return -1; }
virtual int geometry_n(uint32 num, String *result) const { return -1; }
virtual int store_shapes(Gcalc_shape_transporter *trn) const=0;
public:
static Geometry *create_by_typeid(Geometry_buffer *buffer, int type_id);
static Geometry *construct(Geometry_buffer *buffer,
const char *data, uint32 data_len);
static Geometry *create_from_wkt(Geometry_buffer *buffer,
Gis_read_stream *trs, String *wkt,
bool init_stream=1);
static Geometry *create_from_wkb(Geometry_buffer *buffer,
const char *wkb, uint32 len, String *res);
static Geometry *create_from_json(Geometry_buffer *buffer, json_engine_t *je,
bool er_on_3D, String *res);
static Geometry *create_from_opresult(Geometry_buffer *g_buf,
String *res, Gcalc_result_receiver &rr);
static uint get_key_image_itMBR(LEX_CSTRING &src, uchar *buff, uint length);
int as_wkt(String *wkt, const char **end);
int as_json(String *wkt, uint max_dec_digits, const char **end);
int bbox_as_json(String *wkt);
inline void set_data_ptr(const char *data, uint32 data_len)
{
m_data= data;
m_data_end= data + data_len;
}
inline void shift_wkb_header()
{
m_data+= WKB_HEADER_SIZE;
}
const char *get_data_ptr() const
{
return m_data;
}
bool envelope(String *result) const;
static Class_info *ci_collection[wkb_last+1];
static bool create_point(String *result, double x, double y);
protected:
static Class_info *find_class(int type_id)
{
return ((type_id < wkb_point) || (type_id > wkb_last)) ?
NULL : ci_collection[type_id];
}
static Class_info *find_class(const char *name, size_t len);
const char *append_points(String *txt, uint32 n_points,
const char *data, uint32 offset) const;
bool create_point(String *result, const char *data) const;
const char *get_mbr_for_points(MBR *mbr, const char *data, uint offset)
const;
public:
/**
Check if there're enough data remaining as requested
@arg cur_data pointer to the position in the binary form
@arg data_amount number of points expected
@return true if not enough data
*/
inline bool no_data(const char *cur_data, size_t data_amount) const
{
return (cur_data + data_amount > m_data_end);
}
/**
Check if there're enough points remaining as requested
Need to perform the calculation in logical units, since multiplication
can overflow the size data type.
@arg data pointer to the beginning of the points array
@arg expected_points number of points expected
@arg extra_point_space extra space for each point element in the array
@return true if there are not enough points
*/
inline bool not_enough_points(const char *data, uint32 expected_points,
uint32 extra_point_space = 0) const
{
return (m_data_end < data ||
(expected_points > ((m_data_end - data) /
(POINT_DATA_SIZE + extra_point_space))));
}
protected:
const char *m_data;
const char *m_data_end;
};
/***************************** Point *******************************/
class Gis_point: public Geometry
{
public:
Gis_point() = default; /* Remove gcc warning */
virtual ~Gis_point() = default; /* Remove gcc warning */
uint32 get_data_size() const override;
bool init_from_wkt(Gis_read_stream *trs, String *wkb) override;
uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res) override;
bool init_from_json(json_engine_t *je, bool er_on_3D, String *wkb) override;
bool get_data_as_wkt(String *txt, const char **end) const override;
bool get_data_as_json(String *txt, uint max_dec_digits,
const char **end) const override;
bool get_mbr(MBR *mbr, const char **end) const override;
int get_xy(double *x, double *y) const
{
const char *data= m_data;
if (no_data(data, SIZEOF_STORED_DOUBLE * 2))
return 1;
float8get(*x, data);
float8get(*y, data + SIZEOF_STORED_DOUBLE);
return 0;
}
int get_xy_radian(double *x, double *y) const
{
if (!get_xy(x, y))
{
*x= (*x)*M_PI/180;
*y= (*y)*M_PI/180;
return 0;
}
return 1;
}
int get_x(double *x) const override
{
if (no_data(m_data, SIZEOF_STORED_DOUBLE))
return 1;
float8get(*x, m_data);
return 0;
}
int get_y(double *y) const override
{
const char *data= m_data;
if (no_data(data, SIZEOF_STORED_DOUBLE * 2)) return 1;
float8get(*y, data + SIZEOF_STORED_DOUBLE);
return 0;
}
int geom_length(double *len, const char **end) const override;
int area(double *ar, const char **end) const override;
bool dimension(uint32 *dim, const char **end) const override
{
*dim= 0;
*end= 0; /* No default end */
return 0;
}
int store_shapes(Gcalc_shape_transporter *trn) const override;
const Class_info *get_class_info() const override;
double calculate_haversine(const Geometry *g, const double sphere_radius,
int *error);
int spherical_distance_multipoints(Geometry *g, const double r, double *result,
int *error);
};
/***************************** LineString *******************************/
class Gis_line_string: public Geometry
{
public:
Gis_line_string() = default; /* Remove gcc warning */
virtual ~Gis_line_string() = default; /* Remove gcc warning */
uint32 get_data_size() const override;
bool init_from_wkt(Gis_read_stream *trs, String *wkb) override;
uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res) override;
bool init_from_json(json_engine_t *je, bool er_on_3D, String *wkb) override;
bool get_data_as_wkt(String *txt, const char **end) const override;
bool get_data_as_json(String *txt, uint max_dec_digits,
const char **end) const override;
bool get_mbr(MBR *mbr, const char **end) const override;
int geom_length(double *len, const char **end) const override;
int area(double *ar, const char **end) const override;
int is_closed(int *closed) const override;
int num_points(uint32 *n_points) const override;
int start_point(String *point) const override;
int end_point(String *point) const override;
int point_n(uint32 n, String *result) const override;
bool dimension(uint32 *dim, const char **end) const override
{
*dim= 1;
*end= 0; /* No default end */
return 0;
}
int store_shapes(Gcalc_shape_transporter *trn) const override;
const Class_info *get_class_info() const override;
};
/***************************** Polygon *******************************/
class Gis_polygon: public Geometry
{
public:
Gis_polygon() = default; /* Remove gcc warning */
virtual ~Gis_polygon() = default; /* Remove gcc warning */
uint32 get_data_size() const override;
bool init_from_wkt(Gis_read_stream *trs, String *wkb) override;
uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res) override;
uint init_from_opresult(String *bin, const char *opres, uint res_len) override;
bool init_from_json(json_engine_t *je, bool er_on_3D, String *wkb) override;
bool get_data_as_wkt(String *txt, const char **end) const override;
bool get_data_as_json(String *txt, uint max_dec_digits,
const char **end) const override;
bool get_mbr(MBR *mbr, const char **end) const override;
int area(double *ar, const char **end) const override;
int exterior_ring(String *result) const override;
int num_interior_ring(uint32 *n_int_rings) const override;
int interior_ring_n(uint32 num, String *result) const override;
int centroid_xy(double *x, double *y) const;
int centroid(String *result) const override;
bool dimension(uint32 *dim, const char **end) const override
{
*dim= 2;
*end= 0; /* No default end */
return 0;
}
int store_shapes(Gcalc_shape_transporter *trn) const override;
const Class_info *get_class_info() const override;
};
/***************************** MultiPoint *******************************/
class Gis_multi_point: public Geometry
{
// Maximum number of points in MultiPoint that can fit into String
static const uint32 max_n_points=
(uint32) (UINT_MAX32 - WKB_HEADER_SIZE - 4 /* n_points */) /
(WKB_HEADER_SIZE + POINT_DATA_SIZE);
public:
Gis_multi_point() = default; /* Remove gcc warning */
virtual ~Gis_multi_point() = default; /* Remove gcc warning */
uint32 get_data_size() const override;
bool init_from_wkt(Gis_read_stream *trs, String *wkb) override;
uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res) override;
uint init_from_opresult(String *bin, const char *opres, uint res_len) override;
bool init_from_json(json_engine_t *je, bool er_on_3D, String *wkb) override;
bool get_data_as_wkt(String *txt, const char **end) const override;
bool get_data_as_json(String *txt, uint max_dec_digits,
const char **end) const override;
bool get_mbr(MBR *mbr, const char **end) const override;
int num_geometries(uint32 *num) const override;
int geometry_n(uint32 num, String *result) const override;
bool dimension(uint32 *dim, const char **end) const override
{
*dim= 0;
*end= 0; /* No default end */
return 0;
}
int store_shapes(Gcalc_shape_transporter *trn) const override;
const Class_info *get_class_info() const override;
int spherical_distance_multipoints(Geometry *g, const double r, double *res,
int *error);
};
/***************************** MultiLineString *******************************/
class Gis_multi_line_string: public Geometry
{
public:
Gis_multi_line_string() = default; /* Remove gcc warning */
virtual ~Gis_multi_line_string() = default; /* Remove gcc warning */
uint32 get_data_size() const override;
bool init_from_wkt(Gis_read_stream *trs, String *wkb) override;
uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res) override;
uint init_from_opresult(String *bin, const char *opres, uint res_len) override;
bool init_from_json(json_engine_t *je, bool er_on_3D, String *wkb) override;
bool get_data_as_wkt(String *txt, const char **end) const override;
bool get_data_as_json(String *txt, uint max_dec_digits,
const char **end) const override;
bool get_mbr(MBR *mbr, const char **end) const override;
int num_geometries(uint32 *num) const override;
int geometry_n(uint32 num, String *result) const override;
int geom_length(double *len, const char **end) const override;
int is_closed(int *closed) const override;
bool dimension(uint32 *dim, const char **end) const override
{
*dim= 1;
*end= 0; /* No default end */
return 0;
}
int store_shapes(Gcalc_shape_transporter *trn) const override;
const Class_info *get_class_info() const override;
};
/***************************** MultiPolygon *******************************/
class Gis_multi_polygon: public Geometry
{
public:
Gis_multi_polygon() = default; /* Remove gcc warning */
virtual ~Gis_multi_polygon() = default; /* Remove gcc warning */
uint32 get_data_size() const override;
bool init_from_wkt(Gis_read_stream *trs, String *wkb) override;
uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res) override;
bool init_from_json(json_engine_t *je, bool er_on_3D, String *wkb) override;
bool get_data_as_wkt(String *txt, const char **end) const override;
bool get_data_as_json(String *txt, uint max_dec_digits,
const char **end) const override;
bool get_mbr(MBR *mbr, const char **end) const override;
int num_geometries(uint32 *num) const override;
int geometry_n(uint32 num, String *result) const override;
int area(double *ar, const char **end) const override;
int centroid(String *result) const override;
bool dimension(uint32 *dim, const char **end) const override
{
*dim= 2;
*end= 0; /* No default end */
return 0;
}
int store_shapes(Gcalc_shape_transporter *trn) const override;
const Class_info *get_class_info() const override;
uint init_from_opresult(String *bin, const char *opres, uint res_len) override;
};
/*********************** GeometryCollection *******************************/
class Gis_geometry_collection: public Geometry
{
public:
Gis_geometry_collection() = default; /* Remove gcc warning */
virtual ~Gis_geometry_collection() = default; /* Remove gcc warning */
uint32 get_data_size() const override;
bool init_from_wkt(Gis_read_stream *trs, String *wkb) override;
uint init_from_wkb(const char *wkb, uint len, wkbByteOrder bo, String *res) override;
uint init_from_opresult(String *bin, const char *opres, uint res_len) override;
bool init_from_json(json_engine_t *je, bool er_on_3D, String *wkb) override;
bool get_data_as_wkt(String *txt, const char **end) const override;
bool get_data_as_json(String *txt, uint max_dec_digits,
const char **end) const override;
bool get_mbr(MBR *mbr, const char **end) const override;
int area(double *ar, const char **end) const override;
int geom_length(double *len, const char **end) const override;
int num_geometries(uint32 *num) const override;
int geometry_n(uint32 num, String *result) const override;
bool dimension(uint32 *dim, const char **end) const override;
int store_shapes(Gcalc_shape_transporter *trn) const override;
const Class_info *get_class_info() const override;
};
struct Geometry_buffer : public
my_aligned_storage {};
#endif /*HAVE_SPATIAL*/
#endif
PK ! C
g g private/field.hnu [ #ifndef FIELD_INCLUDED
#define FIELD_INCLUDED
/* Copyright (c) 2000, 2015, Oracle and/or its affiliates.
Copyright (c) 2008, 2021, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/*
Because of the function make_new_field() all field classes that have static
variables must declare the size_of() member function.
*/
#ifdef USE_PRAGMA_INTERFACE
#pragma interface /* gcc class implementation */
#endif
#include "mysqld.h" /* system_charset_info */
#include "table.h" /* TABLE */
#include "sql_string.h" /* String */
#include "my_decimal.h" /* my_decimal */
#include "sql_error.h" /* Sql_condition */
#include "compat56.h"
#include "sql_type.h" /* Type_std_attributes */
#include "field_comp.h"
class Send_field;
class Copy_field;
class Protocol;
class Protocol_text;
class Create_field;
class Relay_log_info;
class Field;
class Column_statistics;
class Column_statistics_collected;
class Item_func;
class Item_bool_func;
class Item_equal;
class Virtual_tmp_table;
class Qualified_column_ident;
class Table_ident;
class SEL_ARG;
class RANGE_OPT_PARAM;
struct KEY_PART;
struct SORT_FIELD;
struct SORT_FIELD_ATTR;
enum enum_check_fields
{
CHECK_FIELD_IGNORE,
CHECK_FIELD_EXPRESSION,
CHECK_FIELD_WARN,
CHECK_FIELD_ERROR_FOR_NULL,
};
enum ignore_value_reaction
{
IGNORE_MEANS_ERROR,
IGNORE_MEANS_DEFAULT,
IGNORE_MEANS_FIELD_VALUE
};
ignore_value_reaction find_ignore_reaction(THD *thd);
enum enum_conv_type
{
CONV_TYPE_PRECISE,
CONV_TYPE_VARIANT,
CONV_TYPE_SUBSET_TO_SUPERSET,
CONV_TYPE_SUPERSET_TO_SUBSET,
CONV_TYPE_IMPOSSIBLE
};
class Conv_param
{
uint16 m_table_def_flags;
public:
Conv_param(uint16 table_def_flags)
:m_table_def_flags(table_def_flags)
{ }
uint16 table_def_flags() const { return m_table_def_flags; }
};
class Conv_source: public Type_handler_hybrid_field_type
{
uint16 m_metadata;
CHARSET_INFO *m_cs;
public:
Conv_source(const Type_handler *h, uint16 metadata, CHARSET_INFO *cs)
:Type_handler_hybrid_field_type(h),
m_metadata(metadata),
m_cs(cs)
{
DBUG_ASSERT(cs);
}
uint16 metadata() const { return m_metadata; }
uint mbmaxlen() const { return m_cs->mbmaxlen; }
};
/*
Common declarations for Field and Item
*/
class Value_source
{
protected:
// Parameters for warning and note generation
class Warn_filter
{
bool m_want_warning_edom;
bool m_want_note_truncated_spaces;
public:
Warn_filter(bool want_warning_edom, bool want_note_truncated_spaces) :
m_want_warning_edom(want_warning_edom),
m_want_note_truncated_spaces(want_note_truncated_spaces)
{ }
Warn_filter(const THD *thd);
bool want_warning_edom() const
{ return m_want_warning_edom; }
bool want_note_truncated_spaces() const
{ return m_want_note_truncated_spaces; }
};
class Warn_filter_all: public Warn_filter
{
public:
Warn_filter_all() :Warn_filter(true, true) { }
};
class Converter_double_to_longlong
{
protected:
bool m_error;
longlong m_result;
public:
Converter_double_to_longlong(double nr, bool unsigned_flag);
longlong result() const { return m_result; }
bool error() const { return m_error; }
void push_warning(THD *thd, double nr, bool unsigned_flag);
};
class Converter_double_to_longlong_with_warn:
public Converter_double_to_longlong
{
public:
Converter_double_to_longlong_with_warn(THD *thd, double nr,
bool unsigned_flag)
:Converter_double_to_longlong(nr, unsigned_flag)
{
if (m_error)
push_warning(thd, nr, unsigned_flag);
}
Converter_double_to_longlong_with_warn(double nr, bool unsigned_flag)
:Converter_double_to_longlong(nr, unsigned_flag)
{
if (m_error)
push_warning(current_thd, nr, unsigned_flag);
}
};
// String-to-number converters
class Converter_string_to_number
{
protected:
char *m_end_of_num; // Where the low-level conversion routine stopped
int m_error; // The error code returned by the low-level routine
bool m_edom; // If EDOM-alike error happened during conversion
/**
Check string-to-number conversion and produce a warning if
- could not convert any digits (EDOM-alike error)
- found garbage at the end of the string
- found extra spaces at the end (a note)
See also Field_num::check_edom_and_truncation() for a similar function.
@param thd - the thread that will be used to generate warnings.
Can be NULL (which means current_thd will be used
if a warning is really necessary).
@param type - name of the data type
(e.g. "INTEGER", "DECIMAL", "DOUBLE")
@param cs - character set of the original string
@param str - the original string
@param end - the end of the string
@param allow_notes - tells if trailing space notes should be displayed
or suppressed.
Unlike Field_num::check_edom_and_truncation(), this function does not
distinguish between EDOM and truncation and reports the same warning for
both cases. Perhaps we should eventually print different warnings,
to make the explicit CAST work closer to the implicit cast in
Field_xxx::store().
*/
void check_edom_and_truncation(THD *thd, Warn_filter filter,
const char *type,
CHARSET_INFO *cs,
const char *str,
size_t length) const;
public:
int error() const { return m_error; }
};
class Converter_strntod: public Converter_string_to_number
{
double m_result;
public:
Converter_strntod(CHARSET_INFO *cs, const char *str, size_t length)
{
m_result= cs->strntod((char *) str, length, &m_end_of_num, &m_error);
// strntod() does not set an error if the input string was empty
m_edom= m_error !=0 || str == m_end_of_num;
}
double result() const { return m_result; }
};
class Converter_string_to_longlong: public Converter_string_to_number
{
protected:
longlong m_result;
public:
longlong result() const { return m_result; }
};
class Converter_strntoll: public Converter_string_to_longlong
{
public:
Converter_strntoll(CHARSET_INFO *cs, const char *str, size_t length)
{
m_result= cs->strntoll(str, length, 10, &m_end_of_num, &m_error);
/*
All non-zero errors means EDOM error.
strntoll() does not set an error if the input string was empty.
Check it here.
Notice the different with the same condition in Converter_strntoll10.
*/
m_edom= m_error != 0 || str == m_end_of_num;
}
};
class Converter_strtoll10: public Converter_string_to_longlong
{
public:
Converter_strtoll10(CHARSET_INFO *cs, const char *str, size_t length)
{
m_end_of_num= (char *) str + length;
m_result= cs->strtoll10(str, &m_end_of_num, &m_error);
/*
Negative error means "good negative number".
Only a positive m_error value means a real error.
strtoll10() sets error to MY_ERRNO_EDOM in case of an empty string,
so we don't have to additionally catch empty strings here.
*/
m_edom= m_error > 0;
}
};
class Converter_str2my_decimal: public Converter_string_to_number
{
public:
Converter_str2my_decimal(uint mask,
CHARSET_INFO *cs, const char *str, size_t length,
my_decimal *buf)
{
DBUG_ASSERT(length < UINT_MAX32);
m_error= str2my_decimal(mask, str, length, cs,
buf, (const char **) &m_end_of_num);
// E_DEC_TRUNCATED means a very minor truncation: '1e-100' -> 0
m_edom= m_error && m_error != E_DEC_TRUNCATED;
}
};
// String-to-number converters with automatic warning generation
class Converter_strntod_with_warn: public Converter_strntod
{
public:
Converter_strntod_with_warn(THD *thd, Warn_filter filter,
CHARSET_INFO *cs,
const char *str, size_t length)
:Converter_strntod(cs, str, length)
{
check_edom_and_truncation(thd, filter, "DOUBLE", cs, str, length);
}
};
class Converter_strntoll_with_warn: public Converter_strntoll
{
public:
Converter_strntoll_with_warn(THD *thd, Warn_filter filter,
CHARSET_INFO *cs,
const char *str, size_t length)
:Converter_strntoll(cs, str, length)
{
check_edom_and_truncation(thd, filter, "INTEGER", cs, str, length);
}
};
class Converter_strtoll10_with_warn: public Converter_strtoll10
{
public:
Converter_strtoll10_with_warn(THD *thd, Warn_filter filter,
CHARSET_INFO *cs,
const char *str, size_t length)
:Converter_strtoll10(cs, str, length)
{
check_edom_and_truncation(thd, filter, "INTEGER", cs, str, length);
}
};
class Converter_str2my_decimal_with_warn: public Converter_str2my_decimal
{
public:
Converter_str2my_decimal_with_warn(THD *thd, Warn_filter filter,
uint mask, CHARSET_INFO *cs,
const char *str, size_t length,
my_decimal *buf)
:Converter_str2my_decimal(mask, cs, str, length, buf)
{
check_edom_and_truncation(thd, filter, "DECIMAL", cs, str, length);
}
};
// String-to-number conversion methods for the old code compatibility
longlong longlong_from_string_with_check(CHARSET_INFO *cs, const char *cptr,
const char *end) const
{
/*
TODO: Give error if we wanted a signed integer and we got an unsigned
one
Notice, longlong_from_string_with_check() honors thd->no_error, because
it's used to handle queries like this:
SELECT COUNT(@@basedir);
and is called when Item_func_get_system_var::update_null_value()
suppresses warnings and then calls val_int().
The other methods {double|decimal}_from_string_with_check() ignore
thd->no_errors, because they are not used for update_null_value()
and they always allow all kind of warnings.
*/
THD *thd= current_thd;
return Converter_strtoll10_with_warn(thd, Warn_filter(thd),
cs, cptr, end - cptr).result();
}
double double_from_string_with_check(CHARSET_INFO *cs, const char *cptr,
const char *end) const
{
return Converter_strntod_with_warn(NULL, Warn_filter_all(),
cs, cptr, end - cptr).result();
}
my_decimal *decimal_from_string_with_check(my_decimal *decimal_value,
CHARSET_INFO *cs,
const char *cptr,
const char *end)
{
Converter_str2my_decimal_with_warn(NULL, Warn_filter_all(),
E_DEC_FATAL_ERROR & ~E_DEC_BAD_NUM,
cs, cptr, end - cptr, decimal_value);
return decimal_value;
}
longlong longlong_from_hex_hybrid(const char *str, size_t length)
{
const char *end= str + length;
const char *ptr= end - MY_MIN(length, sizeof(longlong));
ulonglong value= 0;
for ( ; ptr != end ; ptr++)
value= (value << 8) + (ulonglong) (uchar) *ptr;
return (longlong) value;
}
longlong longlong_from_string_with_check(const String *str) const
{
return longlong_from_string_with_check(str->charset(),
str->ptr(), str->end());
}
double double_from_string_with_check(const String *str) const
{
return double_from_string_with_check(str->charset(),
str->ptr(), str->end());
}
my_decimal *decimal_from_string_with_check(my_decimal *decimal_value,
const String *str)
{
return decimal_from_string_with_check(decimal_value, str->charset(),
str->ptr(), str->end());
}
// End of String-to-number conversion methods
public:
/*
The enumeration Subst_constraint is currently used only in implementations
of the virtual function subst_argument_checker.
*/
enum Subst_constraint
{
ANY_SUBST, /* Any substitution for a field is allowed */
IDENTITY_SUBST /* Substitution for a field is allowed if any two
different values of the field type are not equal */
};
/*
Item context attributes.
Comparison functions pass their attributes to propagate_equal_fields().
For example, for string comparison, the collation of the comparison
operation is important inside propagate_equal_fields().
*/
class Context
{
/*
Which type of propagation is allowed:
- ANY_SUBST (loose equality, according to the collation), or
- IDENTITY_SUBST (strict binary equality).
*/
Subst_constraint m_subst_constraint;
/*
Comparison type.
Important only when ANY_SUBSTS.
*/
const Type_handler *m_compare_handler;
/*
Collation of the comparison operation.
Important only when ANY_SUBST.
*/
CHARSET_INFO *m_compare_collation;
public:
Context(Subst_constraint subst, const Type_handler *h, CHARSET_INFO *cs)
:m_subst_constraint(subst),
m_compare_handler(h),
m_compare_collation(cs)
{ DBUG_ASSERT(h == h->type_handler_for_comparison()); }
Subst_constraint subst_constraint() const { return m_subst_constraint; }
const Type_handler *compare_type_handler() const
{
DBUG_ASSERT(m_subst_constraint == ANY_SUBST);
return m_compare_handler;
}
CHARSET_INFO *compare_collation() const
{
DBUG_ASSERT(m_subst_constraint == ANY_SUBST);
return m_compare_collation;
}
};
class Context_identity: public Context
{ // Use this to request only exact value, no invariants.
public:
Context_identity()
:Context(IDENTITY_SUBST, &type_handler_long_blob, &my_charset_bin) { }
};
class Context_boolean: public Context
{ // Use this when an item is [a part of] a boolean expression
public:
Context_boolean()
:Context(ANY_SUBST, &type_handler_slonglong, &my_charset_bin) { }
};
};
#define STORAGE_TYPE_MASK 7
#define COLUMN_FORMAT_MASK 7
#define COLUMN_FORMAT_SHIFT 3
/* The length of the header part for each virtual column in the .frm file */
#define FRM_VCOL_OLD_HEADER_SIZE(b) (3 + MY_TEST(b))
#define FRM_VCOL_NEW_BASE_SIZE 16
#define FRM_VCOL_NEW_HEADER_SIZE 6
class Count_distinct_field;
struct ha_field_option_struct;
struct st_cache_field;
int field_conv(Field *to,Field *from);
int truncate_double(double *nr, uint field_length, decimal_digits_t dec,
bool unsigned_flag, double max_value);
inline uint get_enum_pack_length(int elements)
{
return elements < 256 ? 1 : 2;
}
inline uint get_set_pack_length(int elements)
{
uint len= (elements + 7) / 8;
return len > 4 ? 8 : len;
}
/**
Tests if field type is temporal and has date part,
i.e. represents DATE, DATETIME or TIMESTAMP types in SQL.
@param type Field type, as returned by field->type().
@retval true If field type is temporal type with date part.
@retval false If field type is not temporal type with date part.
*/
inline bool is_temporal_type_with_date(enum_field_types type)
{
switch (type)
{
case MYSQL_TYPE_DATE:
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
return true;
case MYSQL_TYPE_DATETIME2:
case MYSQL_TYPE_TIMESTAMP2:
DBUG_ASSERT(0); // field->real_type() should not get to here.
return false;
default:
return false;
}
}
enum enum_vcol_info_type
{
VCOL_GENERATED_VIRTUAL, VCOL_GENERATED_STORED,
VCOL_DEFAULT, VCOL_CHECK_FIELD, VCOL_CHECK_TABLE,
VCOL_USING_HASH,
/* Additional types should be added here */
VCOL_GENERATED_VIRTUAL_INDEXED, // this is never written in .frm
/* Following is the highest value last */
VCOL_TYPE_NONE = 127 // Since the 0 value is already in use
};
static inline const char *vcol_type_name(enum_vcol_info_type type)
{
switch (type)
{
case VCOL_GENERATED_VIRTUAL:
case VCOL_GENERATED_VIRTUAL_INDEXED:
case VCOL_GENERATED_STORED:
return "GENERATED ALWAYS AS";
case VCOL_DEFAULT:
return "DEFAULT";
case VCOL_CHECK_FIELD:
case VCOL_CHECK_TABLE:
return "CHECK";
case VCOL_USING_HASH:
return "USING HASH";
case VCOL_TYPE_NONE:
return "UNTYPED";
}
return 0;
}
/*
Flags for Virtual_column_info. If none is set, the expression must be
a constant with no side-effects, so it's calculated at CREATE TABLE time,
stored in table->record[2], and not recalculated for every statement.
*/
#define VCOL_FIELD_REF 1
#define VCOL_NON_DETERMINISTIC 2
#define VCOL_SESSION_FUNC 4 /* uses session data, e.g. USER or DAYNAME */
#define VCOL_TIME_FUNC 8 /* safe for SBR */
#define VCOL_AUTO_INC 16
#define VCOL_IMPOSSIBLE 32
#define VCOL_NEXTVAL 64 /* NEXTVAL is not implemented for vcols */
#define VCOL_NOT_STRICTLY_DETERMINISTIC \
(VCOL_NON_DETERMINISTIC | VCOL_TIME_FUNC | VCOL_SESSION_FUNC)
/*
Virtual_column_info is the class to contain additional
characteristics that is specific for a virtual/computed
field such as:
- the defining expression that is evaluated to compute the value
of the field
- whether the field is to be stored in the database
- whether the field is used in a partitioning expression
*/
class Virtual_column_info: public Sql_alloc,
private Type_handler_hybrid_field_type
{
private:
enum_vcol_info_type vcol_type; /* Virtual column expression type */
/*
The following data is only updated by the parser and read
when a Create_field object is created/initialized.
*/
/* Flag indicating that the field used in a partitioning expression */
bool in_partitioning_expr;
public:
/* Flag indicating that the field is physically stored in the database */
bool utf8; /* Already in utf8 */
bool automatic_name;
bool if_not_exists;
Item *expr;
Lex_ident name; /* Name of constraint */
/* see VCOL_* (VCOL_FIELD_REF, ...) */
uint flags;
Virtual_column_info()
:Type_handler_hybrid_field_type(&type_handler_null),
vcol_type((enum_vcol_info_type)VCOL_TYPE_NONE),
in_partitioning_expr(FALSE),
utf8(TRUE), automatic_name(FALSE), expr(NULL), flags(0)
{
name.str= NULL;
name.length= 0;
};
Virtual_column_info* clone(THD *thd);
~Virtual_column_info() = default;
enum_vcol_info_type get_vcol_type() const
{
return vcol_type;
}
void set_vcol_type(enum_vcol_info_type v_type)
{
vcol_type= v_type;
}
const char *get_vcol_type_name() const
{
DBUG_ASSERT(vcol_type != VCOL_TYPE_NONE);
return vcol_type_name(vcol_type);
}
void set_handler(const Type_handler *handler)
{
/* Calling this function can only be done once. */
DBUG_ASSERT(type_handler() == &type_handler_null);
Type_handler_hybrid_field_type::set_handler(handler);
}
bool is_stored() const
{
/* after reading the row vcol value is already in the buffer */
return vcol_type == VCOL_GENERATED_STORED;
}
bool is_in_partitioning_expr() const
{
return in_partitioning_expr;
}
void mark_as_in_partitioning_expr()
{
in_partitioning_expr= TRUE;
}
bool need_refix() const
{
return flags & VCOL_SESSION_FUNC;
}
bool fix_expr(THD *thd);
bool fix_session_expr(THD *thd);
bool cleanup_session_expr();
bool fix_and_check_expr(THD *thd, TABLE *table);
bool check_access(THD *thd);
inline bool is_equal(const Virtual_column_info* vcol, bool cmp_names) const;
inline void print(String*);
};
class Binlog_type_info
{
public:
enum binlog_sign_t
{
SIGN_SIGNED,
SIGN_UNSIGNED,
SIGN_NOT_APPLICABLE // for non-numeric types
};
/**
Retrieve the field metadata for fields.
*/
CHARSET_INFO *m_cs; // NULL if not relevant
TYPELIB *m_enum_typelib; // NULL if not relevant
TYPELIB *m_set_typelib; // NULL if not relevant
binlog_sign_t m_signedness;
uint16 m_metadata;
uint8 m_metadata_size;
uchar m_type_code; // according to Field::binlog_type()
uchar m_geom_type; // Non-geometry fields can return 0
Binlog_type_info(uchar type_code,
uint16 metadata,
uint8 metadata_size)
:m_cs(NULL),
m_enum_typelib(NULL),
m_set_typelib(NULL),
m_signedness(SIGN_NOT_APPLICABLE),
m_metadata(metadata),
m_metadata_size(metadata_size),
m_type_code(type_code),
m_geom_type(0)
{};
Binlog_type_info(uchar type_code, uint16 metadata,
uint8 metadata_size,
binlog_sign_t signedness)
: m_cs(NULL),
m_enum_typelib(NULL),
m_set_typelib(NULL),
m_signedness(signedness),
m_metadata(metadata),
m_metadata_size(metadata_size),
m_type_code(type_code),
m_geom_type(0)
{};
Binlog_type_info(uchar type_code, uint16 metadata,
uint8 metadata_size, CHARSET_INFO *cs)
:m_cs(cs),
m_enum_typelib(NULL),
m_set_typelib(NULL),
m_signedness(SIGN_NOT_APPLICABLE),
m_metadata(metadata),
m_metadata_size(metadata_size),
m_type_code(type_code),
m_geom_type(0)
{};
Binlog_type_info(uchar type_code, uint16 metadata,
uint8 metadata_size,
CHARSET_INFO *cs,
TYPELIB *t_enum, TYPELIB *t_set)
:m_cs(cs),
m_enum_typelib(t_enum),
m_set_typelib(t_set),
m_signedness(SIGN_NOT_APPLICABLE),
m_metadata(metadata),
m_metadata_size(metadata_size),
m_type_code(type_code),
m_geom_type(0)
{};
Binlog_type_info(uchar type_code, uint16 metadata,
uint8 metadata_size, CHARSET_INFO *cs,
uchar geom_type)
:m_cs(cs),
m_enum_typelib(NULL),
m_set_typelib(NULL),
m_signedness(SIGN_NOT_APPLICABLE),
m_metadata(metadata),
m_metadata_size(metadata_size),
m_type_code(type_code),
m_geom_type(geom_type)
{};
static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
{ return alloc_root(mem_root, size); }
};
class Binlog_type_info_fixed_string: public Binlog_type_info
{
public:
Binlog_type_info_fixed_string(uchar type_code,
uint32 octet_length,
CHARSET_INFO *cs);
};
class Field: public Value_source
{
Field(const Item &); /* Prevent use of these */
void operator=(Field &);
protected:
int save_in_field_str(Field *to)
{
StringBuffer result(charset());
val_str(&result);
return to->store(result.ptr(), result.length(), charset());
}
void error_generated_column_function_is_not_allowed(THD *thd, bool error)
const;
static void do_field_eq(const Copy_field *copy);
static void do_field_int(const Copy_field *copy);
static void do_field_real(const Copy_field *copy);
static void do_field_string(const Copy_field *copy);
static void do_field_date(const Copy_field *copy);
static void do_field_temporal(const Copy_field *copy, date_mode_t fuzzydate);
static void do_field_datetime(const Copy_field *copy);
static void do_field_timestamp(const Copy_field *copy);
static void do_field_decimal(const Copy_field *copy);
public:
static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
{ return alloc_root(mem_root, size); }
static void *operator new(size_t size) throw ()
{
DBUG_ASSERT(size < UINT_MAX32);
return thd_alloc(current_thd, (uint) size);
}
static void operator delete(void *ptr_arg, size_t size) { TRASH_FREE(ptr_arg, size); }
static void operator delete(void *ptr, MEM_ROOT *mem_root)
{ DBUG_ASSERT(0); }
bool marked_for_read() const;
bool marked_for_write_or_computed() const;
/**
Used by System Versioning.
*/
virtual void set_max()
{ DBUG_ASSERT(0); }
virtual bool is_max(const uchar *ptr_arg) const
{ DBUG_ASSERT(0); return false; }
bool is_max() const { return is_max(ptr); }
uchar *ptr; // Position to field in record
/**
Byte where the @c NULL bit is stored inside a record. If this Field is a
@c NOT @c NULL field, this member is @c NULL.
*/
uchar *null_ptr;
/*
Note that you can use table->in_use as replacement for current_thd member
only inside of val_*() and store() members (e.g. you can't use it in cons)
*/
TABLE *table; // Pointer for table
TABLE *orig_table; // Pointer to original table
const char * const *table_name; // Pointer to alias in TABLE
LEX_CSTRING field_name;
LEX_CSTRING comment;
/** reference to the list of options or NULL */
engine_option_value *option_list;
ha_field_option_struct *option_struct; /* structure with parsed options */
/* Field is part of the following keys */
key_map key_start, part_of_key, part_of_key_not_clustered;
/*
Bitmap of indexes that have records ordered by col1, ... this_field, ...
For example, INDEX (col(prefix_n)) is not present in col.part_of_sortkey.
*/
key_map part_of_sortkey;
/*
We use three additional unireg types for TIMESTAMP to overcome limitation
of current binary format of .frm file. We'd like to be able to support
NOW() as default and on update value for such fields but unable to hold
this info anywhere except unireg_check field. This issue will be resolved
in more clean way with transition to new text based .frm format.
See also comment for Field_timestamp::Field_timestamp().
*/
enum __attribute__((packed)) utype {
NONE=0,
NEXT_NUMBER=15, // AUTO_INCREMENT
TIMESTAMP_OLD_FIELD=18, // TIMESTAMP created before 4.1.3
TIMESTAMP_DN_FIELD=21, // TIMESTAMP DEFAULT NOW()
TIMESTAMP_UN_FIELD=22, // TIMESTAMP ON UPDATE NOW()
TIMESTAMP_DNUN_FIELD=23, // TIMESTAMP DEFAULT NOW() ON UPDATE NOW()
TMYSQL_COMPRESSED= 24, // Compatibility with TMySQL
};
enum imagetype { itRAW, itMBR};
utype unireg_check;
field_visibility_t invisible;
uint32 field_length; // Length of field
uint32 flags;
field_index_t field_index; // field number in fields array
uchar null_bit; // Bit used to test null bit
/**
If true, this field was created in create_tmp_field_from_item from a NULL
value. This means that the type of the field is just a guess, and the type
may be freely coerced to another type.
@see create_tmp_field_from_item
@see Item_type_holder::get_real_type
*/
bool is_created_from_null_item;
/*
Selectivity of the range condition over this field.
When calculating this selectivity a range predicate
is taken into account only if:
- it is extracted from the WHERE clause
- it depends only on the table the field belongs to
*/
double cond_selectivity;
/*
The next field in the class of equal fields at the top AND level
of the WHERE clause
*/
Field *next_equal_field;
/*
This structure is used for statistical data on the column
that has been read from the statistical table column_stat
*/
Column_statistics *read_stats;
/*
This structure is used for statistical data on the column that
is collected by the function collect_statistics_for_table
*/
Column_statistics_collected *collected_stats;
/*
This is additional data provided for any computed(virtual) field,
default function or check constraint.
In particular it includes a pointer to the item by which this field
can be computed from other fields.
*/
Virtual_column_info *vcol_info, *check_constraint, *default_value;
Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
uchar null_bit_arg, utype unireg_check_arg,
const LEX_CSTRING *field_name_arg);
virtual ~Field() = default;
virtual Type_numeric_attributes type_numeric_attributes() const
{
return Type_numeric_attributes(field_length, decimals(), is_unsigned());
}
Type_std_attributes type_std_attributes() const
{
return Type_std_attributes(type_numeric_attributes(), dtcollation());
}
bool is_unsigned() const { return flags & UNSIGNED_FLAG; }
bool check_assignability_from(const Type_handler *from, bool ignore) const;
bool check_assignability_from(const Field *from, bool ignore) const
{
return check_assignability_from(from->type_handler(), ignore);
}
/**
Convenience definition of a copy function returned by
Field::get_copy_func()
*/
typedef void Copy_func(const Copy_field*);
virtual Copy_func *get_copy_func(const Field *from) const= 0;
virtual Copy_func *get_copy_func_to(const Field *to) const
{
return to->get_copy_func(this);
}
/* Store functions returns 1 on overflow and -1 on fatal error */
virtual int store_field(Field *from) { return from->save_in_field(this); }
virtual int save_in_field(Field *to)= 0;
/**
Check if it is possible just copy the value
of the field 'from' to the field 'this', e.g. for
INSERT INTO t1 (field1) SELECT field2 FROM t2;
@param from - The field to copy from
@retval true - it is possible to just copy value of 'from' to 'this'
@retval false - conversion is needed
*/
virtual bool memcpy_field_possible(const Field *from) const= 0;
virtual bool make_empty_rec_store_default_value(THD *thd, Item *item);
virtual void make_empty_rec_reset()
{
reset();
}
virtual int store(const char *to, size_t length,CHARSET_INFO *cs)=0;
/*
This is used by engines like CSV and Federated to signal the field
that the data is going to be in text (rather than binary) representation,
even if cs points to &my_charset_bin.
If a Field distinguishes between text and binary formats (e.g. INET6),
we cannot call store(str,length,&my_charset_bin),
to avoid "field" mis-interpreting the data format as binary.
*/
virtual int store_text(const char *to, size_t length, CHARSET_INFO *cs)
{
return store(to, length, cs);
}
virtual int store_binary(const char *to, size_t length)
{
return store(to, length, &my_charset_bin);
}
virtual int store_hex_hybrid(const char *str, size_t length);
virtual int store(double nr)=0;
virtual int store(longlong nr, bool unsigned_val)=0;
virtual int store_decimal(const my_decimal *d)=0;
virtual int store_time_dec(const MYSQL_TIME *ltime, uint dec);
virtual int store_timestamp_dec(const timeval &ts, uint dec);
int store_timestamp(my_time_t timestamp, ulong sec_part)
{
return store_timestamp_dec(Timeval(timestamp, sec_part),
TIME_SECOND_PART_DIGITS);
}
/**
Store a value represented in native format
*/
virtual int store_native(const Native &value)
{
DBUG_ASSERT(0);
reset();
return 0;
}
int store_time(const MYSQL_TIME *ltime)
{ return store_time_dec(ltime, TIME_SECOND_PART_DIGITS); }
int store(const char *to, size_t length, CHARSET_INFO *cs,
enum_check_fields check_level);
int store_text(const char *to, size_t length, CHARSET_INFO *cs,
enum_check_fields check_level);
int store(const LEX_CSTRING *ls, CHARSET_INFO *cs)
{
DBUG_ASSERT(ls->length < UINT_MAX32);
return store(ls->str, (uint) ls->length, cs);
}
int store(const LEX_CSTRING &ls, CHARSET_INFO *cs)
{
DBUG_ASSERT(ls.length < UINT_MAX32);
return store(ls.str, (uint) ls.length, cs);
}
/*
@brief
Store minimum/maximum value of a column in the statistics table.
@param
field statistical table field
str value buffer
*/
virtual int store_to_statistical_minmax_field(Field *field, String *str);
/*
@brief
Store minimum/maximum value of a column from the statistical table.
@param
field statistical table field
str value buffer
*/
virtual int store_from_statistical_minmax_field(Field *field, String *str,
MEM_ROOT *mem);
#ifdef HAVE_MEM_CHECK
/**
Mark unused memory in the field as defined. Mainly used to ensure
that if we write full field to disk (for example in
Count_distinct_field::add(), we don't write unitalized data to
disk which would confuse valgrind or MSAN.
*/
virtual void mark_unused_memory_as_defined() {}
#else
void mark_unused_memory_as_defined() {}
#endif
virtual double val_real()=0;
virtual longlong val_int()=0;
/*
Get ulonglong representation.
Negative values are truncated to 0.
*/
virtual ulonglong val_uint(void)
{
longlong nr= val_int();
return nr < 0 ? 0 : (ulonglong) nr;
}
virtual bool val_bool()= 0;
virtual my_decimal *val_decimal(my_decimal *)=0;
inline String *val_str(String *str) { return val_str(str, str); }
/*
val_str(buf1, buf2) gets two buffers and should use them as follows:
if it needs a temp buffer to convert result to string - use buf1
example Field_tiny::val_str()
if the value exists as a string already - use buf2
example Field_string::val_str()
consequently, buf2 may be created as 'String buf;' - no memory
will be allocated for it. buf1 will be allocated to hold a
value if it's too small. Using allocated buffer for buf2 may result in
an unnecessary free (and later, may be an alloc).
This trickery is used to decrease a number of malloc calls.
*/
virtual String *val_str(String*,String *)=0;
virtual bool val_native(Native *to)
{
DBUG_ASSERT(!is_null());
return to->copy((const char *) ptr, pack_length());
}
String *val_int_as_str(String *val_buffer, bool unsigned_flag);
/*
Copy the Field::val_str() value to MEM_ROOT as a 0x00-teminated string.
@param mem_root The memory root to put the value to.
@returns {NULL,0} in case of EOM, or the field value otherwise.
Only one 0x00 terminating byte is put in the end, even in case
of complex character sets like UCS2/UTF16/UTF32.
This is OK, since this method is used to read system tables,
which are in utf8.
*/
LEX_STRING val_lex_string_strmake(MEM_ROOT *mem_root);
/*
Return the field value as a LEX_CSTRING, without padding to full length
(MODE_PAD_CHAR_TO_FULL_LENGTH is temporarily suppressed during the call).
In case of an empty value, to[0] is assigned to empty_clex_string,
memory is not allocated.
In case of a non-empty value, the memory is allocated on mem_root.
In case of a memory allocation failure, to[0] is assigned to {NULL,0}.
@param [IN] mem_root store non-empty values here
@param [OUT to return the string here
@retval false (success)
@retval true (EOM)
*/
bool val_str_nopad(MEM_ROOT *mem_root, LEX_CSTRING *to);
fast_field_copier get_fast_field_copier(const Field *from);
/*
str_needs_quotes() returns TRUE if the value returned by val_str() needs
to be quoted when used in constructing an SQL query.
*/
virtual bool str_needs_quotes() const { return false; }
const Type_handler *type_handler_for_comparison() const
{
return type_handler()->type_handler_for_comparison();
}
Item_result result_type () const
{
return type_handler()->result_type();
}
Item_result cmp_type () const
{
return type_handler()->cmp_type();
}
virtual bool eq(Field *field)
{
return (ptr == field->ptr && null_ptr == field->null_ptr &&
null_bit == field->null_bit && field->type() == type());
}
virtual bool eq_def(const Field *field) const;
/*
pack_length() returns size (in bytes) used to store field data in memory
(i.e. it returns the maximum size of the field in a row of the table,
which is located in RAM).
*/
virtual uint32 pack_length() const { return (uint32) field_length; }
/*
pack_length_in_rec() returns size (in bytes) used to store field data on
storage (i.e. it returns the maximal size of the field in a row of the
table, which is located on disk).
*/
virtual uint32 pack_length_in_rec() const { return pack_length(); }
virtual bool compatible_field_size(uint metadata, const Relay_log_info *rli,
uint16 mflags, int *order) const;
virtual uint pack_length_from_metadata(uint field_metadata) const
{
DBUG_ENTER("Field::pack_length_from_metadata");
DBUG_RETURN(field_metadata);
}
virtual uint row_pack_length() const { return 0; }
/*
data_length() return the "real size" of the data in memory.
*/
virtual uint32 data_length() { return pack_length(); }
virtual uint32 sort_length() const { return pack_length(); }
/*
sort_suffix_length() return the length bytes needed to store the length
for binary charset
*/
virtual uint32 sort_suffix_length() const { return 0; }
/*
Get the number bytes occupied by the value in the field.
CHAR values are stripped of trailing spaces.
Flexible values are stripped of their length.
*/
virtual uint32 value_length()
{
uint len;
if (!zero_pack() &&
(type() == MYSQL_TYPE_STRING &&
(len= pack_length()) >= 4 && len < 256))
{
uchar *str, *end;
for (str= ptr, end= str+len; end > str && end[-1] == ' '; end--) {}
len=(uint) (end-str);
return len;
}
return data_length();
}
/**
Get the maximum size of the data in packed format.
@return Maximum data length of the field when packed using the
Field::pack() function.
*/
virtual uint32 max_data_length() const {
return pack_length();
};
virtual int reset() { bzero(ptr,pack_length()); return 0; }
virtual void reset_fields() {}
const uchar *ptr_in_record(const uchar *record) const
{
my_ptrdiff_t l_offset= (my_ptrdiff_t) (ptr - table->record[0]);
DBUG_ASSERT(l_offset >= 0 && table->s->rec_buff_length - l_offset > 0);
return record + l_offset;
}
virtual int set_default();
bool has_update_default_function() const
{
return flags & ON_UPDATE_NOW_FLAG;
}
bool has_default_now_unireg_check() const
{
return unireg_check == TIMESTAMP_DN_FIELD
|| unireg_check == TIMESTAMP_DNUN_FIELD;
}
/*
Mark the field as having a value supplied by the client, thus it should
not be auto-updated.
*/
void set_has_explicit_value()
{
bitmap_set_bit(&table->has_value_set, field_index);
}
bool has_explicit_value() const
{
return bitmap_is_set(&table->has_value_set, field_index);
}
void clear_has_explicit_value()
{
bitmap_clear_bit(&table->has_value_set, field_index);
}
virtual my_time_t get_timestamp(const uchar *pos, ulong *sec_part) const
{ DBUG_ASSERT(0); return 0; }
my_time_t get_timestamp(ulong *sec_part) const
{
return get_timestamp(ptr, sec_part);
}
virtual bool binary() const { return 1; }
virtual bool zero_pack() const { return 1; }
virtual enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
virtual uint16 key_part_flag() const { return 0; }
virtual uint16 key_part_length_bytes() const { return 0; }
virtual uint32 key_length() const { return pack_length(); }
virtual const Type_handler *type_handler() const = 0;
virtual enum_field_types type() const
{
return type_handler()->field_type();
}
virtual enum_field_types real_type() const
{
return type_handler()->real_field_type();
}
virtual enum_field_types binlog_type() const
{
/*
Binlog stores field->type() as type code by default. For example,
it puts MYSQL_TYPE_STRING in case of CHAR, VARCHAR, SET and ENUM,
with extra data type details put into metadata.
Binlog behaviour slightly differs between various MySQL and MariaDB
versions for the temporal data types TIME, DATETIME and TIMESTAMP.
MySQL prior to 5.6 uses MYSQL_TYPE_TIME, MYSQL_TYPE_DATETIME
and MYSQL_TYPE_TIMESTAMP type codes in binlog and stores no
additional metadata.
MariaDB-5.3 implements new versions for TIME, DATATIME, TIMESTAMP
with fractional second precision, but uses the old format for the
types TIME(0), DATETIME(0), TIMESTAMP(0), and it still stores
MYSQL_TYPE_TIME, MYSQL_TYPE_DATETIME and MYSQL_TYPE_TIMESTAMP in binlog,
with no additional metadata.
So row-based replication between temporal data types of
different precision is not possible in MariaDB.
MySQL-5.6 also implements a new version of TIME, DATETIME, TIMESTAMP
which support fractional second precision 0..6, and use the new
format even for the types TIME(0), DATETIME(0), TIMESTAMP(0).
For these new data types, MySQL-5.6 stores new type codes
MYSQL_TYPE_TIME2, MYSQL_TYPE_DATETIME2, MYSQL_TYPE_TIMESTAMP2 in binlog,
with fractional precision 0..6 put into metadata.
This makes it in theory possible to do row-based replication between
columns of different fractional precision (e.g. from TIME(1) on master
to TIME(6) on slave). However, it's not currently fully implemented yet.
MySQL-5.6 can only do row-based replication from the old types
TIME, DATETIME, TIMESTAMP (represented by MYSQL_TYPE_TIME,
MYSQL_TYPE_DATETIME and MYSQL_TYPE_TIMESTAMP type codes in binlog)
to the new corresponding types TIME(0), DATETIME(0), TIMESTAMP(0).
Note: MariaDB starting from the version 10.0 understands the new
MySQL-5.6 type codes MYSQL_TYPE_TIME2, MYSQL_TYPE_DATETIME2,
MYSQL_TYPE_TIMESTAMP2. When started over MySQL-5.6 tables both on
master and on slave, MariaDB-10.0 can also do row-based replication
from the old types TIME, DATETIME, TIMESTAMP to the new MySQL-5.6
types TIME(0), DATETIME(0), TIMESTAMP(0).
Note: perhaps binlog should eventually be modified to store
real_type() instead of type() for all column types.
*/
return type();
}
virtual Binlog_type_info binlog_type_info() const
{
DBUG_ASSERT(Field::type() == binlog_type());
return Binlog_type_info(Field::type(), 0, 0);
}
virtual en_fieldtype tmp_engine_column_type(bool use_packed_rows) const
{
return FIELD_NORMAL;
}
/*
Conversion type for from the source to the current field.
*/
virtual enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m)
const= 0;
enum_conv_type rpl_conv_type_from_same_data_type(uint16 metadata,
const Relay_log_info *rli,
const Conv_param ¶m)
const;
inline int cmp(const uchar *str) const { return cmp(ptr,str); }
/*
The following method is used for comparing prefix keys.
Currently it's only used in partitioning.
*/
virtual int cmp_prefix(const uchar *a, const uchar *b,
size_t prefix_char_len) const
{ return cmp(a, b); }
virtual int cmp(const uchar *,const uchar *) const=0;
virtual int cmp_binary(const uchar *a,const uchar *b, uint32 max_length=~0U) const
{ return memcmp(a,b,pack_length()); }
virtual int cmp_offset(my_ptrdiff_t row_offset)
{ return cmp(ptr,ptr+row_offset); }
virtual int cmp_binary_offset(uint row_offset)
{ return cmp_binary(ptr, ptr+row_offset); };
virtual int key_cmp(const uchar *a,const uchar *b) const
{ return cmp(a, b); }
virtual int key_cmp(const uchar *str, uint length) const
{ return cmp(ptr,str); }
/*
Update the value m of the 'min_val' field with the current value v
of this field if force_update is set to TRUE or if v < m.
Return TRUE if the value has been updated.
*/
virtual bool update_min(Field *min_val, bool force_update)
{
bool update_fl= force_update || cmp(ptr, min_val->ptr) < 0;
if (update_fl)
{
min_val->set_notnull();
memcpy(min_val->ptr, ptr, pack_length());
}
return update_fl;
}
/*
Update the value m of the 'max_val' field with the current value v
of this field if force_update is set to TRUE or if v > m.
Return TRUE if the value has been updated.
*/
virtual bool update_max(Field *max_val, bool force_update)
{
bool update_fl= force_update || cmp(ptr, max_val->ptr) > 0;
if (update_fl)
{
max_val->set_notnull();
memcpy(max_val->ptr, ptr, pack_length());
}
return update_fl;
}
virtual void store_field_value(uchar *val, uint len)
{
memcpy(ptr, val, len);
}
virtual decimal_digits_t decimals() const { return 0; }
virtual Information_schema_numeric_attributes
information_schema_numeric_attributes() const
{
return Information_schema_numeric_attributes();
}
virtual Information_schema_character_attributes
information_schema_character_attributes() const
{
return Information_schema_character_attributes();
}
virtual void update_data_type_statistics(Data_type_statistics *st) const
{ }
/*
Caller beware: sql_type can change str.Ptr, so check
ptr() to see if it changed if you are using your own buffer
in str and restore it with set() if needed
*/
virtual void sql_type(String &str) const =0;
virtual void sql_rpl_type(String *str) const { sql_type(*str); }
virtual uint size_of() const =0; // For new field
inline bool is_null(my_ptrdiff_t row_offset= 0) const
{
/*
The table may have been marked as containing only NULL values
for all fields if it is a NULL-complemented row of an OUTER JOIN
or if the query is an implicitly grouped query (has aggregate
functions but no GROUP BY clause) with no qualifying rows. If
this is the case (in which TABLE::null_row is true), the field
is considered to be NULL.
Note that if a table->null_row is set then also all null_bits are
set for the row.
In the case of the 'result_field' for GROUP BY, table->null_row might
refer to the *next* row in the table (when the algorithm is: read the
next row, see if any of group column values have changed, send the
result - grouped - row to the client if yes). So, table->null_row might
be wrong, but such a result_field is always nullable (that's defined by
original_field->maybe_null()) and we trust its null bit.
*/
return null_ptr ? null_ptr[row_offset] & null_bit : table->null_row;
}
inline bool is_real_null(my_ptrdiff_t row_offset= 0) const
{ return null_ptr && (null_ptr[row_offset] & null_bit); }
inline bool is_null_in_record(const uchar *record) const
{
if (maybe_null_in_table())
return record[(uint) (null_ptr - table->record[0])] & null_bit;
return 0;
}
inline void set_null(my_ptrdiff_t row_offset= 0)
{ if (null_ptr) null_ptr[row_offset]|= null_bit; }
inline void set_notnull(my_ptrdiff_t row_offset= 0)
{ if (null_ptr) null_ptr[row_offset]&= (uchar) ~null_bit; }
inline bool maybe_null(void) const
{ return null_ptr != 0 || table->maybe_null; }
// Set to NULL on LOAD DATA or LOAD XML
virtual bool load_data_set_null(THD *thd);
// Reset when a LOAD DATA file ended unexpectedly
virtual bool load_data_set_no_data(THD *thd, bool fixed_format);
void load_data_set_value(const char *pos, uint length, CHARSET_INFO *cs);
/* @return true if this field is NULL-able (even if temporarily) */
inline bool real_maybe_null() const { return null_ptr != 0; }
uint null_offset(const uchar *record) const
{ return (uint) (null_ptr - record); }
/*
For a NULL-able field (that can actually store a NULL value in a table)
null_ptr points to the "null bitmap" in the table->record[0] header. For
NOT NULL fields it is either 0 or points outside table->record[0] into the
table->triggers->extra_null_bitmap (so that the field can store a NULL
value temporarily, only in memory)
*/
bool maybe_null_in_table() const
{ return null_ptr >= table->record[0] && null_ptr <= ptr; }
uint null_offset() const
{ return null_offset(table->record[0]); }
void set_null_ptr(uchar *p_null_ptr, uint p_null_bit)
{
null_ptr= p_null_ptr;
null_bit= static_cast(p_null_bit);
}
bool stored_in_db() const { return !vcol_info || vcol_info->is_stored(); }
bool check_vcol_sql_mode_dependency(THD *, vcol_init_mode mode) const;
virtual sql_mode_t value_depends_on_sql_mode() const
{
return 0;
}
virtual sql_mode_t conversion_depends_on_sql_mode(THD *thd,
Item *expr) const
{
return (sql_mode_t) 0;
}
virtual sql_mode_t can_handle_sql_mode_dependency_on_store() const
{
return 0;
}
inline THD *get_thd() const
{ return likely(table) ? table->in_use : current_thd; }
enum {
LAST_NULL_BYTE_UNDEF= 0
};
/*
Find the position of the last null byte for the field.
SYNOPSIS
last_null_byte()
DESCRIPTION
Return a pointer to the last byte of the null bytes where the
field conceptually is placed.
RETURN VALUE
The position of the last null byte relative to the beginning of
the record. If the field does not use any bits of the null
bytes, the value 0 (LAST_NULL_BYTE_UNDEF) is returned.
*/
size_t last_null_byte() const {
size_t bytes= do_last_null_byte();
DBUG_PRINT("debug", ("last_null_byte() ==> %ld", (long) bytes));
DBUG_ASSERT(bytes <= table->s->null_bytes);
return bytes;
}
/*
Create mem-comparable sort key part for a sort key
*/
void make_sort_key_part(uchar *buff, uint length);
/*
create a compact sort key which can be compared with a comparison
function. They are called packed sort keys
*/
virtual uint make_packed_sort_key_part(uchar *buff,
const SORT_FIELD_ATTR *sort_field);
virtual void make_send_field(Send_field *);
/*
Some implementations actually may write up to 8 bytes regardless of what
size was requested. This is due to the minimum value of the system variable
max_sort_length.
*/
virtual void sort_string(uchar *buff,uint length)=0;
virtual bool optimize_range(uint idx, uint part) const;
virtual void free() {}
virtual Field *make_new_field(MEM_ROOT *root, TABLE *new_table,
bool keep_type);
virtual Field *new_key_field(MEM_ROOT *root, TABLE *new_table,
uchar *new_ptr, uint32 length,
uchar *new_null_ptr, uint new_null_bit);
Field *create_tmp_field(MEM_ROOT *root, TABLE *new_table,
bool maybe_null_arg);
Field *create_tmp_field(MEM_ROOT *root, TABLE *new_table)
{
return create_tmp_field(root, new_table, maybe_null());
}
Field *clone(MEM_ROOT *mem_root, TABLE *new_table);
Field *clone(MEM_ROOT *mem_root, TABLE *new_table, my_ptrdiff_t diff);
inline void move_field(uchar *ptr_arg,uchar *null_ptr_arg,uchar null_bit_arg)
{
ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg;
}
inline void move_field(uchar *ptr_arg) { ptr=ptr_arg; }
inline uchar *record_ptr() // record[0] or wherever the field was moved to
{
my_ptrdiff_t offset= table->s->field[field_index]->ptr - table->s->default_values;
return ptr - offset;
}
virtual void move_field_offset(my_ptrdiff_t ptr_diff)
{
ptr=ADD_TO_PTR(ptr,ptr_diff, uchar*);
if (null_ptr)
{
null_ptr=ADD_TO_PTR(null_ptr,ptr_diff,uchar*);
if (table)
{
DBUG_ASSERT(null_ptr < ptr);
DBUG_ASSERT(ptr - null_ptr <= (int)table->s->rec_buff_length);
}
}
}
/*
Copy the Field's value to buff. The value will be in table->record[]
format.
*/
void get_image(uchar *buff, uint length, CHARSET_INFO *cs) const
{ get_image(buff, length, ptr, cs); }
virtual void get_image(uchar *buff, uint length,
const uchar *ptr_arg, CHARSET_INFO *cs) const
{ memcpy(buff,ptr_arg,length); }
/*
Set Field's value to the value in *buf.
*/
virtual void set_image(const uchar *buff,uint length, CHARSET_INFO *cs)
{ memcpy(ptr,buff,length); }
/*
Copy a field part into an output buffer.
SYNOPSIS
Field::get_key_image()
buff [out] output buffer
length output buffer size
type itMBR for geometry blobs, otherwise itRAW
DESCRIPTION
This function makes a copy of field part of size equal to or
less than "length" parameter value.
For fields of string types (CHAR, VARCHAR, TEXT) the rest of buffer
is padded by zero byte.
NOTES
For variable length character fields (i.e. UTF-8) the "length"
parameter means a number of output buffer bytes as if all field
characters have maximal possible size (mbmaxlen). In the other words,
"length" parameter is a number of characters multiplied by
field_charset->mbmaxlen.
RETURN
Number of copied bytes (excluding padded zero bytes -- see above).
*/
uint get_key_image(uchar *buff, uint length, imagetype type_arg) const
{ return get_key_image(buff, length, ptr, type_arg); }
virtual uint get_key_image(uchar *buff, uint length, const uchar *ptr_arg, imagetype type_arg) const
{
get_image(buff, length, ptr_arg, &my_charset_bin);
return length;
}
virtual void set_key_image(const uchar *buff,uint length)
{ set_image(buff,length, &my_charset_bin); }
inline longlong val_int_offset(uint row_offset)
{
ptr+=row_offset;
longlong tmp=val_int();
ptr-=row_offset;
return tmp;
}
inline longlong val_int(const uchar *new_ptr)
{
uchar *old_ptr= ptr;
longlong return_value;
ptr= (uchar*) new_ptr;
return_value= val_int();
ptr= old_ptr;
return return_value;
}
inline String *val_str(String *str, const uchar *new_ptr)
{
uchar *old_ptr= ptr;
ptr= (uchar*) new_ptr;
val_str(str);
ptr= old_ptr;
return str;
}
virtual bool send(Protocol *protocol);
virtual uchar *pack(uchar *to, const uchar *from, uint max_length);
/**
@overload Field::pack(uchar*, const uchar*, uint, bool)
*/
uchar *pack(uchar *to, const uchar *from)
{
DBUG_ENTER("Field::pack");
uchar *result= this->pack(to, from, UINT_MAX);
DBUG_RETURN(result);
}
virtual const uchar *unpack(uchar* to, const uchar *from,
const uchar *from_end, uint param_data=0);
virtual uint packed_col_length(const uchar *to, uint length)
{ return length;}
virtual uint max_packed_col_length(uint max_length)
{ return max_length;}
virtual bool is_packable() const { return false; }
uint offset(const uchar *record) const
{
return (uint) (ptr - record);
}
void copy_from_tmp(int offset);
uint fill_cache_field(struct st_cache_field *copy);
virtual bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate);
virtual longlong val_datetime_packed(THD *thd);
virtual longlong val_time_packed(THD *thd);
virtual const TYPELIB *get_typelib() const { return NULL; }
virtual CHARSET_INFO *charset() const= 0;
/* returns TRUE if the new charset differs. */
virtual void change_charset(const DTCollation &new_cs) {}
virtual const DTCollation &dtcollation() const= 0;
virtual CHARSET_INFO *charset_for_protocol(void) const
{ return binary() ? &my_charset_bin : charset(); }
virtual CHARSET_INFO *sort_charset(void) const { return charset(); }
virtual bool has_charset(void) const { return FALSE; }
virtual int set_time() { return 1; }
bool set_warning(Sql_condition::enum_warning_level, unsigned int code,
int cuted_increment, ulong current_row=0) const;
virtual void print_key_value(String *out, uint32 length);
void print_key_part_value(String *out, const uchar *key, uint32 length);
void print_key_value_binary(String *out, const uchar* key, uint32 length);
void raise_note_cannot_use_key_part(THD *thd, uint keynr, uint part,
const LEX_CSTRING &op,
CHARSET_INFO *op_collation,
Item *value,
const Data_type_compatibility reason)
const;
void raise_note_key_become_unused(THD *thd, const String &expr) const;
protected:
bool set_warning(unsigned int code, int cuted_increment) const
{
return set_warning(Sql_condition::WARN_LEVEL_WARN, code, cuted_increment);
}
bool set_note(unsigned int code, int cuted_increment) const
{
return set_warning(Sql_condition::WARN_LEVEL_NOTE, code, cuted_increment);
}
void set_datetime_warning(Sql_condition::enum_warning_level, uint code,
const ErrConv *str, const char *typestr,
int cuted_increment) const;
void set_datetime_warning(uint code,
const ErrConv *str, const char *typestr,
int cuted_increment) const
{
set_datetime_warning(Sql_condition::WARN_LEVEL_WARN, code, str, typestr,
cuted_increment);
}
void set_warning_truncated_wrong_value(const char *type, const char *value);
inline bool check_overflow(int op_result)
{
return (op_result == E_DEC_OVERFLOW);
}
int warn_if_overflow(int op_result);
Copy_func *get_identical_copy_func() const;
bool cmp_is_done_using_type_handler_of_this(const Item_bool_func *cond,
const Item *item) const;
Data_type_compatibility can_optimize_scalar_range(
const RANGE_OPT_PARAM *param,
const KEY_PART *key_part,
const Item_bool_func *cond,
scalar_comparison_op op,
Item *value) const;
uchar *make_key_image(MEM_ROOT *mem_root, const KEY_PART *key_part);
SEL_ARG *get_mm_leaf_int(RANGE_OPT_PARAM *param, KEY_PART *key_part,
const Item_bool_func *cond,
scalar_comparison_op op, Item *value,
bool unsigned_field);
/*
Make a leaf tree for the cases when the value was stored
to the field exactly, without any truncation, rounding or adjustments.
For example, if we stored an INT value into an INT column,
and value->save_in_field_no_warnings() returned 0,
we know that the value was stored exactly.
*/
SEL_ARG *stored_field_make_mm_leaf_exact(RANGE_OPT_PARAM *param,
KEY_PART *key_part,
scalar_comparison_op op,
Item *value);
/*
Make a leaf tree for the cases when we don't know if
the value was stored to the field without any data loss,
or was modified to a smaller or a greater value.
Used for the data types whose methods Field::store*()
silently adjust the value. This is the most typical case.
*/
SEL_ARG *stored_field_make_mm_leaf(RANGE_OPT_PARAM *param,
KEY_PART *key_part,
scalar_comparison_op op, Item *value);
/*
Make a leaf tree when an INT value was stored into a field of INT type,
and some truncation happened. Tries to adjust the range search condition
when possible, e.g. "tinytint < 300" -> "tinyint <= 127".
Can also return SEL_ARG_IMPOSSIBLE(), and NULL (not sargable).
*/
SEL_ARG *stored_field_make_mm_leaf_bounded_int(RANGE_OPT_PARAM *param,
KEY_PART *key_part,
scalar_comparison_op op,
Item *value,
bool unsigned_field);
/*
Make a leaf tree when some truncation happened during
value->save_in_field_no_warning(this), and we cannot yet adjust the range
search condition for the current combination of the field and the value
data types.
Returns SEL_ARG_IMPOSSIBLE() for "=" and "<=>".
Returns NULL (not sargable) for other comparison operations.
*/
SEL_ARG *stored_field_make_mm_leaf_truncated(RANGE_OPT_PARAM *prm,
scalar_comparison_op,
Item *value);
public:
void set_table_name(String *alias)
{
table_name= &alias->Ptr;
}
void init(TABLE *table_arg)
{
orig_table= table= table_arg;
set_table_name(&table_arg->alias);
}
virtual void init_for_tmp_table(Field *org_field, TABLE *new_table)
{
init(new_table);
orig_table= org_field->orig_table;
vcol_info= 0;
cond_selectivity= 1.0;
next_equal_field= NULL;
option_list= NULL;
option_struct= NULL;
if (org_field->type() == MYSQL_TYPE_VAR_STRING ||
org_field->type() == MYSQL_TYPE_VARCHAR)
new_table->s->db_create_options|= HA_OPTION_PACK_RECORD;
}
void init_for_make_new_field(TABLE *new_table_arg, TABLE *orig_table_arg)
{
init(new_table_arg);
/*
Normally orig_table is different from table only if field was
created via ::make_new_field. Here we alter the type of field,
so ::make_new_field is not applicable. But we still need to
preserve the original field metadata for the client-server
protocol.
*/
orig_table= orig_table_arg;
}
/* maximum possible display length */
virtual uint32 max_display_length() const= 0;
/**
Whether a field being created has the samle type.
Used by the ALTER TABLE
*/
virtual bool is_equal(const Column_definition &new_field) const= 0;
/* convert decimal to longlong with overflow check */
longlong convert_decimal2longlong(const my_decimal *val, bool unsigned_flag,
int *err);
/*
Maximum number of bytes in character representation.
- For string types it is equal to the field capacity, in bytes.
- For non-string types it represents the longest possible string length
after conversion to string.
*/
virtual uint32 character_octet_length() const
{
return field_length;
}
/* The max. number of characters */
virtual uint32 char_length() const
{
return field_length / charset()->mbmaxlen;
}
ha_storage_media field_storage_type() const
{
return (ha_storage_media)
((flags >> FIELD_FLAGS_STORAGE_MEDIA) & 3);
}
void set_storage_type(ha_storage_media storage_type_arg)
{
DBUG_ASSERT(field_storage_type() == HA_SM_DEFAULT);
flags |= static_cast(storage_type_arg) <<
FIELD_FLAGS_STORAGE_MEDIA;
}
column_format_type column_format() const
{
return (column_format_type)
((flags >> FIELD_FLAGS_COLUMN_FORMAT) & 3);
}
void set_column_format(column_format_type column_format_arg)
{
DBUG_ASSERT(column_format() == COLUMN_FORMAT_TYPE_DEFAULT);
flags |= static_cast(column_format_arg) <<
FIELD_FLAGS_COLUMN_FORMAT;
}
bool vers_sys_field() const
{
return flags & (VERS_ROW_START | VERS_ROW_END);
}
bool vers_sys_start() const
{
return flags & VERS_ROW_START;
}
bool vers_sys_end() const
{
return flags & VERS_ROW_END;
}
bool vers_update_unversioned() const
{
return flags & VERS_UPDATE_UNVERSIONED_FLAG;
}
/*
Validate a non-null field value stored in the given record
according to the current thread settings, e.g. sql_mode.
@param thd - the thread
@param record - the record to check in
*/
virtual bool validate_value_in_record(THD *thd, const uchar *record) const
{ return false; }
bool validate_value_in_record_with_warn(THD *thd, const uchar *record);
key_map get_possible_keys();
/* Hash value */
void hash(Hasher *hasher)
{
if (is_null())
hasher->add_null();
else
hash_not_null(hasher);
}
virtual void hash_not_null(Hasher *hasher);
/**
Get the upper limit of the MySQL integral and floating-point type.
@return maximum allowed value for the field
*/
virtual ulonglong get_max_int_value() const
{
DBUG_ASSERT(false);
return 0ULL;
}
/**
Checks whether a string field is part of write_set.
@return
FALSE - If field is not char/varchar/....
- If field is char/varchar/.. and is not part of write set.
TRUE - If field is char/varchar/.. and is part of write set.
*/
virtual bool is_varchar_and_in_write_set() const { return FALSE; }
/* Check whether the field can be used as a join attribute in hash join */
virtual bool hash_join_is_possible() { return TRUE; }
virtual bool eq_cmp_as_binary() { return TRUE; }
/* Position of the field value within the interval of [min, max] */
virtual double pos_in_interval(Field *min, Field *max)
{
return (double) 0.5;
}
virtual bool pos_through_val_str() { return false;}
/*
Check if comparison between the field and an item unambiguously
identifies a distinct field value.
Example1: SELECT * FROM t1 WHERE int_column=10;
This example returns distinct integer value of 10.
Example2: SELECT * FROM t1 WHERE varchar_column=DATE'2001-01-01'
This example returns non-distinct values.
Comparison as DATE will return '2001-01-01' and '2001-01-01x',
but these two values are not equal to each other as VARCHARs.
See also the function with the same name in sql_select.cc.
*/
virtual bool test_if_equality_guarantees_uniqueness(const Item *const_item)
const;
virtual bool can_be_substituted_to_equal_item(const Context &ctx,
const Item_equal *item);
virtual Item *get_equal_const_item(THD *thd, const Context &ctx,
Item *const_item)
{
return const_item;
}
virtual Data_type_compatibility can_optimize_keypart_ref(
const Item_bool_func *cond,
const Item *item) const;
virtual Data_type_compatibility can_optimize_hash_join(
const Item_bool_func *cond,
const Item *item) const
{
return can_optimize_keypart_ref(cond, item);
}
virtual Data_type_compatibility can_optimize_group_min_max(
const Item_bool_func *cond,
const Item *const_item) const;
/**
Test if Field can use range optimizer for a standard comparison operation:
<=, <, =, <=>, >, >=
Note, this method does not cover spatial operations.
*/
virtual Data_type_compatibility can_optimize_range(const Item_bool_func *cond,
const Item *item,
bool is_eq_func) const;
virtual SEL_ARG *get_mm_leaf(RANGE_OPT_PARAM *param, KEY_PART *key_part,
const Item_bool_func *cond,
scalar_comparison_op op, Item *value)= 0;
Data_type_compatibility can_optimize_outer_join_table_elimination(
const Item_bool_func *cond,
const Item *item) const
{
// Exactly the same rules with REF access
return can_optimize_keypart_ref(cond, item);
}
bool save_in_field_default_value(bool view_eror_processing);
bool save_in_field_ignore_value(bool view_error_processing);
/* Mark field in read map. Updates also virtual fields */
void register_field_in_read_map();
virtual Compression_method *compression_method() const { return 0; }
virtual Virtual_tmp_table **virtual_tmp_table_addr()
{
return NULL;
}
virtual bool sp_prepare_and_store_item(THD *thd, Item **value);
friend int cre_myisam(char * name, TABLE *form, uint options,
ulonglong auto_increment_value);
friend class Copy_field;
friend class Item_avg_field;
friend class Item_std_field;
friend class Item_sum_num;
friend class Item_sum_sum;
friend class Item_sum_count;
friend class Item_sum_avg;
friend class Item_sum_std;
friend class Item_sum_min;
friend class Item_sum_max;
friend class Item_func_group_concat;
private:
/*
Primitive for implementing last_null_byte().
SYNOPSIS
do_last_null_byte()
DESCRIPTION
Primitive for the implementation of the last_null_byte()
function. This represents the inheritance interface and can be
overridden by subclasses.
*/
virtual size_t do_last_null_byte() const;
protected:
uchar *pack_int(uchar *to, const uchar *from, size_t size)
{
memcpy(to, from, size);
return to + size;
}
const uchar *unpack_int(uchar* to, const uchar *from,
const uchar *from_end, size_t size)
{
if (from + size > from_end)
return 0;
memcpy(to, from, size);
return from + size;
}
uchar *pack_int16(uchar *to, const uchar *from)
{ return pack_int(to, from, 2); }
const uchar *unpack_int16(uchar* to, const uchar *from, const uchar *from_end)
{ return unpack_int(to, from, from_end, 2); }
uchar *pack_int24(uchar *to, const uchar *from)
{ return pack_int(to, from, 3); }
const uchar *unpack_int24(uchar* to, const uchar *from, const uchar *from_end)
{ return unpack_int(to, from, from_end, 3); }
uchar *pack_int32(uchar *to, const uchar *from)
{ return pack_int(to, from, 4); }
const uchar *unpack_int32(uchar* to, const uchar *from, const uchar *from_end)
{ return unpack_int(to, from, from_end, 4); }
uchar *pack_int64(uchar* to, const uchar *from)
{ return pack_int(to, from, 8); }
const uchar *unpack_int64(uchar* to, const uchar *from, const uchar *from_end)
{ return unpack_int(to, from, from_end, 8); }
double pos_in_interval_val_real(Field *min, Field *max);
double pos_in_interval_val_str(Field *min, Field *max, uint data_offset);
};
class Field_num :public Field {
protected:
int check_edom_and_important_data_truncation(const char *type, bool edom,
CHARSET_INFO *cs,
const char *str, size_t length,
const char *end_of_num);
int check_edom_and_truncation(const char *type, bool edom,
CHARSET_INFO *cs,
const char *str, size_t length,
const char *end_of_num);
int check_int(CHARSET_INFO *cs, const char *str, size_t length,
const char *int_end, int error)
{
return check_edom_and_truncation("integer",
error == MY_ERRNO_EDOM || str == int_end,
cs, str, length, int_end);
}
bool get_int(CHARSET_INFO *cs, const char *from, size_t len,
longlong *rnd, ulonglong unsigned_max,
longlong signed_min, longlong signed_max);
void prepend_zeros(String *value) const;
Item *get_equal_zerofill_const_item(THD *thd, const Context &ctx,
Item *const_item);
Binlog_type_info::binlog_sign_t binlog_signedness() const
{
return (flags & UNSIGNED_FLAG) ? Binlog_type_info::SIGN_UNSIGNED :
Binlog_type_info::SIGN_SIGNED;
}
bool send_numeric_zerofill_str(Protocol_text *protocol,
protocol_send_type_t send_type);
public:
const decimal_digits_t dec;
bool zerofill,unsigned_flag; // Purify cannot handle bit fields
Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg, utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
decimal_digits_t dec_arg, bool zero_arg, bool unsigned_arg);
CHARSET_INFO *charset() const override
{
return DTCollation_numeric::singleton().collation;
}
const DTCollation &dtcollation() const override
{
return DTCollation_numeric::singleton();
}
sql_mode_t can_handle_sql_mode_dependency_on_store() const override;
Item *get_equal_const_item(THD *thd, const Context &ctx, Item *const_item)
override
{
return (flags & ZEROFILL_FLAG) ?
get_equal_zerofill_const_item(thd, ctx, const_item) :
const_item;
}
void add_zerofill_and_unsigned(String &res) const;
friend class Create_field;
void make_send_field(Send_field *) override;
decimal_digits_t decimals() const override { return dec; }
uint size_of() const override { return sizeof(*this); }
bool eq_def(const Field *field) const override;
Copy_func *get_copy_func(const Field *from) const override
{
if (unsigned_flag && from->cmp_type() == DECIMAL_RESULT)
return do_field_decimal;
return do_field_int;
}
int save_in_field(Field *to) override
{
return to->store(val_int(), MY_TEST(flags & UNSIGNED_FLAG));
}
bool is_equal(const Column_definition &new_field) const override;
uint row_pack_length() const override { return pack_length(); }
uint32 pack_length_from_metadata(uint field_metadata) const override
{
uint32 length= pack_length();
DBUG_PRINT("result", ("pack_length_from_metadata(%d): %u",
field_metadata, length));
return length;
}
double pos_in_interval(Field *min, Field *max) override
{
return pos_in_interval_val_real(min, max);
}
SEL_ARG *get_mm_leaf(RANGE_OPT_PARAM *param, KEY_PART *key_part,
const Item_bool_func *cond,
scalar_comparison_op op, Item *value) override;
Binlog_type_info binlog_type_info() const override
{
DBUG_ASSERT(Field_num::type() == binlog_type());
return Binlog_type_info(Field_num::type(), 0, 0, binlog_signedness());
}
};
class Field_str :public Field {
protected:
DTCollation m_collation;
// A short alias for m_collation.collation with non-virtual linkage
const CHARSET_INFO *field_charset() const { return m_collation.collation; }
uint mbmaxlen() const { return m_collation.collation->mbmaxlen; }
public:
bool can_be_substituted_to_equal_item(const Context &ctx,
const Item_equal *item_equal) override;
Field_str(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg, utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
const DTCollation &collation);
decimal_digits_t decimals() const override
{ return is_created_from_null_item ? 0 : DECIMAL_NOT_SPECIFIED; }
int save_in_field(Field *to) override { return save_in_field_str(to); }
bool memcpy_field_possible(const Field *from) const override
{
return real_type() == from->real_type() &&
pack_length() == from->pack_length() &&
charset() == from->charset();
}
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int store_decimal(const my_decimal *) override;
int store(const char *to,size_t length,CHARSET_INFO *cs) override=0;
int store_hex_hybrid(const char *str, size_t length) override
{
return store(str, length, &my_charset_bin);
}
CHARSET_INFO *charset() const override { return m_collation.collation; }
const DTCollation &dtcollation() const override
{
return m_collation;
}
void change_charset(const DTCollation &new_cs) override;
bool binary() const override { return field_charset() == &my_charset_bin; }
uint32 max_display_length() const override { return field_length; }
uint32 character_octet_length() const override { return field_length; }
uint32 char_length() const override
{
return field_length / mbmaxlen();
}
Information_schema_character_attributes
information_schema_character_attributes() const override
{
return Information_schema_character_attributes(max_display_length(),
char_length());
}
friend class Create_field;
my_decimal *val_decimal(my_decimal *) override;
bool val_bool() override { return val_real() != 0e0; }
bool str_needs_quotes() const override { return true; }
bool eq_cmp_as_binary() override { return MY_TEST(flags & BINARY_FLAG); }
virtual uint length_size() const { return 0; }
double pos_in_interval(Field *min, Field *max) override
{
return pos_in_interval_val_str(min, max, length_size());
}
bool pos_through_val_str() override {return true;}
bool test_if_equality_guarantees_uniqueness(const Item *const_item) const
override;
SEL_ARG *get_mm_leaf(RANGE_OPT_PARAM *param, KEY_PART *key_part,
const Item_bool_func *cond,
scalar_comparison_op op, Item *value) override;
Binlog_type_info binlog_type_info() const override
{
DBUG_ASSERT(Field_str::type() == binlog_type());
return Binlog_type_info(Field_str::type(), 0, 0, charset());
}
};
/* base class for Field_string, Field_varstring and Field_blob */
class Field_longstr :public Field_str
{
protected:
int report_if_important_data(const char *ptr, const char *end,
bool count_spaces);
bool check_string_copy_error(const String_copier *copier,
const char *end, CHARSET_INFO *cs);
int check_conversion_status(const String_copier *copier,
const char *end, CHARSET_INFO *cs,
bool count_spaces)
{
if (check_string_copy_error(copier, end, cs))
return 2;
return report_if_important_data(copier->source_end_pos(),
end, count_spaces);
}
int well_formed_copy_with_check(char *to, size_t to_length,
CHARSET_INFO *from_cs,
const char *from, size_t from_length,
size_t nchars, bool count_spaces,
uint *copy_length)
{
String_copier copier;
*copy_length= copier.well_formed_copy(field_charset(), to, to_length,
from_cs, from, from_length,
nchars);
return check_conversion_status(&copier, from + from_length, from_cs, count_spaces);
}
Data_type_compatibility cmp_to_string_with_same_collation(
const Item_bool_func *cond,
const Item *item) const;
Data_type_compatibility cmp_to_string_with_stricter_collation(
const Item_bool_func *cond,
const Item *item) const;
int compress(char *to, uint to_length,
const char *from, uint length,
uint max_length,
uint *out_length,
CHARSET_INFO *cs, size_t nchars);
String *uncompress(String *val_buffer, String *val_ptr,
const uchar *from, uint from_length) const;
public:
Field_longstr(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg, utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
const DTCollation &collation)
:Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
field_name_arg, collation)
{}
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
int store_decimal(const my_decimal *d) override;
uint32 max_data_length() const override;
void make_send_field(Send_field *) override;
bool send(Protocol *protocol) override;
bool is_varchar_and_in_write_set() const override
{
DBUG_ASSERT(table && table->write_set);
return bitmap_is_set(table->write_set, field_index);
}
bool match_collation_to_optimize_range() const { return true; }
Data_type_compatibility can_optimize_keypart_ref(const Item_bool_func *cond,
const Item *item)
const override;
Data_type_compatibility can_optimize_hash_join(const Item_bool_func *cond,
const Item *item)
const override;
Data_type_compatibility can_optimize_group_min_max(const Item_bool_func *cond,
const Item *const_item)
const override;
Data_type_compatibility can_optimize_range(const Item_bool_func *cond,
const Item *item,
bool is_eq_func) const override;
bool is_packable() const override { return true; }
uint make_packed_sort_key_part(uchar *buff,
const SORT_FIELD_ATTR *sort_field)override;
uchar* pack_sort_string(uchar *to, const SORT_FIELD_ATTR *sort_field);
};
/* base class for float and double and decimal (old one) */
class Field_real :public Field_num {
protected:
double get_double(const char *str, size_t length, CHARSET_INFO *cs, int *err);
public:
bool not_fixed;
Field_real(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg, utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
decimal_digits_t dec_arg, bool zero_arg, bool unsigned_arg)
:Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
field_name_arg, dec_arg, zero_arg, unsigned_arg),
not_fixed(dec_arg >= FLOATING_POINT_DECIMALS)
{}
Copy_func *get_copy_func(const Field *from) const override
{
return do_field_real;
}
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
Information_schema_numeric_attributes
information_schema_numeric_attributes() const override
{
return dec == DECIMAL_NOT_SPECIFIED ?
Information_schema_numeric_attributes(field_length) :
Information_schema_numeric_attributes(field_length, dec);
}
void sql_type(String &str) const override;
int save_in_field(Field *to) override { return to->store(val_real()); }
bool memcpy_field_possible(const Field *from) const override
{
/*
Cannot do memcpy from a longer field to a shorter field,
e.g. a DOUBLE(53,10) into a DOUBLE(10,10).
But it should be OK the other way around.
*/
return real_type() == from->real_type() &&
pack_length() == from->pack_length() &&
is_unsigned() <= from->is_unsigned() &&
decimals() == from->decimals() &&
field_length >= from->field_length;
}
int store_decimal(const my_decimal *dec) override
{ return store(dec->to_double()); }
int store_time_dec(const MYSQL_TIME *ltime, uint dec) override;
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
my_decimal *val_decimal(my_decimal *) override;
bool val_bool() override { return val_real() != 0e0; }
uint32 max_display_length() const override { return field_length; }
uint size_of() const override { return sizeof *this; }
Item *get_equal_const_item(THD *thd, const Context &ctx, Item *const_item)
override;
};
class Field_decimal final :public Field_real {
public:
Field_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
decimal_digits_t dec_arg, bool zero_arg,bool unsigned_arg)
:Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg,
dec_arg, zero_arg, unsigned_arg)
{}
Field *make_new_field(MEM_ROOT *root, TABLE *new_table, bool keep_type)
override;
const Type_handler *type_handler() const override
{ return &type_handler_olddecimal; }
enum ha_base_keytype key_type() const override
{ return zerofill ? HA_KEYTYPE_BINARY : HA_KEYTYPE_NUM; }
Information_schema_numeric_attributes
information_schema_numeric_attributes() const override
{
uint tmp= dec ? 2 : 1; // The sign and the decimal point
return Information_schema_numeric_attributes(field_length - tmp, dec);
}
Copy_func *get_copy_func(const Field *from) const override
{
return eq_def(from) ? get_identical_copy_func() : do_field_string;
}
int reset() override;
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
void overflow(bool negative);
bool zero_pack() const override { return false; }
void sql_type(String &str) const override;
uchar *pack(uchar* to, const uchar *from, uint max_length) override
{
return Field::pack(to, from, max_length);
}
};
/* New decimal/numeric field which use fixed point arithmetic */
class Field_new_decimal final :public Field_num {
public:
/* The maximum number of decimal digits can be stored */
decimal_digits_t precision;
uint32 bin_size;
/*
Constructors take max_length of the field as a parameter - not the
precision as the number of decimal digits allowed.
So for example we need to count length from precision handling
CREATE TABLE ( DECIMAL(x,y))
*/
Field_new_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
decimal_digits_t dec_arg, bool zero_arg, bool unsigned_arg);
const Type_handler *type_handler() const override
{ return &type_handler_newdecimal; }
enum ha_base_keytype key_type() const override { return HA_KEYTYPE_BINARY; }
Copy_func *get_copy_func(const Field *from) const override
{
// if (from->real_type() == MYSQL_TYPE_BIT) // QQ: why?
// return do_field_int;
return do_field_decimal;
}
int save_in_field(Field *to) override
{
my_decimal tmp(ptr, precision, dec);
return to->store_decimal(&tmp);
}
bool memcpy_field_possible(const Field *from) const override
{
return real_type() == from->real_type() &&
pack_length() == from->pack_length() &&
is_unsigned() <= from->is_unsigned() &&
decimals() == from->decimals() &&
field_length == from->field_length;
}
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
int reset() override;
bool store_value(const my_decimal *decimal_value);
bool store_value(const my_decimal *decimal_value, int *native_error);
void set_value_on_overflow(my_decimal *decimal_value, bool sign);
int store(const char *to, size_t length, CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int store_time_dec(const MYSQL_TIME *ltime, uint dec) override;
int store_decimal(const my_decimal *) override;
double val_real() override
{
return my_decimal(ptr, precision, dec).to_double();
}
longlong val_int() override
{
return my_decimal(ptr, precision, dec).to_longlong(unsigned_flag);
}
ulonglong val_uint() override
{
return (ulonglong) my_decimal(ptr, precision, dec).to_longlong(true);
}
my_decimal *val_decimal(my_decimal *) override;
String *val_str(String *val_buffer, String *) override
{
uint fixed_precision= zerofill ? precision : 0;
return my_decimal(ptr, precision, dec).
to_string(val_buffer, fixed_precision, dec, '0');
}
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override
{
my_decimal nr(ptr, precision, dec);
return decimal_to_datetime_with_warn(get_thd(), &nr, ltime,
fuzzydate, table->s, field_name.str);
}
bool val_bool() override
{
return my_decimal(ptr, precision, dec).to_bool();
}
int cmp(const uchar *, const uchar *) const override;
void sort_string(uchar *buff, uint length) override;
bool zero_pack() const override { return false; }
void sql_type(String &str) const override;
uint32 max_display_length() const override { return field_length; }
Information_schema_numeric_attributes
information_schema_numeric_attributes() const override
{
return Information_schema_numeric_attributes(precision, dec);
}
uint size_of() const override { return sizeof *this; }
uint32 pack_length() const override { return bin_size; }
uint pack_length_from_metadata(uint field_metadata) const override;
uint row_pack_length() const override { return pack_length(); }
bool compatible_field_size(uint field_metadata, const Relay_log_info *rli,
uint16 mflags, int *order_var) const override;
bool is_equal(const Column_definition &new_field) const override;
const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end,
uint param_data) override;
Item *get_equal_const_item(THD *thd, const Context &ctx, Item *const_item)
override;
Binlog_type_info binlog_type_info() const override;
};
class Field_int :public Field_num
{
protected:
String *val_str_from_long(String *val_buffer, uint max_char_length,
int radix, long nr);
public:
Field_int(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg, bool zero_arg, bool unsigned_arg)
:Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, 0, zero_arg, unsigned_arg)
{}
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
bool memcpy_field_possible(const Field *from) const override
{
return real_type() == from->real_type() &&
pack_length() == from->pack_length() &&
is_unsigned() == from->is_unsigned();
}
int store_decimal(const my_decimal *) override;
my_decimal *val_decimal(my_decimal *) override;
bool val_bool() override { return val_int() != 0; }
ulonglong val_uint() override
{
longlong nr= val_int();
return nr < 0 && !unsigned_flag ? 0 : (ulonglong) nr;
}
int store_time_dec(const MYSQL_TIME *ltime, uint dec) override;
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
virtual const Type_limits_int *type_limits_int() const= 0;
uint32 max_display_length() const override
{
return type_limits_int()->char_length();
}
Type_numeric_attributes type_numeric_attributes() const override
{
/*
For integer data types, the user-specified length does not constrain the
supported range, so e.g. a column of the INT(1) data type supports the
full integer range anyway.
Choose the maximum from the user-specified length and the maximum
possible length determined by the data type capacity:
INT(1) -> 11
INT(10) -> 11
INT(40) -> 40
*/
uint32 length1= max_display_length();
uint32 length2= field_length;
return Type_numeric_attributes(MY_MAX(length1, length2),
decimals(), is_unsigned());
}
Information_schema_numeric_attributes
information_schema_numeric_attributes() const override
{
uint32 prec= type_limits_int()->precision();
return Information_schema_numeric_attributes(prec, 0);
}
void sql_type(String &str) const override;
SEL_ARG *get_mm_leaf(RANGE_OPT_PARAM *param, KEY_PART *key_part,
const Item_bool_func *cond,
scalar_comparison_op op, Item *value) override
{
return get_mm_leaf_int(param, key_part, cond, op, value, unsigned_flag);
}
};
class Field_tiny :public Field_int
{
const Type_handler_general_purpose_int *type_handler_priv() const
{
if (is_unsigned())
return &type_handler_utiny;
return &type_handler_stiny;
}
public:
Field_tiny(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
bool zero_arg, bool unsigned_arg)
:Field_int(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, zero_arg, unsigned_arg)
{}
const Type_handler *type_handler() const override
{ return type_handler_priv(); }
enum ha_base_keytype key_type() const override
{ return unsigned_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_INT8; }
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int reset() override { ptr[0]=0; return 0; }
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
bool send(Protocol *protocol) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return 1; }
const Type_limits_int *type_limits_int() const override
{
return type_handler_priv()->type_limits_int();
}
uchar *pack(uchar* to, const uchar *from, uint max_length) override
{
*to= *from;
return to + 1;
}
const uchar *unpack(uchar* to, const uchar *from,
const uchar *from_end, uint param_data) override
{
if (from == from_end)
return 0;
*to= *from;
return from + 1;
}
ulonglong get_max_int_value() const override
{
return unsigned_flag ? 0xFFULL : 0x7FULL;
}
};
class Field_short final :public Field_int
{
const Type_handler_general_purpose_int *type_handler_priv() const
{
if (is_unsigned())
return &type_handler_ushort;
return &type_handler_sshort;
}
public:
Field_short(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
bool zero_arg, bool unsigned_arg)
:Field_int(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, zero_arg, unsigned_arg)
{}
Field_short(uint32 len_arg,bool maybe_null_arg,
const LEX_CSTRING *field_name_arg,
bool unsigned_arg)
:Field_int((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
NONE, field_name_arg, 0, unsigned_arg)
{}
const Type_handler *type_handler() const override
{ return type_handler_priv(); }
enum ha_base_keytype key_type() const override
{ return unsigned_flag ? HA_KEYTYPE_USHORT_INT : HA_KEYTYPE_SHORT_INT;}
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int reset() override { ptr[0]=ptr[1]=0; return 0; }
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
bool send(Protocol *protocol) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return 2; }
const Type_limits_int *type_limits_int() const override
{
return type_handler_priv()->type_limits_int();
}
uchar *pack(uchar* to, const uchar *from, uint) override
{ return pack_int16(to, from); }
const uchar *unpack(uchar* to, const uchar *from,
const uchar *from_end, uint) override
{ return unpack_int16(to, from, from_end); }
ulonglong get_max_int_value() const override
{
return unsigned_flag ? 0xFFFFULL : 0x7FFFULL;
}
};
class Field_medium final :public Field_int
{
const Type_handler_general_purpose_int *type_handler_priv() const
{
if (is_unsigned())
return &type_handler_uint24;
return &type_handler_sint24;
}
public:
Field_medium(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
bool zero_arg, bool unsigned_arg)
:Field_int(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, zero_arg, unsigned_arg)
{}
const Type_handler *type_handler() const override
{ return type_handler_priv(); }
enum ha_base_keytype key_type() const override
{ return unsigned_flag ? HA_KEYTYPE_UINT24 : HA_KEYTYPE_INT24; }
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int reset() override { ptr[0]=ptr[1]=ptr[2]=0; return 0; }
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
bool send(Protocol *protocol) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return 3; }
const Type_limits_int *type_limits_int() const override
{
return type_handler_priv()->type_limits_int();
}
uchar *pack(uchar* to, const uchar *from, uint max_length) override
{
return Field::pack(to, from, max_length);
}
ulonglong get_max_int_value() const override
{
return unsigned_flag ? 0xFFFFFFULL : 0x7FFFFFULL;
}
};
class Field_long final :public Field_int
{
const Type_handler_general_purpose_int *type_handler_priv() const
{
if (is_unsigned())
return &type_handler_ulong;
return &type_handler_slong;
}
public:
Field_long(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
bool zero_arg, bool unsigned_arg)
:Field_int(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, zero_arg, unsigned_arg)
{}
Field_long(uint32 len_arg,bool maybe_null_arg,
const LEX_CSTRING *field_name_arg,
bool unsigned_arg)
:Field_int((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
NONE, field_name_arg, 0, unsigned_arg)
{}
const Type_handler *type_handler() const override
{ return type_handler_priv(); }
enum ha_base_keytype key_type() const override
{ return unsigned_flag ? HA_KEYTYPE_ULONG_INT : HA_KEYTYPE_LONG_INT; }
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int reset() override { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; }
double val_real() override;
longlong val_int() override;
bool send(Protocol *protocol) override;
String *val_str(String *, String *) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return 4; }
const Type_limits_int *type_limits_int() const override
{
return type_handler_priv()->type_limits_int();
}
uchar *pack(uchar* to, const uchar *from, uint) override
{
return pack_int32(to, from);
}
const uchar *unpack(uchar* to, const uchar *from,
const uchar *from_end, uint) override
{
return unpack_int32(to, from, from_end);
}
ulonglong get_max_int_value() const override
{
return unsigned_flag ? 0xFFFFFFFFULL : 0x7FFFFFFFULL;
}
};
class Field_longlong :public Field_int
{
const Type_handler_general_purpose_int *type_handler_priv() const
{
if (is_unsigned())
return &type_handler_ulonglong;
return &type_handler_slonglong;
}
public:
Field_longlong(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
bool zero_arg, bool unsigned_arg)
:Field_int(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, zero_arg, unsigned_arg)
{}
Field_longlong(uint32 len_arg,bool maybe_null_arg,
const LEX_CSTRING *field_name_arg,
bool unsigned_arg)
:Field_int((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0,0,
NONE, field_name_arg, 0, unsigned_arg)
{}
const Type_handler *type_handler() const override
{ return type_handler_priv(); }
enum ha_base_keytype key_type() const override
{ return unsigned_flag ? HA_KEYTYPE_ULONGLONG : HA_KEYTYPE_LONGLONG; }
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int reset() override
{
ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0;
return 0;
}
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
bool send(Protocol *protocol) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return 8; }
const Type_limits_int *type_limits_int() const override
{
return type_handler_priv()->type_limits_int();
}
uchar *pack(uchar* to, const uchar *from, uint) override
{
return pack_int64(to, from);
}
const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end,
uint) override
{
return unpack_int64(to, from, from_end);
}
void set_max() override;
bool is_max(const uchar *ptr_arg) const override;
ulonglong get_max_int_value() const override
{
return unsigned_flag ? 0xFFFFFFFFFFFFFFFFULL : 0x7FFFFFFFFFFFFFFFULL;
}
};
class Field_vers_trx_id :public Field_longlong {
MYSQL_TIME cache;
ulonglong cached;
public:
Field_vers_trx_id(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg, bool zero_arg,
bool unsigned_arg)
: Field_longlong(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, zero_arg,
unsigned_arg),
cached(0)
{}
const Type_handler *type_handler() const override
{ return &type_handler_vers_trx_id; }
uint size_of() const override { return sizeof *this; }
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate, ulonglong trx_id);
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override
{
return get_date(ltime, fuzzydate, (ulonglong) val_int());
}
bool test_if_equality_guarantees_uniqueness(const Item *item) const override;
Data_type_compatibility can_optimize_keypart_ref(const Item_bool_func *,
const Item *)
const override
{
return Data_type_compatibility::OK;
}
Data_type_compatibility can_optimize_group_min_max(const Item_bool_func *,
const Item *)
const override
{
return Data_type_compatibility::OK;
}
Data_type_compatibility can_optimize_range(const Item_bool_func *,
const Item *, bool is_eq_func)
const override
{
return Data_type_compatibility::OK;
}
/* cmp_type() cannot be TIME_RESULT, because we want to compare this field against
integers. But in all other cases we treat it as TIME_RESULT! */
};
static inline decimal_digits_t fix_dec_arg(decimal_digits_t dec_arg)
{ return dec_arg >= FLOATING_POINT_DECIMALS ? DECIMAL_NOT_SPECIFIED : dec_arg; }
class Field_float final :public Field_real {
public:
Field_float(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
decimal_digits_t dec_arg,bool zero_arg,bool unsigned_arg)
:Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg,
fix_dec_arg(dec_arg), zero_arg, unsigned_arg)
{ }
Field_float(uint32 len_arg, bool maybe_null_arg,
const LEX_CSTRING *field_name_arg, decimal_digits_t dec_arg)
:Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, (uint) 0,
NONE, field_name_arg, fix_dec_arg(dec_arg), 0, 0)
{ }
const Type_handler *type_handler() const override
{ return &type_handler_float; }
enum ha_base_keytype key_type() const override { return HA_KEYTYPE_FLOAT; }
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int reset() override { bzero(ptr,sizeof(float)); return 0; }
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
bool send(Protocol *protocol) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff, uint length) override;
uint32 pack_length() const override { return sizeof(float); }
uint row_pack_length() const override { return pack_length(); }
ulonglong get_max_int_value() const override
{
/*
We use the maximum as per IEEE754-2008 standard, 2^24
*/
return 0x1000000ULL;
}
Binlog_type_info binlog_type_info() const override;
};
class Field_double :public Field_real {
longlong val_int_from_real(bool want_unsigned_result);
public:
Field_double(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
decimal_digits_t dec_arg,bool zero_arg,bool unsigned_arg)
:Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg,
fix_dec_arg(dec_arg), zero_arg, unsigned_arg)
{ }
Field_double(uint32 len_arg, bool maybe_null_arg,
const LEX_CSTRING *field_name_arg, decimal_digits_t dec_arg)
:Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "" : 0, (uint) 0,
NONE, field_name_arg, fix_dec_arg(dec_arg), 0, 0)
{ }
Field_double(uint32 len_arg, bool maybe_null_arg,
const LEX_CSTRING *field_name_arg,
decimal_digits_t dec_arg, bool not_fixed_arg)
:Field_real((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "" : 0, (uint) 0,
NONE, field_name_arg, fix_dec_arg(dec_arg), 0, 0)
{
not_fixed= not_fixed_arg;
}
void init_for_tmp_table(Field *org_field, TABLE *new_table) override
{
Field::init_for_tmp_table(org_field, new_table);
not_fixed= true;
}
const Type_handler *type_handler() const override
{ return &type_handler_double; }
enum ha_base_keytype key_type() const override final { return HA_KEYTYPE_DOUBLE; }
int store(const char *to,size_t length,CHARSET_INFO *charset) override final;
int store(double nr) override final;
int store(longlong nr, bool unsigned_val) override final;
int reset() override final { bzero(ptr,sizeof(double)); return 0; }
double val_real() override final;
longlong val_int() override final { return val_int_from_real(false); }
ulonglong val_uint() override final { return (ulonglong) val_int_from_real(true); }
String *val_str(String *, String *) override final;
bool send(Protocol *protocol) override;
int cmp(const uchar *,const uchar *) const override final;
void sort_string(uchar *buff, uint length) override final;
uint32 pack_length() const override final { return sizeof(double); }
uint row_pack_length() const override final { return pack_length(); }
ulonglong get_max_int_value() const override final
{
/*
We use the maximum as per IEEE754-2008 standard, 2^53
*/
return 0x20000000000000ULL;
}
Binlog_type_info binlog_type_info() const override final;
};
/* Everything saved in this will disappear. It will always return NULL */
class Field_null :public Field_str {
static uchar null[1];
public:
Field_null(uchar *ptr_arg, uint32 len_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
const DTCollation &collation)
:Field_str(ptr_arg, len_arg, null, 1,
unireg_check_arg, field_name_arg, collation)
{}
const Type_handler *type_handler() const override
{ return &type_handler_null; }
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
Information_schema_character_attributes
information_schema_character_attributes() const override
{
return Information_schema_character_attributes();
}
Copy_func *get_copy_func(const Field *from) const override
{
return do_field_string;
}
int store(const char *to, size_t length, CHARSET_INFO *cs) override final
{ null[0]=1; return 0; }
int store(double nr) override final { null[0]=1; return 0; }
int store(longlong nr, bool unsigned_val) override final { null[0]=1; return 0; }
int store_decimal(const my_decimal *d) override final { null[0]=1; return 0; }
int reset() override final { return 0; }
double val_real() override final { return 0.0;}
longlong val_int() override final { return 0;}
bool val_bool() override final { return false; }
my_decimal *val_decimal(my_decimal *) override final { return 0; }
String *val_str(String *value,String *value2) override final
{ value2->length(0); return value2;}
bool is_equal(const Column_definition &new_field) const override final;
int cmp(const uchar *a, const uchar *b) const override final { return 0;}
void sort_string(uchar *buff, uint length) override final {}
uint32 pack_length() const override final { return 0; }
void sql_type(String &str) const override final;
uint size_of() const override final { return sizeof *this; }
uint32 max_display_length() const override final { return 4; }
void move_field_offset(my_ptrdiff_t ptr_diff) override final {}
Data_type_compatibility can_optimize_keypart_ref(const Item_bool_func *cond,
const Item *item)
const override final
{
return Data_type_compatibility::INCOMPATIBLE_DATA_TYPE;
}
Data_type_compatibility can_optimize_group_min_max(const Item_bool_func *cond,
const Item *const_item)
const override final
{
return Data_type_compatibility::INCOMPATIBLE_DATA_TYPE;
}
};
class Field_temporal :public Field {
protected:
Item *get_equal_const_item_datetime(THD *thd, const Context &ctx,
Item *const_item);
void set_warnings(Sql_condition::enum_warning_level trunc_level,
const ErrConv *str, int was_cut, const char *typestr);
int store_TIME_return_code_with_warnings(int warn, const ErrConv *str,
const char *typestr)
{
if (!MYSQL_TIME_WARN_HAVE_WARNINGS(warn) &&
MYSQL_TIME_WARN_HAVE_NOTES(warn))
{
set_warnings(Sql_condition::WARN_LEVEL_NOTE, str,
warn | MYSQL_TIME_WARN_TRUNCATED, typestr);
return 3;
}
set_warnings(Sql_condition::WARN_LEVEL_WARN, str, warn, typestr);
return warn ? 2 : 0;
}
int store_invalid_with_warning(const ErrConv *str, int was_cut,
const char *typestr)
{
DBUG_ASSERT(was_cut);
reset();
Sql_condition::enum_warning_level level= Sql_condition::WARN_LEVEL_WARN;
if (was_cut & MYSQL_TIME_WARN_ZERO_DATE)
{
set_warnings(level, str, MYSQL_TIME_WARN_OUT_OF_RANGE, typestr);
return 2;
}
set_warnings(level, str, MYSQL_TIME_WARN_TRUNCATED, typestr);
return 1;
}
void sql_type_comment(String &str,
const Name &name,
const Name &comment) const;
void sql_type_dec_comment(String &str,
const Name &name, uint dec,
const Name &comment) const;
void sql_type_opt_dec_comment(String &str,
const Name &name, uint dec,
const Name &comment) const
{
if (dec)
sql_type_dec_comment(str, name, dec, comment);
else
sql_type_comment(str, name, comment);
}
static const Name &type_version_mysql56();
public:
Field_temporal(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg, utype unireg_check_arg,
const LEX_CSTRING *field_name_arg)
:Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
field_name_arg)
{ flags|= BINARY_FLAG; }
int store_hex_hybrid(const char *str, size_t length) override
{
return store(str, length, &my_charset_bin);
}
sql_mode_t can_handle_sql_mode_dependency_on_store() const override;
Copy_func *get_copy_func(const Field *from) const override;
int save_in_field(Field *to) override
{
MYSQL_TIME ltime;
// For temporal types no truncation needed. Rounding mode is not important.
if (get_date(<ime, TIME_CONV_NONE | TIME_FRAC_NONE))
return to->reset();
return to->store_time_dec(<ime, decimals());
}
bool memcpy_field_possible(const Field *from) const override;
uint32 max_display_length() const override { return field_length; }
bool str_needs_quotes() const override { return true; }
CHARSET_INFO *charset() const override
{
return DTCollation_numeric::singleton().collation;
}
const DTCollation &dtcollation() const override
{
return DTCollation_numeric::singleton();
}
CHARSET_INFO *sort_charset() const override { return &my_charset_bin; }
bool binary() const override { return true; }
bool val_bool() override { return val_real() != 0e0; }
bool is_equal(const Column_definition &new_field) const override;
bool eq_def(const Field *field) const override
{
return (Field::eq_def(field) && decimals() == field->decimals());
}
my_decimal *val_decimal(my_decimal*) override;
double pos_in_interval(Field *min, Field *max) override
{
return pos_in_interval_val_real(min, max);
}
Data_type_compatibility can_optimize_keypart_ref(const Item_bool_func *cond,
const Item *item)
const override;
Data_type_compatibility can_optimize_group_min_max(const Item_bool_func *cond,
const Item *const_item)
const override;
Data_type_compatibility can_optimize_range(const Item_bool_func *cond,
const Item *item,
bool is_eq_func) const override
{
return Data_type_compatibility::OK;
}
SEL_ARG *get_mm_leaf(RANGE_OPT_PARAM *param, KEY_PART *key_part,
const Item_bool_func *cond,
scalar_comparison_op op, Item *value) override;
};
/**
Abstract class for:
- DATE
- DATETIME
- DATETIME(1..6)
- DATETIME(0..6) - MySQL56 version
*/
class Field_temporal_with_date :public Field_temporal {
protected:
virtual void store_TIME(const MYSQL_TIME *ltime) = 0;
void store_datetime(const Datetime &dt)
{
return store_TIME(dt.get_mysql_time());
}
virtual bool get_TIME(MYSQL_TIME *ltime, const uchar *pos,
date_mode_t fuzzydate) const = 0;
bool validate_MMDD(bool not_zero_date, uint month, uint day,
date_mode_t fuzzydate) const
{
if (!not_zero_date)
return bool(fuzzydate & TIME_NO_ZERO_DATE);
if (!month || !day)
return bool(fuzzydate & TIME_NO_ZERO_IN_DATE);
return false;
}
public:
Field_temporal_with_date(uchar *ptr_arg, uint32 len_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
utype unireg_check_arg,
const LEX_CSTRING *field_name_arg)
:Field_temporal(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg)
{}
bool validate_value_in_record(THD *thd, const uchar *record) const override;
};
class Field_timestamp :public Field_temporal {
protected:
int store_TIME_with_warning(THD *, const Datetime *,
const ErrConv *, int warn);
virtual void store_TIMEVAL(const timeval &tv)= 0;
void store_TIMESTAMP(const Timestamp &ts)
{
store_TIMEVAL(ts.tv());
}
int zero_time_stored_return_code_with_warning();
public:
Field_timestamp(uchar *ptr_arg, uint32 len_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
TABLE_SHARE *share);
const Type_handler *type_handler() const override
{ return &type_handler_timestamp; }
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
Copy_func *get_copy_func(const Field *from) const override;
sql_mode_t conversion_depends_on_sql_mode(THD *, Item *) const override;
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int store_time_dec(const MYSQL_TIME *ltime, uint dec) override;
int store_decimal(const my_decimal *) override;
int store_timestamp_dec(const timeval &ts, uint dec) override;
int save_in_field(Field *to) override;
longlong val_int() override;
String *val_str(String *, String *) override;
bool zero_pack() const override { return false; }
/*
This method is used by storage/perfschema and
Item_func_now_local::save_in_field().
*/
void store_TIME(my_time_t ts, ulong sec_part)
{
int warn;
time_round_mode_t mode= Datetime::default_round_mode(get_thd());
store_TIMESTAMP(Timestamp(ts, sec_part).round(decimals(), mode, &warn));
}
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
int store_native(const Native &value) override;
bool validate_value_in_record(THD *thd, const uchar *record) const override;
Item *get_equal_const_item(THD *thd, const Context &ctx, Item *const_item)
override
{
return get_equal_const_item_datetime(thd, ctx, const_item);
}
bool load_data_set_null(THD *thd) override;
bool load_data_set_no_data(THD *thd, bool fixed_format) override;
};
class Field_timestamp0 :public Field_timestamp
{
void store_TIMEVAL(const timeval &tv) override
{
int4store(ptr, tv.tv_sec);
}
public:
Field_timestamp0(uchar *ptr_arg, uint32 len_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
TABLE_SHARE *share)
:Field_timestamp(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, share)
{ }
enum ha_base_keytype key_type() const override
{ return HA_KEYTYPE_ULONG_INT; }
void sql_type(String &str) const override
{
sql_type_comment(str, Field_timestamp0::type_handler()->name(),
Type_handler::version_mariadb53());
}
double val_real() override
{
return (double) Field_timestamp0::val_int();
}
bool send(Protocol *protocol) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return 4; }
int set_time() override;
/* Get TIMESTAMP field value as seconds since begging of Unix Epoch */
my_time_t get_timestamp(const uchar *pos, ulong *sec_part) const override;
bool val_native(Native *to) override;
uchar *pack(uchar *to, const uchar *from, uint) override
{
return pack_int32(to, from);
}
const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end,
uint) override
{
return unpack_int32(to, from, from_end);
}
uint size_of() const override { return sizeof *this; }
};
/**
Abstract class for:
- TIMESTAMP(1..6)
- TIMESTAMP(0..6) - MySQL56 version
*/
class Field_timestamp_with_dec :public Field_timestamp {
protected:
decimal_digits_t dec;
public:
Field_timestamp_with_dec(uchar *ptr_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
TABLE_SHARE *share, decimal_digits_t dec_arg) :
Field_timestamp(ptr_arg,
MAX_DATETIME_WIDTH + dec_arg + MY_TEST(dec_arg),
null_ptr_arg,
null_bit_arg, unireg_check_arg, field_name_arg, share),
dec(dec_arg)
{
DBUG_ASSERT(dec <= TIME_SECOND_PART_DIGITS);
}
decimal_digits_t decimals() const override { return dec; }
enum ha_base_keytype key_type() const override { return HA_KEYTYPE_BINARY; }
uchar *pack(uchar *to, const uchar *from, uint max_length) override
{ return Field::pack(to, from, max_length); }
const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end,
uint param_data) override
{ return Field::unpack(to, from, from_end, param_data); }
void make_send_field(Send_field *field) override;
void sort_string(uchar *to, uint length) override
{
DBUG_ASSERT(length == pack_length());
memcpy(to, ptr, length);
}
bool send(Protocol *protocol) override;
double val_real() override;
my_decimal* val_decimal(my_decimal*) override;
int set_time() override;
};
class Field_timestamp_hires :public Field_timestamp_with_dec {
uint sec_part_bytes(uint dec) const
{
return Type_handler_timestamp::sec_part_bytes(dec);
}
void store_TIMEVAL(const timeval &tv) override;
public:
Field_timestamp_hires(uchar *ptr_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
TABLE_SHARE *share, decimal_digits_t dec_arg) :
Field_timestamp_with_dec(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, share, dec_arg)
{
DBUG_ASSERT(dec);
}
void sql_type(String &str) const override
{
sql_type_dec_comment(str, Field_timestamp_hires::type_handler()->name(),
dec, Type_handler::version_mariadb53());
}
bool val_native(Native *to) override;
my_time_t get_timestamp(const uchar *pos, ulong *sec_part) const override;
int cmp(const uchar *,const uchar *) const override;
uint32 pack_length() const override { return 4 + sec_part_bytes(dec); }
uint size_of() const override { return sizeof *this; }
};
/**
TIMESTAMP(0..6) - MySQL56 version
*/
class Field_timestampf :public Field_timestamp_with_dec {
void store_TIMEVAL(const timeval &tv) override;
public:
Field_timestampf(uchar *ptr_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
TABLE_SHARE *share, decimal_digits_t dec_arg) :
Field_timestamp_with_dec(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, share, dec_arg)
{}
const Type_handler *type_handler() const override
{ return &type_handler_timestamp2; }
enum_field_types binlog_type() const override
{ return MYSQL_TYPE_TIMESTAMP2; }
void sql_type(String &str) const override
{
sql_type_opt_dec_comment(str, Field_timestampf::type_handler()->name(),
dec, type_version_mysql56());
}
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
uint32 pack_length() const override
{
return my_timestamp_binary_length(dec);
}
uint row_pack_length() const override { return pack_length(); }
uint pack_length_from_metadata(uint field_metadata) const override
{
DBUG_ENTER("Field_timestampf::pack_length_from_metadata");
uint tmp= my_timestamp_binary_length(field_metadata);
DBUG_RETURN(tmp);
}
int cmp(const uchar *a_ptr,const uchar *b_ptr) const override
{
return memcmp(a_ptr, b_ptr, pack_length());
}
void set_max() override;
bool is_max(const uchar *ptr_arg) const override;
my_time_t get_timestamp(const uchar *pos, ulong *sec_part) const override;
bool val_native(Native *to) override;
uint size_of() const override { return sizeof *this; }
Binlog_type_info binlog_type_info() const override;
};
class Field_year final :public Field_tiny {
public:
Field_year(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg)
:Field_tiny(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, 1, 1)
{}
const Type_handler *type_handler() const override
{
return field_length == 2 ? &type_handler_year2 : &type_handler_year;
}
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
Copy_func *get_copy_func(const Field *from) const override
{
if (eq_def(from))
return get_identical_copy_func();
switch (from->cmp_type()) {
case STRING_RESULT:
{
const Type_handler *handler= from->type_handler();
if (handler == &type_handler_enum || handler == &type_handler_set)
return do_field_int;
return do_field_string;
}
case TIME_RESULT:
return do_field_date;
case DECIMAL_RESULT:
return do_field_decimal;
case REAL_RESULT:
return do_field_real;
case INT_RESULT:
break;
case ROW_RESULT:
default:
DBUG_ASSERT(0);
break;
}
return do_field_int;
}
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int store_time_dec(const MYSQL_TIME *ltime, uint dec) override;
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
bool send(Protocol *protocol) override;
Information_schema_numeric_attributes
information_schema_numeric_attributes() const override
{
return Information_schema_numeric_attributes();
}
uint32 max_display_length() const override { return field_length; }
void sql_type(String &str) const override;
};
class Field_date_common :public Field_temporal_with_date
{
protected:
int store_TIME_with_warning(const Datetime *ltime, const ErrConv *str,
int was_cut);
public:
Field_date_common(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg)
:Field_temporal_with_date(ptr_arg, MAX_DATE_WIDTH,
null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg)
{}
Copy_func *get_copy_func(const Field *from) const override;
SEL_ARG *get_mm_leaf(RANGE_OPT_PARAM *param, KEY_PART *key_part,
const Item_bool_func *cond,
scalar_comparison_op op, Item *value) override;
int store(const char *to, size_t length, CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int store_time_dec(const MYSQL_TIME *ltime, uint dec) override;
int store_decimal(const my_decimal *) override;
};
class Field_date final :public Field_date_common
{
void store_TIME(const MYSQL_TIME *ltime) override;
bool get_TIME(MYSQL_TIME *ltime, const uchar *pos, date_mode_t fuzzydate)
const override;
public:
Field_date(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg)
:Field_date_common(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg) {}
const Type_handler *type_handler() const override
{ return &type_handler_date; }
enum ha_base_keytype key_type() const override
{ return HA_KEYTYPE_ULONG_INT; }
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
int reset() override { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; }
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override
{ return Field_date::get_TIME(ltime, ptr, fuzzydate); }
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
bool send(Protocol *protocol) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return 4; }
void sql_type(String &str) const override;
uchar *pack(uchar* to, const uchar *from, uint) override
{
return pack_int32(to, from);
}
const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end,
uint) override
{
return unpack_int32(to, from, from_end);
}
uint size_of() const override { return sizeof *this; }
};
class Field_newdate final :public Field_date_common
{
void store_TIME(const MYSQL_TIME *ltime) override;
bool get_TIME(MYSQL_TIME *ltime, const uchar *pos, date_mode_t fuzzydate)
const override;
public:
Field_newdate(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg)
:Field_date_common(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg)
{}
const Type_handler *type_handler() const override
{ return &type_handler_newdate; }
enum ha_base_keytype key_type() const override { return HA_KEYTYPE_UINT24; }
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
int reset() override { ptr[0]=ptr[1]=ptr[2]=0; return 0; }
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
bool send(Protocol *protocol) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return 3; }
void sql_type(String &str) const override;
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override
{ return Field_newdate::get_TIME(ltime, ptr, fuzzydate); }
longlong val_datetime_packed(THD *thd) override;
uint size_of() const override { return sizeof *this; }
Item *get_equal_const_item(THD *thd, const Context &ctx, Item *const_item)
override;
};
class Field_time :public Field_temporal {
/*
when this Field_time instance is used for storing values for index lookups
(see class store_key, Field::new_key_field(), etc), the following
might be set to TO_DAYS(CURDATE()). See also Field_time::store_time_dec()
*/
long curdays;
protected:
virtual void store_TIME(const MYSQL_TIME *ltime)= 0;
void store_TIME(const Time &t) { return store_TIME(t.get_mysql_time()); }
int store_TIME_with_warning(const Time *ltime, const ErrConv *str, int warn);
bool check_zero_in_date_with_warn(date_mode_t fuzzydate);
static void do_field_time(const Copy_field *copy);
public:
Field_time(uchar *ptr_arg, uint length_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg)
:Field_temporal(ptr_arg, length_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg), curdays(0)
{}
bool can_be_substituted_to_equal_item(const Context &ctx,
const Item_equal *item_equal) override;
const Type_handler *type_handler() const override
{ return &type_handler_time; }
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
Copy_func *get_copy_func(const Field *from) const override
{
return from->cmp_type() == REAL_RESULT ? do_field_string : // MDEV-9344
from->type() == MYSQL_TYPE_YEAR ? do_field_int :
from->type() == MYSQL_TYPE_BIT ? do_field_int :
eq_def(from) ? get_identical_copy_func() :
do_field_time;
}
bool memcpy_field_possible(const Field *from) const override
{
return real_type() == from->real_type() &&
decimals() == from->decimals();
}
sql_mode_t conversion_depends_on_sql_mode(THD *, Item *) const override;
int store_native(const Native &value) override;
bool val_native(Native *to) override;
int store_time_dec(const MYSQL_TIME *ltime, uint dec) override;
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int store_decimal(const my_decimal *) override;
String *val_str(String *, String *) override;
bool send(Protocol *protocol) override;
void set_curdays(THD *thd);
Field *new_key_field(MEM_ROOT *root, TABLE *new_table,
uchar *new_ptr, uint32 length,
uchar *new_null_ptr, uint new_null_bit) override;
Item *get_equal_const_item(THD *thd, const Context &ctx, Item *const_item)
override;
};
class Field_time0 final :public Field_time
{
protected:
void store_TIME(const MYSQL_TIME *ltime) override;
public:
Field_time0(uchar *ptr_arg, uint length_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg)
:Field_time(ptr_arg, length_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg)
{ }
enum ha_base_keytype key_type() const override { return HA_KEYTYPE_INT24; }
void sql_type(String &str) const override
{
sql_type_comment(str, Field_time0::type_handler()->name(),
Type_handler::version_mariadb53());
}
double val_real() override;
longlong val_int() override;
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return 3; }
uint size_of() const override { return sizeof *this; }
};
/**
Abstract class for:
- TIME(1..6)
- TIME(0..6) - MySQL56 version
*/
class Field_time_with_dec :public Field_time {
protected:
decimal_digits_t dec;
public:
Field_time_with_dec(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
decimal_digits_t dec_arg)
:Field_time(ptr_arg, MIN_TIME_WIDTH + dec_arg + MY_TEST(dec_arg),
null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg),
dec(dec_arg)
{
DBUG_ASSERT(dec <= TIME_SECOND_PART_DIGITS);
}
decimal_digits_t decimals() const override { return dec; }
enum ha_base_keytype key_type() const override { return HA_KEYTYPE_BINARY; }
longlong val_int() override;
double val_real() override;
void make_send_field(Send_field *) override;
};
/**
TIME(1..6)
*/
class Field_time_hires final :public Field_time_with_dec {
longlong zero_point;
void store_TIME(const MYSQL_TIME *) override;
public:
Field_time_hires(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
decimal_digits_t dec_arg)
:Field_time_with_dec(ptr_arg, null_ptr_arg,
null_bit_arg, unireg_check_arg, field_name_arg,
dec_arg)
{
DBUG_ASSERT(dec);
zero_point= sec_part_shift(
((TIME_MAX_VALUE_SECONDS+1LL)*TIME_SECOND_PART_FACTOR), dec);
}
void sql_type(String &str) const override
{
sql_type_dec_comment(str, Field_time_hires::type_handler()->name(),
dec, Type_handler::version_mariadb53());
}
int reset() override;
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override
{ return Type_handler_time::hires_bytes(dec); }
uint size_of() const override { return sizeof *this; }
};
/**
TIME(0..6) - MySQL56 version
*/
class Field_timef final :public Field_time_with_dec {
void store_TIME(const MYSQL_TIME *ltime) override;
public:
Field_timef(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
decimal_digits_t dec_arg)
:Field_time_with_dec(ptr_arg, null_ptr_arg,
null_bit_arg, unireg_check_arg, field_name_arg,
dec_arg)
{
DBUG_ASSERT(dec <= TIME_SECOND_PART_DIGITS);
}
const Type_handler *type_handler() const override
{ return &type_handler_time2; }
enum_field_types binlog_type() const override { return MYSQL_TYPE_TIME2; }
void sql_type(String &str) const override
{
sql_type_opt_dec_comment(str, Field_timef::type_handler()->name(),
dec, type_version_mysql56());
}
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
uint32 pack_length() const override
{
return my_time_binary_length(dec);
}
uint row_pack_length() const override { return pack_length(); }
uint pack_length_from_metadata(uint field_metadata) const override
{
DBUG_ENTER("Field_timef::pack_length_from_metadata");
uint tmp= my_time_binary_length(field_metadata);
DBUG_RETURN(tmp);
}
void sort_string(uchar *to, uint length) override
{
DBUG_ASSERT(length == Field_timef::pack_length());
memcpy(to, ptr, length);
}
int cmp(const uchar *a_ptr, const uchar *b_ptr) const override
{
return memcmp(a_ptr, b_ptr, pack_length());
}
int reset() override;
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
longlong val_time_packed(THD *thd) override;
int store_native(const Native &value) override;
bool val_native(Native *to) override;
uint size_of() const override { return sizeof *this; }
Binlog_type_info binlog_type_info() const override;
};
class Field_datetime :public Field_temporal_with_date {
protected:
int store_TIME_with_warning(const Datetime *ltime, const ErrConv *str,
int was_cut);
public:
Field_datetime(uchar *ptr_arg, uint length_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg)
:Field_temporal_with_date(ptr_arg, length_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg)
{
if (unireg_check == TIMESTAMP_UN_FIELD ||
unireg_check == TIMESTAMP_DNUN_FIELD)
flags|= ON_UPDATE_NOW_FLAG;
}
const Type_handler *type_handler() const override
{ return &type_handler_datetime; }
sql_mode_t conversion_depends_on_sql_mode(THD *, Item *) const override;
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
int store(const char *to, size_t length, CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int store_time_dec(const MYSQL_TIME *ltime, uint dec) override;
int store_decimal(const my_decimal *) override;
int set_time() override;
Item *get_equal_const_item(THD *thd, const Context &ctx, Item *const_item)
override
{
return get_equal_const_item_datetime(thd, ctx, const_item);
}
};
/*
Stored as a 8 byte unsigned int. Should sometimes be change to a 6 byte
*/
class Field_datetime0 final :public Field_datetime
{
void store_TIME(const MYSQL_TIME *ltime) override;
bool get_TIME(MYSQL_TIME *ltime, const uchar *pos, date_mode_t fuzzydate)
const override;
public:
Field_datetime0(uchar *ptr_arg, uint length_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg)
:Field_datetime(ptr_arg, length_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg)
{}
enum ha_base_keytype key_type() const override
{ return HA_KEYTYPE_ULONGLONG; }
void sql_type(String &str) const override
{
sql_type_comment(str, Field_datetime0::type_handler()->name(),
Type_handler::version_mariadb53());
}
double val_real() override
{
return (double) Field_datetime0::val_int();
}
longlong val_int() override;
String *val_str(String *, String *) override;
bool send(Protocol *protocol) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return 8; }
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override
{ return Field_datetime0::get_TIME(ltime, ptr, fuzzydate); }
uchar *pack(uchar* to, const uchar *from, uint) override
{
return pack_int64(to, from);
}
const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end,
uint) override
{
return unpack_int64(to, from, from_end);
}
uint size_of() const override { return sizeof *this; }
};
/**
Abstract class for:
- DATETIME(1..6)
- DATETIME(0..6) - MySQL56 version
*/
class Field_datetime_with_dec :public Field_datetime {
protected:
decimal_digits_t dec;
public:
Field_datetime_with_dec(uchar *ptr_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg, decimal_digits_t dec_arg)
:Field_datetime(ptr_arg, MAX_DATETIME_WIDTH + dec_arg + MY_TEST(dec_arg),
null_ptr_arg, null_bit_arg, unireg_check_arg,
field_name_arg), dec(dec_arg)
{
DBUG_ASSERT(dec <= TIME_SECOND_PART_DIGITS);
}
decimal_digits_t decimals() const override final { return dec; }
enum ha_base_keytype key_type() const override final { return HA_KEYTYPE_BINARY; }
void make_send_field(Send_field *field) override final;
bool send(Protocol *protocol) override final;
uchar *pack(uchar *to, const uchar *from, uint max_length) override final
{ return Field::pack(to, from, max_length); }
const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end,
uint param_data) override final
{ return Field::unpack(to, from, from_end, param_data); }
void sort_string(uchar *to, uint length) override final
{
DBUG_ASSERT(length == pack_length());
memcpy(to, ptr, length);
}
double val_real() override final;
longlong val_int() override final;
String *val_str(String *, String *) override final;
};
/**
DATETIME(1..6)
*/
class Field_datetime_hires final :public Field_datetime_with_dec {
void store_TIME(const MYSQL_TIME *ltime) override;
bool get_TIME(MYSQL_TIME *ltime, const uchar *pos, date_mode_t fuzzydate)
const override;
public:
Field_datetime_hires(uchar *ptr_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg, decimal_digits_t dec_arg)
:Field_datetime_with_dec(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, dec_arg)
{
DBUG_ASSERT(dec);
}
void sql_type(String &str) const override
{
sql_type_dec_comment(str, Field_datetime_hires::type_handler()->name(),
dec, Type_handler::version_mariadb53());
}
int cmp(const uchar *,const uchar *) const override;
uint32 pack_length() const override
{ return Type_handler_datetime::hires_bytes(dec); }
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override
{ return Field_datetime_hires::get_TIME(ltime, ptr, fuzzydate); }
uint size_of() const override { return sizeof *this; }
};
/**
DATETIME(0..6) - MySQL56 version
*/
class Field_datetimef final :public Field_datetime_with_dec {
void store_TIME(const MYSQL_TIME *ltime) override;
bool get_TIME(MYSQL_TIME *ltime, const uchar *pos, date_mode_t fuzzydate)
const override;
public:
Field_datetimef(uchar *ptr_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg, decimal_digits_t dec_arg)
:Field_datetime_with_dec(ptr_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, dec_arg)
{}
const Type_handler *type_handler() const override
{ return &type_handler_datetime2; }
enum_field_types binlog_type() const override
{ return MYSQL_TYPE_DATETIME2; }
void sql_type(String &str) const override
{
sql_type_opt_dec_comment(str, Field_datetimef::type_handler()->name(),
dec, type_version_mysql56());
}
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
uint32 pack_length() const override
{
return my_datetime_binary_length(dec);
}
uint row_pack_length() const override { return pack_length(); }
uint pack_length_from_metadata(uint field_metadata) const override
{
DBUG_ENTER("Field_datetimef::pack_length_from_metadata");
uint tmp= my_datetime_binary_length(field_metadata);
DBUG_RETURN(tmp);
}
int cmp(const uchar *a_ptr, const uchar *b_ptr) const override
{
return memcmp(a_ptr, b_ptr, pack_length());
}
int reset() override;
bool get_date(MYSQL_TIME *ltime, date_mode_t fuzzydate) override
{ return Field_datetimef::get_TIME(ltime, ptr, fuzzydate); }
longlong val_datetime_packed(THD *thd) override;
uint size_of() const override { return sizeof *this; }
Binlog_type_info binlog_type_info() const override;
};
static inline Field_timestamp *
new_Field_timestamp(MEM_ROOT *root,uchar *ptr, uchar *null_ptr, uchar null_bit,
enum Field::utype unireg_check,
const LEX_CSTRING *field_name,
TABLE_SHARE *share, decimal_digits_t dec)
{
if (dec==0)
return new (root)
Field_timestamp0(ptr, MAX_DATETIME_WIDTH, null_ptr,
null_bit, unireg_check, field_name, share);
if (dec >= FLOATING_POINT_DECIMALS)
dec= MAX_DATETIME_PRECISION;
return new (root)
Field_timestamp_hires(ptr, null_ptr, null_bit, unireg_check,
field_name, share, dec);
}
static inline Field_time *
new_Field_time(MEM_ROOT *root, uchar *ptr, uchar *null_ptr, uchar null_bit,
enum Field::utype unireg_check, const LEX_CSTRING *field_name,
decimal_digits_t dec)
{
if (dec == 0)
return new (root)
Field_time0(ptr, MIN_TIME_WIDTH, null_ptr, null_bit, unireg_check,
field_name);
if (dec >= FLOATING_POINT_DECIMALS)
dec= MAX_DATETIME_PRECISION;
return new (root)
Field_time_hires(ptr, null_ptr, null_bit, unireg_check, field_name, dec);
}
static inline Field_datetime *
new_Field_datetime(MEM_ROOT *root, uchar *ptr, uchar *null_ptr, uchar null_bit,
enum Field::utype unireg_check,
const LEX_CSTRING *field_name, decimal_digits_t dec)
{
if (dec == 0)
return new (root)
Field_datetime0(ptr, MAX_DATETIME_WIDTH, null_ptr, null_bit,
unireg_check, field_name);
if (dec >= FLOATING_POINT_DECIMALS)
dec= MAX_DATETIME_PRECISION;
return new (root)
Field_datetime_hires(ptr, null_ptr, null_bit,
unireg_check, field_name, dec);
}
class Field_string final :public Field_longstr {
class Warn_filter_string: public Warn_filter
{
public:
Warn_filter_string(const THD *thd, const Field_string *field);
};
bool is_var_string() const
{
return can_alter_field_type &&
orig_table &&
(orig_table->s->db_create_options & HA_OPTION_PACK_RECORD) &&
field_length >= 4 &&
orig_table->s->frm_version < FRM_VER_TRUE_VARCHAR;
}
LEX_CSTRING to_lex_cstring() const;
public:
bool can_alter_field_type;
Field_string(uchar *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
const DTCollation &collation)
:Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, collation),
can_alter_field_type(1) {};
Field_string(uint32 len_arg,bool maybe_null_arg,
const LEX_CSTRING *field_name_arg,
const DTCollation &collation)
:Field_longstr((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
NONE, field_name_arg, collation),
can_alter_field_type(1) {};
const Type_handler *type_handler() const override;
enum ha_base_keytype key_type() const override
{ return binary() ? HA_KEYTYPE_BINARY : HA_KEYTYPE_TEXT; }
en_fieldtype tmp_engine_column_type(bool use_packed_rows) const override;
bool zero_pack() const override { return false; }
Copy_func *get_copy_func(const Field *from) const override;
int reset() override
{
charset()->fill((char*) ptr, field_length, (has_charset() ? ' ' : 0));
return 0;
}
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
using Field_str::store;
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
my_decimal *val_decimal(my_decimal *) override;
int cmp(const uchar *,const uchar *) const override;
int cmp_prefix(const uchar *a, const uchar *b, size_t prefix_char_len) const
override;
void sort_string(uchar *buff,uint length) override;
void update_data_type_statistics(Data_type_statistics *st) const override
{
st->m_fixed_string_count++;
st->m_fixed_string_total_length+= pack_length();
}
void sql_type(String &str) const override;
void sql_rpl_type(String*) const override;
bool is_equal(const Column_definition &new_field) const override;
uchar *pack(uchar *to, const uchar *from, uint max_length) override;
const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end,
uint param_data) override;
uint pack_length_from_metadata(uint field_metadata) const override
{
DBUG_PRINT("debug", ("field_metadata: 0x%04x", field_metadata));
if (field_metadata == 0)
return row_pack_length();
return (((field_metadata >> 4) & 0x300) ^ 0x300) + (field_metadata & 0x00ff);
}
bool compatible_field_size(uint field_metadata, const Relay_log_info *rli,
uint16 mflags, int *order_var) const override;
uint row_pack_length() const override { return field_length; }
uint packed_col_length(const uchar *to, uint length) override;
uint max_packed_col_length(uint max_length) override;
uint size_of() const override { return sizeof *this; }
bool has_charset() const override { return charset() != &my_charset_bin; }
Field *make_new_field(MEM_ROOT *root, TABLE *new_table, bool keep_type)
override;
uint get_key_image(uchar *buff, uint length,
const uchar *ptr_arg, imagetype type) const override;
sql_mode_t value_depends_on_sql_mode() const override;
sql_mode_t can_handle_sql_mode_dependency_on_store() const override;
void print_key_value(String *out, uint32 length) override;
Binlog_type_info binlog_type_info() const override;
};
class Field_varstring :public Field_longstr {
public:
const uchar *get_data() const
{
return get_data(ptr);
}
const uchar *get_data(const uchar *ptr_arg) const
{
return ptr_arg + length_bytes;
}
uint get_length() const
{
return get_length(ptr);
}
uint get_length(const uchar *ptr_arg) const
{
return length_bytes == 1 ? (uint) *ptr_arg : uint2korr(ptr_arg);
}
protected:
void store_length(uint32 number)
{
if (length_bytes == 1)
*ptr= (uchar) number;
else
int2store(ptr, number);
}
virtual void val_str_from_ptr(String *val, const uchar *ptr) const;
public:
/*
The maximum space available in a Field_varstring, in bytes. See
length_bytes.
*/
static const uint MAX_SIZE;
/* Store number of bytes used to store length (1 or 2) */
uint32 length_bytes;
Field_varstring(uchar *ptr_arg,
uint32 len_arg, uint length_bytes_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
TABLE_SHARE *share, const DTCollation &collation)
:Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, collation),
length_bytes(length_bytes_arg)
{
share->varchar_fields++;
}
Field_varstring(uint32 len_arg,bool maybe_null_arg,
const LEX_CSTRING *field_name_arg,
TABLE_SHARE *share, const DTCollation &collation)
:Field_longstr((uchar*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
NONE, field_name_arg, collation),
length_bytes(len_arg < 256 ? 1 :2)
{
share->varchar_fields++;
}
const Type_handler *type_handler() const override;
en_fieldtype tmp_engine_column_type(bool use_packed_rows) const override
{
return FIELD_VARCHAR;
}
enum ha_base_keytype key_type() const override;
uint16 key_part_flag() const override { return HA_VAR_LENGTH_PART; }
uint16 key_part_length_bytes() const override { return HA_KEY_BLOB_LENGTH; }
uint row_pack_length() const override { return field_length; }
bool zero_pack() const override { return false; }
int reset() override { bzero(ptr,field_length+length_bytes); return 0; }
uint32 pack_length() const override
{ return (uint32) field_length+length_bytes; }
uint32 key_length() const override { return (uint32) field_length; }
uint32 sort_length() const override
{
return (uint32) field_length + sort_suffix_length();
}
uint32 sort_suffix_length() const override
{
return (field_charset() == &my_charset_bin ? length_bytes : 0);
}
Copy_func *get_copy_func(const Field *from) const override;
bool memcpy_field_possible(const Field *from) const override;
void update_data_type_statistics(Data_type_statistics *st) const override
{
st->m_variable_string_count++;
st->m_variable_string_total_length+= pack_length();
}
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
using Field_str::store;
#ifdef HAVE_MEM_CHECK
void mark_unused_memory_as_defined() override;
#endif
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
my_decimal *val_decimal(my_decimal *) override;
bool send(Protocol *protocol) override;
int cmp(const uchar *a,const uchar *b) const override;
int cmp_prefix(const uchar *a, const uchar *b, size_t prefix_char_len) const
override;
void sort_string(uchar *buff,uint length) override;
uint get_key_image(uchar *buff, uint length,
const uchar *ptr_arg, imagetype type) const override;
void set_key_image(const uchar *buff,uint length) override;
void sql_type(String &str) const override;
void sql_rpl_type(String*) const override;
uchar *pack(uchar *to, const uchar *from, uint max_length) override;
const uchar *unpack(uchar* to, const uchar *from, const uchar *from_end,
uint param_data) override;
int cmp_binary(const uchar *a,const uchar *b, uint32 max_length=~0U) const
override;
int key_cmp(const uchar *,const uchar*) const override;
int key_cmp(const uchar *str, uint length) const override;
uint packed_col_length(const uchar *to, uint length) override;
uint max_packed_col_length(uint max_length) override;
uint32 data_length() override;
uint size_of() const override { return sizeof *this; }
bool has_charset() const override
{ return charset() == &my_charset_bin ? FALSE : TRUE; }
Field *make_new_field(MEM_ROOT *root, TABLE *new_table, bool keep_type)
override;
Field *new_key_field(MEM_ROOT *root, TABLE *new_table,
uchar *new_ptr, uint32 length,
uchar *new_null_ptr, uint new_null_bit) override;
bool is_equal(const Column_definition &new_field) const override;
void hash_not_null(Hasher *hasher) override;
uint length_size() const override { return length_bytes; }
void print_key_value(String *out, uint32 length) override;
Binlog_type_info binlog_type_info() const override;
};
class Field_varstring_compressed final :public Field_varstring {
public:
Field_varstring_compressed(uchar *ptr_arg,
uint32 len_arg, uint length_bytes_arg,
uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg,
TABLE_SHARE *share, const DTCollation &collation,
Compression_method *compression_method_arg):
Field_varstring(ptr_arg, len_arg, length_bytes_arg, null_ptr_arg,
null_bit_arg, unireg_check_arg, field_name_arg,
share, collation),
compression_method_ptr(compression_method_arg) { DBUG_ASSERT(len_arg > 0); }
Compression_method *compression_method() const override
{ return compression_method_ptr; }
private:
Compression_method *compression_method_ptr;
void val_str_from_ptr(String *val, const uchar *ptr) const override;
int store(const char *to, size_t length, CHARSET_INFO *charset) override;
using Field_str::store;
String *val_str(String *, String *) override;
double val_real() override;
longlong val_int() override;
uint size_of() const override { return sizeof *this; }
/*
We use the default Field::send() implementation,
because the derived optimized version (from Field_longstr)
is not suitable for compressed fields.
*/
bool send(Protocol *protocol) override
{
return Field::send(protocol);
}
enum_field_types binlog_type() const override
{ return MYSQL_TYPE_VARCHAR_COMPRESSED; }
void sql_type(String &str) const override
{
Field_varstring::sql_type(str);
str.append(STRING_WITH_LEN(" /*M!100301 COMPRESSED*/"));
}
uint32 max_display_length() const override { return field_length - 1; }
uint32 character_octet_length() const override { return field_length - 1; }
uint32 char_length() const override
{
return (field_length - 1) / mbmaxlen();
}
int cmp(const uchar *a_ptr, const uchar *b_ptr) const override;
/*
Compressed fields can't have keys as two rows may have different
compression methods or compression levels.
*/
int key_cmp(const uchar *str, uint length) const override
{ DBUG_ASSERT(0); return 0; }
using Field_varstring::key_cmp;
Binlog_type_info binlog_type_info() const override;
Field *make_new_field(MEM_ROOT *root, TABLE *new_table, bool keep_type) override;
};
static inline uint8 number_storage_requirement(uint32 n)
{
return n < 256 ? 1 : n < 65536 ? 2 : n < 16777216 ? 3 : 4;
}
static inline void store_bigendian(ulonglong num, uchar *to, uint bytes)
{
switch(bytes) {
case 1: mi_int1store(to, num); break;
case 2: mi_int2store(to, num); break;
case 3: mi_int3store(to, num); break;
case 4: mi_int4store(to, num); break;
case 5: mi_int5store(to, num); break;
case 6: mi_int6store(to, num); break;
case 7: mi_int7store(to, num); break;
case 8: mi_int8store(to, num); break;
default: DBUG_ASSERT(0);
}
}
static inline longlong read_bigendian(const uchar *from, uint bytes)
{
switch(bytes) {
case 1: return mi_uint1korr(from);
case 2: return mi_uint2korr(from);
case 3: return mi_uint3korr(from);
case 4: return mi_uint4korr(from);
case 5: return mi_uint5korr(from);
case 6: return mi_uint6korr(from);
case 7: return mi_uint7korr(from);
case 8: return mi_sint8korr(from);
default: DBUG_ASSERT(0); return 0;
}
}
static inline void store_lowendian(ulonglong num, uchar *to, uint bytes)
{
switch(bytes) {
case 1: *to= (uchar)num; break;
case 2: int2store(to, num); break;
case 3: int3store(to, num); break;
case 4: int4store(to, num); break;
case 8: int8store(to, num); break;
default: DBUG_ASSERT(0);
}
}
static inline longlong read_lowendian(const uchar *from, uint bytes)
{
switch(bytes) {
case 1: return from[0];
case 2: return uint2korr(from);
case 3: return uint3korr(from);
case 4: return uint4korr(from);
case 8: return sint8korr(from);
default: DBUG_ASSERT(0); return 0;
}
}
extern LEX_CSTRING temp_lex_str;
class Field_blob :public Field_longstr {
protected:
/**
The number of bytes used to represent the length of the blob.
*/
uint packlength;
/**
The 'value'-object is a cache fronting the storage engine.
*/
String value;
/**
Cache for blob values when reading a row with a virtual blob
field. This is needed to not destroy the old cached value when
updating the blob with a new value when creating the new row.
*/
String read_value;
static void do_copy_blob(const Copy_field *copy);
static void do_conv_blob(const Copy_field *copy);
uint get_key_image_itRAW(const uchar *ptr_arg, uchar *buff, uint length) const;
public:
Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
TABLE_SHARE *share, uint blob_pack_length,
const DTCollation &collation);
Field_blob(uint32 len_arg,bool maybe_null_arg, const LEX_CSTRING *field_name_arg,
const DTCollation &collation)
:Field_longstr((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
NONE, field_name_arg, collation),
packlength(4)
{
flags|= BLOB_FLAG;
}
Field_blob(uint32 len_arg,bool maybe_null_arg,
const LEX_CSTRING *field_name_arg,
const DTCollation &collation, bool set_packlength)
:Field_longstr((uchar*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
NONE, field_name_arg, collation)
{
flags|= BLOB_FLAG;
packlength= set_packlength ? number_storage_requirement(len_arg) : 4;
}
Field_blob(uint32 packlength_arg)
:Field_longstr((uchar*) 0, 0, (uchar*) "", 0, NONE, &temp_lex_str,
system_charset_info),
packlength(packlength_arg) {}
const Type_handler *type_handler() const override;
/* Note that the default copy constructor is used, in clone() */
enum_field_types type() const override
{
/*
We cannot return type_handler()->field_type() here.
Some pieces of the code (e.g. in engines) rely on the fact
that Field::type(), Field::real_type() and Item_field::field_type()
return MYSQL_TYPE_BLOB for all blob variants.
We should eventually fix all such code pieces to expect
all BLOB type codes.
*/
return MYSQL_TYPE_BLOB;
}
enum_field_types real_type() const override
{
return MYSQL_TYPE_BLOB;
}
enum ha_base_keytype key_type() const override
{ return binary() ? HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2; }
uint16 key_part_flag() const override { return HA_BLOB_PART; }
uint16 key_part_length_bytes() const override { return HA_KEY_BLOB_LENGTH; }
en_fieldtype tmp_engine_column_type(bool use_packed_rows) const override
{
return FIELD_BLOB;
}
Type_numeric_attributes type_numeric_attributes() const override
{
return Type_numeric_attributes(Field_blob::max_display_length(),
decimals(), is_unsigned());
}
Information_schema_character_attributes
information_schema_character_attributes() const override
{
uint32 octets= Field_blob::character_octet_length();
uint32 chars= octets / field_charset()->mbminlen;
return Information_schema_character_attributes(octets, chars);
}
void update_data_type_statistics(Data_type_statistics *st) const override
{
st->m_blob_count++;
}
void make_send_field(Send_field *) override;
Copy_func *get_copy_func(const Field *from) const override
{
/*
TODO: MDEV-9331
if (from->type() == MYSQL_TYPE_BIT)
return do_field_int;
*/
if (!(from->flags & BLOB_FLAG) || from->charset() != charset() ||
!from->compression_method() != !compression_method())
return do_conv_blob;
if (from->pack_length() != Field_blob::pack_length())
return do_copy_blob;
return get_identical_copy_func();
}
int store_field(Field *from) override
{ // Be sure the value is stored
if (field_charset() == &my_charset_bin &&
from->type_handler()->convert_to_binary_using_val_native())
{
NativeBuffer<64> tmp;
from->val_native(&tmp);
value.copy(tmp.ptr(), tmp.length(), &my_charset_bin);
return store(value.ptr(), value.length(), &my_charset_bin);
}
from->val_str(&value);
if (table->copy_blobs ||
(!value.is_alloced() && from->is_varchar_and_in_write_set()))
value.copy();
return store(value.ptr(), value.length(), from->charset());
}
bool memcpy_field_possible(const Field *from) const override
{
return Field_str::memcpy_field_possible(from) &&
!compression_method() == !from->compression_method() &&
!table->copy_blobs;
}
bool make_empty_rec_store_default_value(THD *thd, Item *item) override;
int store(const char *to, size_t length, CHARSET_INFO *charset) override;
int store_from_statistical_minmax_field(Field *stat_field, String *str,
MEM_ROOT *mem) override;
using Field_str::store;
void hash_not_null(Hasher *hasher) override;
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
my_decimal *val_decimal(my_decimal *) override;
int cmp(const uchar *a, const uchar *b) const override;
int cmp_prefix(const uchar *a, const uchar *b, size_t prefix_char_len) const
override;
int cmp(const uchar *a, uint32 a_length, const uchar *b, uint32 b_length)
const;
int cmp_binary(const uchar *a,const uchar *b, uint32 max_length=~0U) const
override;
int key_cmp(const uchar *,const uchar*) const override;
int key_cmp(const uchar *str, uint length) const override;
/* Never update the value of min_val for a blob field */
bool update_min(Field *min_val, bool force_update) override { return false; }
/* Never update the value of max_val for a blob field */
bool update_max(Field *max_val, bool force_update) override { return false; }
uint32 key_length() const override { return 0; }
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override
{ return (uint32) (packlength + portable_sizeof_char_ptr); }
/**
Return the packed length without the pointer size added.
This is used to determine the size of the actual data in the row
buffer.
@returns The length of the raw data itself without the pointer.
*/
uint32 pack_length_no_ptr() const
{ return (uint32) (packlength); }
uint row_pack_length() const override { return pack_length_no_ptr(); }
uint32 sort_length() const override;
uint32 sort_suffix_length() const override;
uint32 value_length() override { return get_length(); }
uint32 max_data_length() const override
{
return (uint32) (((ulonglong) 1 << (packlength*8)) -1);
}
int reset() override { bzero(ptr, packlength+sizeof(uchar*)); return 0; }
void reset_fields() override
{
bzero((uchar*) &value, sizeof value);
bzero((uchar*) &read_value, sizeof read_value);
}
uint32 get_field_buffer_size() { return value.alloced_length(); }
void store_length(uchar *i_ptr, uint i_packlength, uint32 i_number);
void store_length(size_t number)
{
DBUG_ASSERT(number < UINT_MAX32);
store_length(ptr, packlength, (uint32)number);
}
inline uint32 get_length(my_ptrdiff_t row_offset= 0) const
{ return get_length(ptr+row_offset, this->packlength); }
uint32 get_length(const uchar *ptr, uint packlength) const;
uint32 get_length(const uchar *ptr_arg) const
{ return get_length(ptr_arg, this->packlength); }
inline uchar *get_ptr() const { return get_ptr(ptr); }
inline uchar *get_ptr(const uchar *ptr_arg) const
{
uchar *s;
memcpy(&s, ptr_arg + packlength, sizeof(uchar*));
return s;
}
inline void set_ptr(uchar *length, uchar *data)
{
memcpy(ptr,length,packlength);
memcpy(ptr+packlength, &data,sizeof(char*));
}
void set_ptr_offset(my_ptrdiff_t ptr_diff, uint32 length, const uchar *data)
{
uchar *ptr_ofs= ADD_TO_PTR(ptr,ptr_diff,uchar*);
store_length(ptr_ofs, packlength, length);
memcpy(ptr_ofs+packlength, &data, sizeof(char*));
}
inline void set_ptr(uint32 length, uchar *data)
{
set_ptr_offset(0, length, data);
}
int copy_value(Field_blob *from);
uint get_key_image(uchar *buff, uint length,
const uchar *ptr_arg, imagetype type) const override
{
DBUG_ASSERT(type == itRAW);
return get_key_image_itRAW(ptr_arg, buff, length);
}
void set_key_image(const uchar *buff,uint length) override;
Field *make_new_field(MEM_ROOT *, TABLE *new_table, bool keep_type) override;
Field *new_key_field(MEM_ROOT *root, TABLE *new_table,
uchar *new_ptr, uint32 length,
uchar *new_null_ptr, uint new_null_bit) override;
void sql_type(String &str) const override;
/**
Copy blob buffer into internal storage "value" and update record pointer.
@retval true Memory allocation error
@retval false Success
*/
bool copy()
{
uchar *tmp= get_ptr();
if (value.copy((char*) tmp, get_length(), charset()))
{
Field_blob::reset();
return 1;
}
tmp=(uchar*) value.ptr();
memcpy(ptr+packlength, &tmp, sizeof(char*));
return 0;
}
void swap(String &inout, bool set_read_value)
{
if (set_read_value)
read_value.swap(inout);
else
value.swap(inout);
}
/**
Return pointer to blob cache or NULL if not cached.
*/
String * cached(bool *set_read_value)
{
char *tmp= (char *) get_ptr();
if (!value.is_empty() && tmp == value.ptr())
{
*set_read_value= false;
return &value;
}
if (!read_value.is_empty() && tmp == read_value.ptr())
{
*set_read_value= true;
return &read_value;
}
return NULL;
}
/* store value for the duration of the current read record */
inline void swap_value_and_read_value()
{
read_value.swap(value);
}
inline void set_value(uchar *data)
{
/* Set value pointer. Lengths are not important */
value.reset((char*) data, 1, 1, &my_charset_bin);
}
uchar *pack(uchar *to, const uchar *from, uint max_length) override;
const uchar *unpack(uchar *to, const uchar *from, const uchar *from_end,
uint param_data) override;
uint packed_col_length(const uchar *col_ptr, uint length) override;
uint max_packed_col_length(uint max_length) override;
void free() override
{
value.free();
read_value.free();
}
inline void clear_temporary()
{
uchar *tmp= get_ptr();
if (likely(value.ptr() == (char*) tmp))
bzero((uchar*) &value, sizeof(value));
else
{
/*
Currently read_value should never point to tmp, the following code
is mainly here to make things future proof.
*/
if (unlikely(read_value.ptr() == (char*) tmp))
bzero((uchar*) &read_value, sizeof(read_value));
}
}
uint size_of() const override { return sizeof *this; }
bool has_charset() const override { return charset() != &my_charset_bin; }
uint32 max_display_length() const override;
uint32 char_length() const override;
uint32 character_octet_length() const override;
bool is_equal(const Column_definition &new_field) const override;
void print_key_value(String *out, uint32 length) override;
Binlog_type_info binlog_type_info() const override;
friend void TABLE::remember_blob_values(String *blob_storage);
friend void TABLE::restore_blob_values(String *blob_storage);
};
class Field_blob_compressed final :public Field_blob {
public:
Field_blob_compressed(uchar *ptr_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg, TABLE_SHARE *share,
uint blob_pack_length, const DTCollation &collation,
Compression_method *compression_method_arg):
Field_blob(ptr_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
field_name_arg, share, blob_pack_length, collation),
compression_method_ptr(compression_method_arg) {}
Compression_method *compression_method() const override
{ return compression_method_ptr; }
private:
Compression_method *compression_method_ptr;
int store(const char *to, size_t length, CHARSET_INFO *charset) override;
using Field_str::store;
String *val_str(String *, String *) override;
double val_real() override;
longlong val_int() override;
/*
We use the default Field::send() implementation,
because the derived optimized version (from Field_longstr)
is not suitable for compressed fields.
*/
bool send(Protocol *protocol) override
{
return Field::send(protocol);
}
uint size_of() const override { return sizeof *this; }
enum_field_types binlog_type() const override
{ return MYSQL_TYPE_BLOB_COMPRESSED; }
void sql_type(String &str) const override
{
Field_blob::sql_type(str);
str.append(STRING_WITH_LEN(" /*M!100301 COMPRESSED*/"));
}
/*
Compressed fields can't have keys as two rows may have different
compression methods or compression levels.
*/
uint get_key_image(uchar *buff, uint length,
const uchar *ptr_arg, imagetype type_arg) const override
{ DBUG_ASSERT(0); return 0; }
void set_key_image(const uchar *, uint) override
{ DBUG_ASSERT(0); }
int key_cmp(const uchar *, const uchar *) const override
{ DBUG_ASSERT(0); return 0; }
int key_cmp(const uchar *, uint) const override
{ DBUG_ASSERT(0); return 0; }
Field *new_key_field(MEM_ROOT *, TABLE *, uchar *, uint32, uchar *, uint)
override
{ DBUG_ASSERT(0); return 0; }
Binlog_type_info binlog_type_info() const override;
Field *make_new_field(MEM_ROOT *root, TABLE *new_table, bool keep_type) override;
};
class Field_enum :public Field_str {
static void do_field_enum(const Copy_field *copy_field);
longlong val_int(const uchar *) const;
Data_type_compatibility can_optimize_range_or_keypart_ref(
const Item_bool_func *cond,
const Item *item) const;
protected:
uint packlength;
public:
const TYPELIB *typelib;
Field_enum(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg,
uint packlength_arg,
const TYPELIB *typelib_arg,
const DTCollation &collation)
:Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unireg_check_arg, field_name_arg, collation),
packlength(packlength_arg),typelib(typelib_arg)
{
flags|=ENUM_FLAG;
}
Field *make_new_field(MEM_ROOT *root, TABLE *new_table, bool keep_type)
override;
const Type_handler *type_handler() const override
{ return &type_handler_enum; }
enum ha_base_keytype key_type() const override;
sql_mode_t can_handle_sql_mode_dependency_on_store() const override;
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
Copy_func *get_copy_func(const Field *from) const override
{
if (eq_def(from))
return get_identical_copy_func();
if (real_type() == MYSQL_TYPE_ENUM &&
from->real_type() == MYSQL_TYPE_ENUM)
return do_field_enum;
if (from->result_type() == STRING_RESULT)
return do_field_string;
return do_field_int;
}
int store_field(Field *from) override
{
if (from->real_type() == MYSQL_TYPE_ENUM && from->val_int() == 0)
{
store_type(0);
return 0;
}
return from->save_in_field(this);
}
int save_in_field(Field *to) override
{
if (to->result_type() != STRING_RESULT)
return to->store(val_int(), 0);
return save_in_field_str(to);
}
bool memcpy_field_possible(const Field *from) const override
{ return false; }
void make_empty_rec_reset() override
{
if (flags & NOT_NULL_FLAG)
{
set_notnull();
store(1LL, true);
}
else
reset();
}
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
double val_real() override;
longlong val_int() override;
String *val_str(String *, String *) override;
int cmp(const uchar *,const uchar *) const override;
void sort_string(uchar *buff,uint length) override;
uint32 pack_length() const override { return (uint32) packlength; }
void store_type(ulonglong value);
void sql_type(String &str) const override;
uint size_of() const override { return sizeof *this; }
uint pack_length_from_metadata(uint field_metadata) const override
{ return (field_metadata & 0x00ff); }
uint row_pack_length() const override { return pack_length(); }
bool zero_pack() const override { return false; }
bool optimize_range(uint, uint) const override { return false; }
bool eq_def(const Field *field) const override;
bool has_charset() const override { return true; }
/* enum and set are sorted as integers */
CHARSET_INFO *sort_charset() const override { return &my_charset_bin; }
decimal_digits_t decimals() const override { return 0; }
const TYPELIB *get_typelib() const override { return typelib; }
uchar *pack(uchar *to, const uchar *from, uint max_length) override;
const uchar *unpack(uchar *to, const uchar *from, const uchar *from_end,
uint param_data) override;
Data_type_compatibility can_optimize_keypart_ref(const Item_bool_func *cond,
const Item *item)
const override
{
return can_optimize_range_or_keypart_ref(cond, item);
}
Data_type_compatibility can_optimize_group_min_max(const Item_bool_func *cond,
const Item *const_item)
const override
{
/*
Can't use GROUP_MIN_MAX optimization for ENUM and SET,
because the values are stored as numbers in index,
while MIN() and MAX() work as strings.
It would return the records with min and max enum numeric indexes.
"Bug#45300 MAX() and ENUM type" should be fixed first.
*/
return Data_type_compatibility::INCOMPATIBLE_DATA_TYPE;
}
Data_type_compatibility can_optimize_range(const Item_bool_func *cond,
const Item *item,
bool is_eq_func) const override
{
return can_optimize_range_or_keypart_ref(cond, item);
}
Binlog_type_info binlog_type_info() const override;
private:
bool is_equal(const Column_definition &new_field) const override;
};
class Field_set final :public Field_enum {
public:
Field_set(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg, enum utype unireg_check_arg,
const LEX_CSTRING *field_name_arg, uint32 packlength_arg,
const TYPELIB *typelib_arg, const DTCollation &collation)
:Field_enum(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
field_name_arg, packlength_arg, typelib_arg, collation)
{
flags=(flags & ~ENUM_FLAG) | SET_FLAG;
}
void make_empty_rec_reset() override
{
Field::make_empty_rec_reset();
}
int store_field(Field *from) override { return from->save_in_field(this); }
int store(const char *to,size_t length,CHARSET_INFO *charset) override;
int store(double nr) override
{ return Field_set::store((longlong) nr, FALSE); }
int store(longlong nr, bool unsigned_val) override;
bool zero_pack() const override { return true; }
String *val_str(String *, String *) override;
void sql_type(String &str) const override;
uint size_of() const override { return sizeof *this; }
const Type_handler *type_handler() const override
{ return &type_handler_set; }
bool has_charset() const override { return true; }
Binlog_type_info binlog_type_info() const override;
};
/*
Note:
To use Field_bit::cmp_binary() you need to copy the bits stored in
the beginning of the record (the NULL bytes) to each memory you
want to compare (where the arguments point).
This is the reason:
- Field_bit::cmp_binary() is only implemented in the base class
(Field::cmp_binary()).
- Field::cmp_binary() currently uses pack_length() to calculate how
long the data is.
- pack_length() includes size of the bits stored in the NULL bytes
of the record.
*/
class Field_bit :public Field {
public:
uchar *bit_ptr; // position in record where 'uneven' bits store
uchar bit_ofs; // offset to 'uneven' high bits
uint bit_len; // number of 'uneven' high bits
uint bytes_in_rec;
Field_bit(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg);
const Type_handler *type_handler() const override
{ return &type_handler_bit; }
enum ha_base_keytype key_type() const override { return HA_KEYTYPE_BIT; }
uint16 key_part_flag() const override { return HA_BIT_PART; }
uint32 key_length() const override
{ return (uint32) (field_length + 7) / 8; }
uint32 max_data_length() const override { return key_length(); }
uint32 max_display_length() const override { return field_length; }
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override;
CHARSET_INFO *charset() const override { return &my_charset_bin; }
const DTCollation & dtcollation() const override;
Information_schema_numeric_attributes
information_schema_numeric_attributes() const override
{
return Information_schema_numeric_attributes(field_length);
}
void update_data_type_statistics(Data_type_statistics *st) const override
{
st->m_uneven_bit_length+= field_length & 7;
}
uint size_of() const override { return sizeof *this; }
int reset() override
{
bzero(ptr, bytes_in_rec);
if (bit_ptr && (bit_len > 0)) // reset odd bits among null bits
clr_rec_bits(bit_ptr, bit_ofs, bit_len);
return 0;
}
Copy_func *get_copy_func(const Field *from) const override
{
if (from->cmp_type() == DECIMAL_RESULT)
return do_field_decimal;
return do_field_int;
}
int save_in_field(Field *to) override { return to->store(val_int(), true); }
bool memcpy_field_possible(const Field *from) const override{ return false; }
int store(const char *to, size_t length, CHARSET_INFO *charset) override;
int store(double nr) override;
int store(longlong nr, bool unsigned_val) override;
int store_decimal(const my_decimal *) override;
double val_real() override;
longlong val_int() override;
String *val_str(String*, String *) override;
bool str_needs_quotes() const override { return true; }
my_decimal *val_decimal(my_decimal *) override;
bool val_bool() override { return val_int() != 0; }
int cmp(const uchar *a, const uchar *b) const override
{
DBUG_ASSERT(ptr == a || ptr == b);
if (ptr == a)
return Field_bit::key_cmp(b, bytes_in_rec + MY_TEST(bit_len));
else
return Field_bit::key_cmp(a, bytes_in_rec + MY_TEST(bit_len)) * -1;
}
int cmp_binary_offset(uint row_offset) override
{ return cmp_offset(row_offset); }
int cmp_prefix(const uchar *a, const uchar *b,
size_t prefix_char_length) const override;
int key_cmp(const uchar *a, const uchar *b) const override
{ return cmp_binary((uchar *) a, (uchar *) b); }
int key_cmp(const uchar *str, uint length) const override;
int cmp_offset(my_ptrdiff_t row_offset) override;
bool update_min(Field *min_val, bool force_update) override
{
longlong val= val_int();
bool update_fl= force_update || val < min_val->val_int();
if (update_fl)
{
min_val->set_notnull();
min_val->store(val, FALSE);
}
return update_fl;
}
bool update_max(Field *max_val, bool force_update) override
{
longlong val= val_int();
bool update_fl= force_update || val > max_val->val_int();
if (update_fl)
{
max_val->set_notnull();
max_val->store(val, FALSE);
}
return update_fl;
}
void store_field_value(uchar *val, uint) override
{
store(*((longlong *)val), TRUE);
}
double pos_in_interval(Field *min, Field *max) override
{
return pos_in_interval_val_real(min, max);
}
void get_image(uchar *buff, uint length,
const uchar *ptr_arg, CHARSET_INFO *cs) const override
{ get_key_image(buff, length, ptr_arg, itRAW); }
void set_image(const uchar *buff,uint length, CHARSET_INFO *cs) override
{ Field_bit::store((char *) buff, length, cs); }
uint get_key_image(uchar *buff, uint length,
const uchar *ptr_arg, imagetype type) const override;
void set_key_image(const uchar *buff, uint length) override
{ Field_bit::store((char*) buff, length, &my_charset_bin); }
void sort_string(uchar *buff, uint length) override
{ get_key_image(buff, length, ptr, itRAW); }
uint32 pack_length() const override
{ return (uint32) (field_length + 7) / 8; }
uint32 pack_length_in_rec() const override { return bytes_in_rec; }
uint pack_length_from_metadata(uint field_metadata) const override;
uint row_pack_length() const override
{ return (bytes_in_rec + ((bit_len > 0) ? 1 : 0)); }
bool compatible_field_size(uint metadata, const Relay_log_info *rli,
uint16 mflags, int *order_var) const override;
void sql_type(String &str) const override;
uchar *pack(uchar *to, const uchar *from, uint max_length) override;
const uchar *unpack(uchar *to, const uchar *from,
const uchar *from_end, uint param_data) override;
int set_default() override;
Field *new_key_field(MEM_ROOT *root, TABLE *new_table,
uchar *new_ptr, uint32 length,
uchar *new_null_ptr, uint new_null_bit) override;
void set_bit_ptr(uchar *bit_ptr_arg, uchar bit_ofs_arg)
{
bit_ptr= bit_ptr_arg;
bit_ofs= bit_ofs_arg;
}
bool eq(Field *field) override
{
return (Field::eq(field) &&
bit_ptr == ((Field_bit *)field)->bit_ptr &&
bit_ofs == ((Field_bit *)field)->bit_ofs);
}
bool is_equal(const Column_definition &new_field) const override;
void move_field_offset(my_ptrdiff_t ptr_diff) override
{
Field::move_field_offset(ptr_diff);
/*
clang does not like when things are added to a null pointer, even if
it is never referenced.
*/
if (bit_ptr)
bit_ptr= ADD_TO_PTR(bit_ptr, ptr_diff, uchar*);
}
void hash_not_null(Hasher *hasher) override;
SEL_ARG *get_mm_leaf(RANGE_OPT_PARAM *param, KEY_PART *key_part,
const Item_bool_func *cond,
scalar_comparison_op op, Item *value) override
{
return get_mm_leaf_int(param, key_part, cond, op, value, true);
}
void print_key_value(String *out, uint32 length) override
{
val_int_as_str(out, 1);
}
/**
Save the field metadata for bit fields.
Saves the bit length in the first byte and bytes in record in the
second byte of the field metadata array at index of *metadata_ptr and
*(metadata_ptr + 1).
@param metadata_ptr First byte of field metadata
@returns number of bytes written to metadata_ptr
*/
Binlog_type_info binlog_type_info() const override
{
DBUG_PRINT("debug", ("bit_len: %d, bytes_in_rec: %d",
bit_len, bytes_in_rec));
/*
Since this class and Field_bit_as_char have different ideas of
what should be stored here, we compute the values of the metadata
explicitly using the field_length.
*/
return Binlog_type_info(type(),
static_cast((field_length & 7) |
((field_length / 8) << 8)), 2);
}
private:
size_t do_last_null_byte() const override;
};
/**
BIT field represented as chars for non-MyISAM tables.
@todo The inheritance relationship is backwards since Field_bit is
an extended version of Field_bit_as_char and not the other way
around. Hence, we should refactor it to fix the hierarchy order.
*/
class Field_bit_as_char final :public Field_bit {
public:
Field_bit_as_char(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
uchar null_bit_arg,
enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg);
enum ha_base_keytype key_type() const override { return HA_KEYTYPE_BINARY; }
uint size_of() const override { return sizeof *this; }
int store(const char *to, size_t length, CHARSET_INFO *charset) override;
int store(double nr) override { return Field_bit::store(nr); }
int store(longlong nr, bool unsigned_val) override
{ return Field_bit::store(nr, unsigned_val); }
void sql_type(String &str) const override;
};
class Field_row final :public Field_null
{
class Virtual_tmp_table *m_table;
public:
Field_row(uchar *ptr_arg, const LEX_CSTRING *field_name_arg)
:Field_null(ptr_arg, 0, Field::NONE, field_name_arg, &my_charset_bin),
m_table(NULL)
{}
~Field_row();
en_fieldtype tmp_engine_column_type(bool use_packed_rows) const override
{
DBUG_ASSERT(0);
return Field::tmp_engine_column_type(use_packed_rows);
}
enum_conv_type rpl_conv_type_from(const Conv_source &source,
const Relay_log_info *rli,
const Conv_param ¶m) const override
{
DBUG_ASSERT(0);
return CONV_TYPE_IMPOSSIBLE;
}
Virtual_tmp_table **virtual_tmp_table_addr() override { return &m_table; }
bool sp_prepare_and_store_item(THD *thd, Item **value) override;
};
extern const LEX_CSTRING null_clex_str;
class Column_definition_attributes
{
public:
/*
At various stages in execution this can be length of field in bytes or
max number of characters.
*/
ulonglong length;
const TYPELIB *interval;
CHARSET_INFO *charset;
uint32 srid;
uint32 pack_flag;
decimal_digits_t decimals;
Field::utype unireg_check;
Column_definition_attributes()
:length(0),
interval(NULL),
charset(&my_charset_bin),
srid(0),
pack_flag(0),
decimals(0),
unireg_check(Field::NONE)
{ }
Column_definition_attributes(const Field *field);
Column_definition_attributes(const Type_all_attributes &attr);
Field *make_field(TABLE_SHARE *share, MEM_ROOT *mem_root,
const Record_addr *rec,
const Type_handler *handler,
const LEX_CSTRING *field_name,
uint32 flags) const;
uint temporal_dec(uint intlen) const
{
return (uint) (length > intlen ? length - intlen - 1 : 0);
}
uint pack_flag_to_pack_length() const;
void frm_pack_basic(uchar *buff) const;
void frm_pack_charset(uchar *buff) const;
void frm_pack_numeric_with_dec(uchar *buff) const;
void frm_unpack_basic(const uchar *buff);
bool frm_unpack_charset(TABLE_SHARE *share, const uchar *buff);
bool frm_unpack_numeric_with_dec(TABLE_SHARE *share, const uchar *buff);
bool frm_unpack_temporal_with_dec(TABLE_SHARE *share, uint intlen,
const uchar *buff);
void set_length_and_dec(const Lex_length_and_dec_st &attr);
CHARSET_INFO *explicit_or_derived_charset(const Column_derived_attributes
*derived_attr) const
{
return charset ? charset : derived_attr->charset();
}
};
/*
Create field class for CREATE TABLE
*/
class Column_definition: public Sql_alloc,
public Type_handler_hybrid_field_type,
public Column_definition_attributes
{
/**
Create "interval" from "interval_list".
@param mem_root - memory root to create the TYPELIB
instance and its values on
@param reuse_interval_list_values - determines if TYPELIB can reuse strings
from interval_list, or should always
allocate a copy on mem_root, even if
character set conversion is not needed
@retval false on success
@retval true on error (bad values, or EOM)
*/
bool create_interval_from_interval_list(MEM_ROOT *mem_root,
bool reuse_interval_list_values);
/*
Calculate TYPELIB (set or enum) max and total lengths
@param cs charset+collation pair of the interval
@param max_length length of the longest item
@param tot_length sum of the item lengths
After this method call:
- ENUM uses max_length
- SET uses tot_length.
*/
void calculate_interval_lengths(uint32 *max_length, uint32 *tot_length)
{
const char **pos;
uint *len;
*max_length= *tot_length= 0;
for (pos= interval->type_names, len= interval->type_lengths;
*pos ; pos++, len++)
{
size_t length= charset->numchars(*pos, *pos + *len);
DBUG_ASSERT(length < UINT_MAX32);
*tot_length+= (uint) length;
set_if_bigger(*max_length, (uint32)length);
}
}
bool prepare_stage1_check_typelib_default();
bool prepare_stage1_convert_default(THD *, MEM_ROOT *, CHARSET_INFO *to);
const Type_handler *field_type() const; // Prevent using this
Compression_method *compression_method_ptr;
public:
Lex_ident field_name;
LEX_CSTRING comment; // Comment for field
enum enum_column_versioning
{
VERSIONING_NOT_SET,
WITH_VERSIONING,
WITHOUT_VERSIONING
};
Item *on_update; // ON UPDATE NOW()
field_visibility_t invisible;
/*
The value of `length' as set by parser: is the number of characters
for most of the types, or of bytes for BLOBs or numeric types.
*/
uint32 char_length;
uint flags, pack_length;
List interval_list;
engine_option_value *option_list;
bool explicitly_nullable;
/*
This is additinal data provided for any computed(virtual) field.
In particular it includes a pointer to the item by which this field
can be computed from other fields.
*/
Virtual_column_info
*vcol_info, // Virtual field
*default_value, // Default value
*check_constraint; // Check constraint
enum_column_versioning versioning;
Table_period_info *period;
Column_definition()
:Type_handler_hybrid_field_type(&type_handler_null),
compression_method_ptr(0),
comment(null_clex_str),
on_update(NULL), invisible(VISIBLE), char_length(0),
flags(0), pack_length(0),
option_list(NULL), explicitly_nullable(false),
vcol_info(0), default_value(0), check_constraint(0),
versioning(VERSIONING_NOT_SET), period(NULL)
{
interval_list.empty();
}
Column_definition(THD *thd, Field *field, Field *orig_field);
bool set_attributes(THD *thd,
const Lex_field_type_st &attr,
column_definition_type_t type);
void create_length_to_internal_length_null()
{
DBUG_ASSERT(length == 0);
pack_length= 0;
}
void create_length_to_internal_length_simple()
{
pack_length= type_handler()->calc_pack_length((uint32) length);
}
void create_length_to_internal_length_string()
{
length*= charset->mbmaxlen;
if (real_field_type() == MYSQL_TYPE_VARCHAR && compression_method())
length++;
set_if_smaller(length, UINT_MAX32);
pack_length= type_handler()->calc_pack_length((uint32) length);
}
void create_length_to_internal_length_typelib()
{
/* Pack_length already calculated in sql_parse.cc */
length*= charset->mbmaxlen;
}
bool vers_sys_field() const
{
return flags & (VERS_ROW_START | VERS_ROW_END);
}
void create_length_to_internal_length_bit();
void create_length_to_internal_length_newdecimal();
/*
Prepare the "charset" member for string data types,
such as CHAR, VARCHAR, TEXT, ENUM, SET:
- derive the charset if not specified explicitly
- find a _bin collation if the BINARY comparison style was specified, e.g.:
CREATE TABLE t1 (a VARCHAR(10) BINARY) CHARSET utf8;
*/
bool prepare_charset_for_string(Sql_used *used,
const Charset_collation_map_st &map,
const Column_derived_attributes *dattr);
/**
Prepare a SET/ENUM field.
Create "interval" from "interval_list" if needed, and adjust "length".
@param mem_root - Memory root to allocate TYPELIB and
its values on
@param reuse_interval_list_values - determines if TYPELIB can reuse value
buffers from interval_list, or should
always allocate a copy on mem_root,
even if character set conversion
is not needed
*/
bool prepare_interval_field(MEM_ROOT *mem_root,
bool reuse_interval_list_values);
void prepare_interval_field_calc_length()
{
uint32 field_length, dummy;
if (real_field_type() == MYSQL_TYPE_SET)
{
calculate_interval_lengths(&dummy, &field_length);
length= field_length + (interval->count - 1);
}
else /* MYSQL_TYPE_ENUM */
{
calculate_interval_lengths(&field_length, &dummy);
length= field_length;
}
set_if_smaller(length, MAX_FIELD_WIDTH - 1);
}
bool prepare_blob_field(THD *thd);
bool sp_prepare_create_field(THD *thd, MEM_ROOT *mem_root);
bool prepare_stage1(THD *thd, MEM_ROOT *mem_root,
column_definition_type_t type,
const Column_derived_attributes *derived_attr);
void prepare_stage1_simple(CHARSET_INFO *cs)
{
charset= cs;
create_length_to_internal_length_simple();
}
bool prepare_stage1_typelib(THD *thd, MEM_ROOT *mem_root,
column_definition_type_t deftype);
bool prepare_stage1_string(THD *thd, MEM_ROOT *mem_root);
bool prepare_stage1_bit(THD *thd, MEM_ROOT *mem_root);
bool bulk_alter(const Column_derived_attributes *derived_attr,
const Column_bulk_alter_attributes *bulk_attr)
{
return type_handler()->Column_definition_bulk_alter(this,
derived_attr,
bulk_attr);
}
void redefine_stage1_common(const Column_definition *dup_field,
const handler *file);
bool redefine_stage1(const Column_definition *dup_field, const handler *file)
{
const Type_handler *handler= dup_field->type_handler();
return handler->Column_definition_redefine_stage1(this, dup_field, file);
}
bool prepare_stage2(handler *handler, ulonglong table_flags);
bool prepare_stage2_blob(handler *handler,
ulonglong table_flags, uint field_flags);
bool prepare_stage2_varchar(ulonglong table_flags);
bool prepare_stage2_typelib(const char *type_name, uint field_flags,
uint *dup_val_count);
uint pack_flag_numeric() const;
uint sign_length() const { return flags & UNSIGNED_FLAG ? 0 : 1; }
bool check_length(uint mysql_errno, uint max_allowed_length) const;
bool fix_attributes_real(uint default_length);
bool fix_attributes_int(uint default_length);
bool fix_attributes_decimal();
bool fix_attributes_temporal_with_time(uint int_part_length);
bool fix_attributes_bit();
bool check(THD *thd);
bool validate_check_constraint(THD *thd);
bool stored_in_db() const { return !vcol_info || vcol_info->is_stored(); }
ha_storage_media field_storage_type() const
{
return (ha_storage_media)
((flags >> FIELD_FLAGS_STORAGE_MEDIA) & 3);
}
column_format_type column_format() const
{
return (column_format_type)
((flags >> FIELD_FLAGS_COLUMN_FORMAT) & 3);
}
bool has_default_function() const
{
return unireg_check != Field::NONE;
}
Field *make_field(TABLE_SHARE *share, MEM_ROOT *mem_root,
const Record_addr *addr,
const LEX_CSTRING *field_name_arg) const
{
return Column_definition_attributes::make_field(share, mem_root, addr,
type_handler(),
field_name_arg, flags);
}
Field *make_field(TABLE_SHARE *share, MEM_ROOT *mem_root,
const LEX_CSTRING *field_name_arg) const
{
Record_addr addr(true);
return make_field(share, mem_root, &addr, field_name_arg);
}
/* Return true if default is an expression that must be saved explicitly */
bool has_default_expression();
bool has_default_now_unireg_check() const
{
return unireg_check == Field::TIMESTAMP_DN_FIELD
|| unireg_check == Field::TIMESTAMP_DNUN_FIELD;
}
void set_type(const Column_definition &other)
{
set_handler(other.type_handler());
length= other.length;
char_length= other.char_length;
decimals= other.decimals;
flags= other.flags;
pack_length= other.pack_length;
unireg_check= other.unireg_check;
interval= other.interval;
charset= other.charset;
srid= other.srid;
pack_flag= other.pack_flag;
}
// Replace the entire value by another definition
void set_column_definition(const Column_definition *def)
{
*this= *def;
}
bool set_compressed(const char *method);
bool set_compressed_deprecated(THD *thd, const char *method);
bool set_compressed_deprecated_column_attribute(THD *thd,
const char *pos,
const char *method);
void set_compression_method(Compression_method *compression_method_arg)
{ compression_method_ptr= compression_method_arg; }
Compression_method *compression_method() const
{ return compression_method_ptr; }
bool check_vcol_for_key(THD *thd) const;
void set_charset_collation_attrs(Sql_used *used,
const Charset_collation_map_st &map, const
Lex_column_charset_collation_attrs_st &lc)
{
charset= lc.charset_info(used, map);
if (lc.is_contextually_typed_collation())
flags|= CONTEXT_COLLATION_FLAG;
else
flags&= ~CONTEXT_COLLATION_FLAG;
}
Lex_column_charset_collation_attrs charset_collation_attrs() const
{
if (!charset)
return Lex_column_charset_collation_attrs();
if (flags & CONTEXT_COLLATION_FLAG)
return Lex_column_charset_collation_attrs(Lex_context_collation(charset));
return Lex_column_charset_collation_attrs(Lex_exact_collation(charset));
}
};
/**
List of ROW element definitions, e.g.:
DECLARE a ROW(a INT,b VARCHAR(10))
*/
class Row_definition_list: public List
{
public:
inline bool eq_name(const Spvar_definition *def, const LEX_CSTRING *name) const;
/**
Find a ROW field by name.
@param [IN] name - the name
@param [OUT] offset - if the ROW field found, its offset it returned here
@retval NULL - the ROW field was not found
@retval !NULL - the pointer to the found ROW field
*/
Spvar_definition *find_row_field_by_name(const LEX_CSTRING *name, uint *offset) const
{
// Cast-off the "const" qualifier
List_iterator it(*((List*)this));
Spvar_definition *def;
for (*offset= 0; (def= it++); (*offset)++)
{
if (eq_name(def, name))
return def;
}
return 0;
}
static Row_definition_list *make(MEM_ROOT *mem_root, Spvar_definition *var)
{
Row_definition_list *list;
if (!(list= new (mem_root) Row_definition_list()))
return NULL;
return list->push_back(var, mem_root) ? NULL : list;
}
bool append_uniq(MEM_ROOT *thd, Spvar_definition *var);
bool adjust_formal_params_to_actual_params(THD *thd, List
- *args);
bool adjust_formal_params_to_actual_params(THD *thd,
Item **args, uint arg_count);
bool resolve_type_refs(THD *);
};
/**
This class is used during a stored routine or a trigger execution,
at sp_rcontext::create() time.
Currently it can represent:
- variables with explicit data types: DECLARE a INT;
- variables with data type references: DECLARE a t1.a%TYPE;
- ROW type variables
Notes:
- Scalar variables have m_field_definitions==NULL.
- ROW variables are defined as having MYSQL_TYPE_NULL,
with a non-empty m_field_definitions.
Data type references to other object types will be added soon, e.g.:
- DECLARE a table_name%ROWTYPE;
- DECLARE a cursor_name%ROWTYPE;
- DECLARE a record_name%TYPE;
- DECLARE a variable_name%TYPE;
*/
class Spvar_definition: public Column_definition
{
const Qualified_column_ident *m_column_type_ref; // for %TYPE
Table_ident *m_table_rowtype_ref; // for table%ROWTYPE
bool m_cursor_rowtype_ref; // for cursor%ROWTYPE
uint m_cursor_rowtype_offset; // for cursor%ROWTYPE
Row_definition_list *m_row_field_definitions; // for ROW
public:
Spvar_definition()
:m_column_type_ref(NULL),
m_table_rowtype_ref(NULL),
m_cursor_rowtype_ref(false),
m_cursor_rowtype_offset(0),
m_row_field_definitions(NULL)
{ }
Spvar_definition(THD *thd, Field *field)
:Column_definition(thd, field, NULL),
m_column_type_ref(NULL),
m_table_rowtype_ref(NULL),
m_cursor_rowtype_ref(false),
m_cursor_rowtype_offset(0),
m_row_field_definitions(NULL)
{ }
const Type_handler *type_handler() const
{
return Type_handler_hybrid_field_type::type_handler();
}
bool is_column_type_ref() const { return m_column_type_ref != 0; }
bool is_table_rowtype_ref() const { return m_table_rowtype_ref != 0; }
bool is_cursor_rowtype_ref() const { return m_cursor_rowtype_ref; }
bool is_explicit_data_type() const
{
return !is_column_type_ref() &&
!is_table_rowtype_ref() &&
!is_cursor_rowtype_ref();
}
const Qualified_column_ident *column_type_ref() const
{
return m_column_type_ref;
}
void set_column_type_ref(const Qualified_column_ident *ref)
{
m_column_type_ref= ref;
}
Table_ident *table_rowtype_ref() const
{
return m_table_rowtype_ref;
}
void set_table_rowtype_ref(Table_ident *ref)
{
DBUG_ASSERT(ref);
set_handler(&type_handler_row);
m_table_rowtype_ref= ref;
}
uint cursor_rowtype_offset() const
{
return m_cursor_rowtype_offset;
}
void set_cursor_rowtype_ref(uint offset)
{
set_handler(&type_handler_row);
m_cursor_rowtype_ref= true;
m_cursor_rowtype_offset= offset;
}
/*
Find a ROW field by name.
See Row_field_list::find_row_field_by_name() for details.
*/
Spvar_definition *find_row_field_by_name(const LEX_CSTRING *name, uint *offset) const
{
DBUG_ASSERT(m_row_field_definitions);
return m_row_field_definitions->find_row_field_by_name(name, offset);
}
uint is_row() const
{
return m_row_field_definitions != NULL;
}
// Check if "this" defines a ROW variable with n elements
uint is_row(uint n) const
{
return m_row_field_definitions != NULL &&
m_row_field_definitions->elements == n;
}
Row_definition_list *row_field_definitions() const
{
return m_row_field_definitions;
}
void set_row_field_definitions(Row_definition_list *list)
{
DBUG_ASSERT(list);
set_handler(&type_handler_row);
m_row_field_definitions= list;
}
};
inline bool Row_definition_list::eq_name(const Spvar_definition *def,
const LEX_CSTRING *name) const
{
return def->field_name.length == name->length && my_strcasecmp(system_charset_info, def->field_name.str, name->str) == 0;
}
class Create_field :public Column_definition
{
public:
LEX_CSTRING change; // Old column name if column is renamed by ALTER
LEX_CSTRING after; // Put column after this one
Field *field; // For alter table
const TYPELIB *save_interval; // Temporary copy for the above
// Used only for UCS2 intervals
/** structure with parsed options (for comparing fields in ALTER TABLE) */
ha_field_option_struct *option_struct;
uint offset;
uint8 interval_id;
bool create_if_not_exists; // Used in ALTER TABLE IF NOT EXISTS
Create_field():
Column_definition(),
field(0), option_struct(NULL),
create_if_not_exists(false)
{
change= after= null_clex_str;
}
Create_field(THD *thd, Field *old_field, Field *orig_field):
Column_definition(thd, old_field, orig_field),
change(old_field->field_name),
field(old_field), option_struct(old_field->option_struct),
create_if_not_exists(false)
{
after= null_clex_str;
}
/* Used to make a clone of this object for ALTER/CREATE TABLE */
Create_field *clone(MEM_ROOT *mem_root) const;
static void upgrade_data_types(List &list)
{
List_iterator it(list);
while (Create_field *f= it++)
f->type_handler()->type_handler_for_implicit_upgrade()->
Column_definition_implicit_upgrade_to_this(f);
}
};
/*
A class for sending info to the client
*/
class Send_field :public Sql_alloc,
public Type_handler_hybrid_field_type,
public Send_field_extended_metadata
{
public:
LEX_CSTRING db_name;
LEX_CSTRING table_name, org_table_name;
LEX_CSTRING col_name, org_col_name;
ulong length;
uint flags;
decimal_digits_t decimals;
Send_field(Field *field)
{
field->make_send_field(this);
DBUG_ASSERT(table_name.str != 0);
normalize();
}
Send_field(THD *thd, Item *item);
Send_field(Field *field,
const LEX_CSTRING &db_name_arg,
const LEX_CSTRING &table_name_arg)
:Type_handler_hybrid_field_type(field->type_handler()),
db_name(db_name_arg),
table_name(table_name_arg),
org_table_name(table_name_arg),
col_name(field->field_name),
org_col_name(field->field_name),
length(field->field_length),
flags(field->table->maybe_null ?
(field->flags & ~NOT_NULL_FLAG) : field->flags),
decimals(field->decimals())
{
normalize();
}
private:
void normalize()
{
/* limit number of decimals for float and double */
if (type_handler()->field_type() == MYSQL_TYPE_FLOAT ||
type_handler()->field_type() == MYSQL_TYPE_DOUBLE)
set_if_smaller(decimals, FLOATING_POINT_DECIMALS);
}
public:
// This should move to Type_handler eventually
uint32 max_char_length(CHARSET_INFO *cs) const
{
return type_handler()->field_type() >= MYSQL_TYPE_TINY_BLOB &&
type_handler()->field_type() <= MYSQL_TYPE_BLOB
? static_cast(length / cs->mbminlen)
: static_cast(length / cs->mbmaxlen);
}
uint32 max_octet_length(CHARSET_INFO *from, CHARSET_INFO *to) const
{
/*
For TEXT/BLOB columns, field_length describes the maximum data
length in bytes. There is no limit to the number of characters
that a TEXT column can store, as long as the data fits into
the designated space.
For the rest of textual columns, field_length is evaluated as
char_count * mbmaxlen, where character count is taken from the
definition of the column. In other words, the maximum number
of characters here is limited by the column definition.
When one has a LONG TEXT column with a single-byte
character set, and the connection character set is multi-byte, the
client may get fields longer than UINT_MAX32, due to
-> conversion.
In that case column max length would not fit into the 4 bytes
reserved for it in the protocol. So we cut it here to UINT_MAX32.
*/
return char_to_byte_length_safe(max_char_length(from), to->mbmaxlen);
}
// This should move to Type_handler eventually
bool is_sane_float() const
{
return (decimals <= FLOATING_POINT_DECIMALS ||
(type_handler()->field_type() != MYSQL_TYPE_FLOAT &&
type_handler()->field_type() != MYSQL_TYPE_DOUBLE));
}
bool is_sane_signess() const
{
if (type_handler() == type_handler()->type_handler_signed() &&
type_handler() == type_handler()->type_handler_unsigned())
return true; // Any signess is allowed, e.g. DOUBLE, DECIMAL
/*
We are here e.g. in case of INT data type.
The UNSIGNED_FLAG bit must match in flags and in the type handler.
*/
return ((bool) (flags & UNSIGNED_FLAG)) == type_handler()->is_unsigned();
}
bool is_sane() const
{
return is_sane_float() && is_sane_signess();
}
};
/*
A class for quick copying data to fields
*/
class Copy_field :public Sql_alloc {
public:
uchar *from_ptr,*to_ptr;
uchar *from_null_ptr,*to_null_ptr;
bool *null_row;
uint from_bit,to_bit;
/**
Number of bytes in the fields pointed to by 'from_ptr' and
'to_ptr'. Usually this is the number of bytes that are copied from
'from_ptr' to 'to_ptr'.
For variable-length fields (VARCHAR), the first byte(s) describe
the actual length of the text. For VARCHARs with length
< 256 there is 1 length byte
>= 256 there is 2 length bytes
Thus, if from_field is VARCHAR(10), from_length (and in most cases
to_length) is 11. For VARCHAR(1024), the length is 1026. @see
Field_varstring::length_bytes
Note that for VARCHARs, do_copy() will be do_varstring*() which
only copies the length-bytes (1 or 2) + the actual length of the
text instead of from/to_length bytes.
*/
uint from_length,to_length;
Field *from_field,*to_field;
mutable String tmp; // For items
Copy_field() = default;
~Copy_field() = default;
void set(Field *to,Field *from,bool save); // Field to field
void set(uchar *to,Field *from); // Field to string
void (*do_copy)(const Copy_field *);
void (*do_copy2)(const Copy_field *); // Used to handle null values
};
uint pack_length_to_packflag(uint type);
enum_field_types get_blob_type_from_length(ulong length);
int set_field_to_null(Field *field);
int set_field_to_null_with_conversions(Field *field, bool no_conversions);
int convert_null_to_field_value_or_error(Field *field, uint err);
bool check_expression(Virtual_column_info *vcol, const LEX_CSTRING *name,
enum_vcol_info_type type, Alter_info *alter_info= NULL);
/*
The following are for the interface with the .frm file
*/
#define FIELDFLAG_DECIMAL 1U
#define FIELDFLAG_BINARY 1U // Shares same flag
#define FIELDFLAG_NUMBER 2U
#define FIELDFLAG_ZEROFILL 4U
#define FIELDFLAG_PACK 120U // Bits used for packing
#define FIELDFLAG_INTERVAL 256U // mangled with decimals!
#define FIELDFLAG_BITFIELD 512U // mangled with decimals!
#define FIELDFLAG_BLOB 1024U // mangled with decimals!
#define FIELDFLAG_GEOM 2048U // mangled with decimals!
#define FIELDFLAG_TREAT_BIT_AS_CHAR 4096U /* use Field_bit_as_char */
#define FIELDFLAG_LONG_DECIMAL 8192U
#define FIELDFLAG_NO_DEFAULT 16384U /* sql */
#define FIELDFLAG_MAYBE_NULL 32768U // sql
#define FIELDFLAG_HEX_ESCAPE 0x10000U
#define FIELDFLAG_PACK_SHIFT 3
#define FIELDFLAG_DEC_SHIFT 8
#define FIELDFLAG_MAX_DEC 63U
#define FIELDFLAG_DEC_MASK 0x3F00U
#define MTYP_TYPENR(type) ((type) & 127U) // Remove bits from type
#define f_is_dec(x) ((x) & FIELDFLAG_DECIMAL)
#define f_is_num(x) ((x) & FIELDFLAG_NUMBER)
#define f_is_zerofill(x) ((x) & FIELDFLAG_ZEROFILL)
#define f_is_packed(x) ((x) & FIELDFLAG_PACK)
#define f_packtype(x) (((x) >> FIELDFLAG_PACK_SHIFT) & 15)
#define f_decimals(x) ((uint8) (((x) >> FIELDFLAG_DEC_SHIFT) & FIELDFLAG_MAX_DEC))
#define f_is_alpha(x) (!f_is_num(x))
#define f_is_binary(x) ((x) & FIELDFLAG_BINARY) // 4.0- compatibility
#define f_is_enum(x) (((x) & (FIELDFLAG_INTERVAL | FIELDFLAG_NUMBER)) == FIELDFLAG_INTERVAL)
#define f_is_bitfield(x) (((x) & (FIELDFLAG_BITFIELD | FIELDFLAG_NUMBER)) == FIELDFLAG_BITFIELD)
#define f_is_blob(x) (((x) & (FIELDFLAG_BLOB | FIELDFLAG_NUMBER)) == FIELDFLAG_BLOB)
#define f_is_geom(x) (((x) & (FIELDFLAG_GEOM | FIELDFLAG_NUMBER)) == FIELDFLAG_GEOM)
#define f_settype(x) (((uint) (x)) << FIELDFLAG_PACK_SHIFT)
#define f_maybe_null(x) ((x) & FIELDFLAG_MAYBE_NULL)
#define f_no_default(x) ((x) & FIELDFLAG_NO_DEFAULT)
#define f_bit_as_char(x) ((x) & FIELDFLAG_TREAT_BIT_AS_CHAR)
#define f_is_hex_escape(x) ((x) & FIELDFLAG_HEX_ESCAPE)
#define f_visibility(x) (static_cast ((x) & INVISIBLE_MAX_BITS))
inline
ulonglong TABLE::vers_end_id(const uchar *record_arg) const
{
DBUG_ASSERT(versioned(VERS_TRX_ID));
DBUG_ASSERT(dynamic_cast(vers_end_field()));
const uchar *ptr= vers_end_field()->ptr_in_record(record_arg);
return static_cast(sint8korr(ptr));
}
inline
ulonglong TABLE::vers_start_id(const uchar *record_arg) const
{
DBUG_ASSERT(versioned(VERS_TRX_ID));
DBUG_ASSERT(dynamic_cast(vers_start_field()));
const uchar *ptr= vers_start_field()->ptr_in_record(record_arg);
return static_cast(sint8korr(ptr));
}
double pos_in_interval_for_string(CHARSET_INFO *cset,
const uchar *midp_val, uint32 midp_len,
const uchar *min_val, uint32 min_len,
const uchar *max_val, uint32 max_len);
double pos_in_interval_for_double(double midp_val,
double min_val, double max_val);
#endif /* FIELD_INCLUDED */
PK ! E