-diff -urNpa mysql-8.0.37.orig/client/mysql.cc mysql-8.0.37/client/mysql.cc
---- mysql-8.0.37.orig/client/mysql.cc 2024-05-09 12:13:14.356961750 +0200
-+++ mysql-8.0.37/client/mysql.cc 2024-05-09 12:13:39.849316431 +0200
+diff -urNpa mysql-8.0.41.orig/client/mysql.cc mysql-8.0.41/client/mysql.cc
+--- mysql-8.0.41.orig/client/mysql.cc 2025-02-20 23:26:36.428279923 +0100
++++ mysql-8.0.41/client/mysql.cc 2025-02-20 23:30:23.903112288 +0100
@@ -82,6 +82,7 @@ Foundation, Inc., 51 Franklin St, Fifth
#define LOG_USER 0
#else
#include <syslog.h>
#define HAVE_READLINE
-@@ -1153,22 +1154,6 @@ static COMMANDS commands[] = {
+@@ -1154,22 +1155,6 @@ static COMMANDS commands[] = {
static const char *load_default_groups[] = {"mysql", "client", nullptr};
#ifdef HAVE_READLINE
static int not_in_history(const char *line);
static void initialize_readline(char *name);
#endif /* HAVE_READLINE */
+diff -urNpa mysql-8.0.41.orig/client/mysql.cc.orig mysql-8.0.41/client/mysql.cc.orig
+--- mysql-8.0.41.orig/client/mysql.cc.orig 1970-01-01 01:00:00.000000000 +0100
++++ mysql-8.0.41/client/mysql.cc.orig 2024-12-16 10:20:55.000000000 +0100
+@@ -0,0 +1,5482 @@
++/*
++Copyright (c) 2000, 2024, 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 designed to work 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 either included with
++the program or referenced in the documentation.
++
++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
++*/
++
++// mysql command tool
++
++#include "my_config.h"
++
++#include <errno.h>
++#include <fcntl.h>
++#include <inttypes.h>
++#include <math.h>
++#include <signal.h>
++#include <stdarg.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <sys/types.h>
++#include <time.h>
++
++#include "client/client_priv.h"
++#include "client/client_query_attributes.h"
++#include "client/my_readline.h"
++#include "client/pattern_matcher.h"
++#include "compression.h"
++#include "lex_string.h"
++#include "m_ctype.h"
++#include "my_compiler.h"
++#include "my_dbug.h"
++#include "my_default.h"
++#include "my_dir.h"
++#include "my_inttypes.h"
++#include "my_io.h"
++#include "my_loglevel.h"
++#include "my_macros.h"
++#include "typelib.h"
++#include "user_registration.h"
++#include "violite.h"
++
++#ifdef HAVE_SYS_IOCTL_H
++#include <sys/ioctl.h>
++#endif
++
++#if defined(USE_LIBEDIT_INTERFACE)
++#include <locale.h>
++#endif
++
++#ifdef HAVE_PWD_H
++#include <pwd.h>
++#endif
++
++#if defined(HAVE_TERM_H)
++#define NOMACROS // move() macro interferes with std::move.
++#include <curses.h>
++#include <term.h>
++#endif
++
++#if defined(_WIN32)
++#include <conio.h>
++
++// Not using syslog but EventLog on Win32, so a dummy facility is enough.
++#define LOG_USER 0
++#else
++#include <readline.h>
++#include <syslog.h>
++
++#define HAVE_READLINE
++#define USE_POPEN
++#endif
++
++#include <mysqld_error.h>
++#include <algorithm>
++#include <new>
++
++#include "sql-common/net_ns.h"
++#include "sql_common.h"
++
++using std::max;
++using std::min;
++
++extern CHARSET_INFO my_charset_utf16le_bin;
++
++const char *VER = "14.14";
++
++/* Don't try to make a nice table if the data is too big */
++#define MAX_COLUMN_LENGTH 1024
++
++/* Buffer to hold 'version' and 'version_comment' */
++static char *server_version = nullptr;
++
++/* Array of options to pass to libemysqld */
++#define MAX_SERVER_ARGS 64
++
++/* Maximum memory limit that can be claimed by alloca(). */
++#define MAX_ALLOCA_SIZE 512
++
++#include "sql_string.h"
++
++#ifdef FN_NO_CASE_SENSE
++#define cmp_database(cs, A, B) my_strcasecmp((cs), (A), (B))
++#else
++#define cmp_database(cs, A, B) strcmp((A), (B))
++#endif
++
++#include "client/completion_hash.h"
++#include "print_version.h"
++#include "welcome_copyright_notice.h" // ORACLE_WELCOME_COPYRIGHT_NOTICE
++
++#define PROMPT_CHAR '\\'
++#define DEFAULT_DELIMITER ";"
++
++#define MAX_BATCH_BUFFER_SIZE (1024L * 1024L * 1024L)
++
++/** default set of patterns used for history exclusion filter */
++const static std::string HI_DEFAULTS("*IDENTIFIED*:*PASSWORD*");
++
++/** used for matching which history lines to ignore */
++static Pattern_matcher ignore_matcher;
++
++struct STATUS {
++ int exit_status;
++ ulong query_start_line;
++ char *file_name;
++ LINE_BUFFER *line_buff;
++ bool batch, add_to_history;
++};
++
++static HashTable ht;
++static MEM_ROOT argv_alloc{PSI_NOT_INSTRUMENTED, 512};
++
++enum enum_info_type { INFO_INFO, INFO_ERROR, INFO_RESULT };
++typedef enum enum_info_type INFO_TYPE;
++
++static MYSQL mysql; /* The connection */
++static bool ignore_errors = false, wait_flag = false, quick = false,
++ connected = false, opt_raw_data = false, unbuffered = false,
++ output_tables = false, opt_rehash = true, skip_updates = false,
++ safe_updates = false, one_database = false, opt_compress = false,
++ using_opt_local_infile = false, vertical = false,
++ line_numbers = true, column_names = true, opt_html = false,
++ opt_xml = false, opt_nopager = true, opt_outfile = false,
++ named_cmds = false, opt_nobeep = false, opt_reconnect = true,
++ default_pager_set = false, opt_sigint_ignore = false,
++ auto_vertical_output = false, show_warnings = false,
++ executing_query = false, interrupted_query = false,
++ ignore_spaces = false, sigint_received = false, opt_syslog = false,
++ opt_binhex = false;
++static bool opt_binary_as_hex_set_explicitly = false;
++static bool debug_info_flag, debug_check_flag;
++static bool column_types_flag;
++static bool preserve_comments = false;
++static ulong opt_max_allowed_packet, opt_net_buffer_length;
++static uint verbose = 0, opt_silent = 0, opt_mysql_port = 0,
++ opt_local_infile = 0;
++static uint opt_enable_cleartext_plugin = 0;
++static bool using_opt_enable_cleartext_plugin = false;
++static uint my_end_arg;
++static char *opt_mysql_unix_port = nullptr;
++static char *opt_bind_addr = nullptr;
++static int connect_flag = CLIENT_INTERACTIVE;
++static bool opt_binary_mode = false;
++static bool opt_connect_expired_password = false;
++static char *current_host;
++static char *dns_srv_name;
++static char *current_db;
++static char *current_user = nullptr;
++static char *current_prompt = nullptr;
++static char *delimiter_str = nullptr;
++static char *opt_init_command = nullptr;
++static const char *default_charset = MYSQL_AUTODETECT_CHARSET_NAME;
++#ifdef HAVE_READLINE
++static char *histfile;
++static char *histfile_tmp;
++#endif
++static char *opt_histignore = nullptr;
++static String glob_buffer, old_buffer;
++static String processed_prompt;
++static char *full_username = nullptr, *part_username = nullptr,
++ *default_prompt = nullptr;
++static char *current_os_user = nullptr, *current_os_sudouser = nullptr;
++static int wait_time = 5;
++static STATUS status;
++static ulong select_limit, max_join_size, opt_connect_timeout = 0;
++static char mysql_charsets_dir[FN_REFLEN + 1];
++static char *opt_plugin_dir = nullptr, *opt_default_auth = nullptr;
++static char *opt_load_data_local_dir = nullptr;
++#ifdef HAVE_SETNS
++static char *opt_network_namespace = nullptr;
++#endif
++static const char *xmlmeta[] = {
++ "&", "&", "<", "<", ">", ">", "\"", """,
++ /* Turn \0 into a space. Why not �? That's not valid XML or HTML. */
++ "\0", " ", nullptr, nullptr};
++static const char *day_names[] = {"Sun", "Mon", "Tue", "Wed",
++ "Thu", "Fri", "Sat"};
++static const char *month_names[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
++ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
++static char default_pager[FN_REFLEN];
++static char pager[FN_REFLEN], outfile[FN_REFLEN];
++static FILE *PAGER, *OUTFILE;
++static MEM_ROOT hash_mem_root(PSI_NOT_INSTRUMENTED, 16384);
++static uint prompt_counter;
++static char delimiter[16] = DEFAULT_DELIMITER;
++static size_t delimiter_length = 1;
++unsigned short terminal_width = 80;
++static uint opt_zstd_compress_level = default_zstd_compression_level;
++static char *opt_compress_algorithm = nullptr;
++
++#if defined(_WIN32)
++static char *shared_memory_base_name = 0;
++#endif
++static uint opt_protocol = 0;
++static const CHARSET_INFO *charset_info = &my_charset_latin1;
++
++static char *opt_fido_register_factor = nullptr;
++static char *opt_oci_config_file = nullptr;
++static char *opt_authentication_oci_client_config_profile = nullptr;
++
++#include "authentication_kerberos_clientopt-vars.h"
++#include "caching_sha2_passwordopt-vars.h"
++#include "multi_factor_passwordopt-vars.h"
++#include "sslopt-vars.h"
++
++const char *default_dbug_option = "d:t:o,/tmp/mysql.trace";
++static void *ssl_session_data = nullptr;
++
++/*
++ completion_hash is an auxiliary feature for mysql client to complete
++ an object name(db name, table name and field name) automatically.
++ e.g.
++ mysql> use my_d
++ then press <TAB>, it will check the hash and complete the db name
++ for users.
++ the result will be:
++ mysql> use my_dbname
++
++ In general, this feature is only on when it is an interactive mysql client.
++ It is not possible to use it in test case.
++
++ For using this feature in test case, we add the option in debug code.
++*/
++#ifndef NDEBUG
++static bool opt_build_completion_hash = false;
++#endif
++
++#ifdef _WIN32
++/*
++ A flag that indicates if --execute buffer has already been converted,
++ to avoid double conversion on reconnect.
++*/
++static bool execute_buffer_conversion_done{false};
++
++/*
++ my_win_is_console(...) is quite slow.
++ We cache my_win_is_console() results for stdout and stderr.
++ Any other output files, except stdout and stderr,
++ cannot be Windows console.
++ Note, if mysql.exe is executed from a service, its _fileno(stdout) is -1,
++ so shift (1 << -1) can return implementation defined result.
++ This corner case is taken into account, as the shift result
++ will be multiplied to 0 and we'll get 0 as a result.
++ The same is true for stderr.
++*/
++static uint win_is_console_cache =
++ ((my_win_is_console(stdout)) * (1 << _fileno(stdout))) |
++ ((my_win_is_console(stderr)) * (1 << _fileno(stderr)));
++
++static inline bool my_win_is_console_cached(FILE *file) {
++ return win_is_console_cache & (1 << _fileno(file));
++}
++#endif /* _WIN32 */
++
++/* Various printing flags */
++#define MY_PRINT_ESC_0 1 /* Replace 0x00 bytes to "\0" */
++#define MY_PRINT_SPS_0 2 /* Replace 0x00 bytes to space */
++#define MY_PRINT_XML 4 /* Encode XML entities */
++#define MY_PRINT_MB 8 /* Recognize multi-byte characters */
++#define MY_PRINT_CTRL 16 /* Replace TAB, NL, CR to "\t", "\n", "\r" */
++
++void tee_write(FILE *file, const char *s, size_t slen, int flags);
++void tee_fprintf(FILE *file, const char *fmt, ...)
++ MY_ATTRIBUTE((format(printf, 2, 3)));
++void tee_fputs(const char *s, FILE *file);
++void tee_puts(const char *s, FILE *file);
++void tee_putc(int c, FILE *file);
++static void tee_print_sized_data(const char *, unsigned int, unsigned int,
++ bool);
++/* The names of functions that actually do the manipulation. */
++static int get_options(int argc, char **argv);
++extern "C" bool get_one_option(int optid, const struct my_option *opt,
++ char *argument);
++static int com_quit(String *str, char *), com_go(String *str, char *),
++ com_ego(String *str, char *), com_print(String *str, char *),
++ com_help(String *str, char *), com_clear(String *str, char *),
++ com_connect(String *str, char *), com_status(String *str, char *),
++ com_use(String *str, char *), com_source(String *str, char *),
++ com_rehash(String *str, char *), com_tee(String *str, char *),
++ com_notee(String *str, char *), com_charset(String *str, char *),
++ com_prompt(String *str, char *), com_delimiter(String *str, char *),
++ com_warnings(String *str, char *), com_nowarnings(String *str, char *),
++ com_resetconnection(String *str, char *),
++ com_query_attributes(String *str, char *),
++ com_ssl_session_data_print(String *str, char *);
++static int com_shell(String *str, char *);
++
++#ifdef USE_POPEN
++static int com_nopager(String *str, char *), com_pager(String *str, char *),
++ com_edit(String *str, char *);
++#endif
++
++static int read_and_execute(bool interactive);
++static bool init_connection_options(MYSQL *mysql);
++static int sql_connect(char *host, char *database, char *user, uint silent);
++static const char *server_version_string(MYSQL *mysql);
++static int put_info(const char *str, INFO_TYPE info, uint error = 0,
++ const char *sql_state = nullptr);
++static int put_error(MYSQL *mysql);
++static void put_error_if_any(MYSQL *mysql);
++static void safe_put_field(const char *pos, ulong length);
++static void xmlencode_print(const char *src, uint length);
++static void init_pager();
++static void end_pager();
++static void init_tee(const char *);
++static void end_tee();
++static const char *construct_prompt();
++static inline void reset_prompt(char *in_string, bool *ml_comment);
++static char *get_arg(char *line, bool get_next_arg);
++static void init_username();
++static void add_int_to_prompt(int toadd);
++static int get_result_width(MYSQL_RES *res);
++static int get_field_disp_length(MYSQL_FIELD *field);
++static int normalize_dbname(const char *line, char *buff, uint buff_size);
++static int get_quote_count(const char *line);
++
++static void add_filtered_history(const char *string);
++static void add_syslog(const char *buffer); /* for syslog */
++static void fix_line(String *buffer);
++
++static void get_current_os_user();
++static void get_current_os_sudouser();
++
++/* A structure which contains information on the commands this program
++ can understand. */
++
++typedef struct {
++ const char *name; /* User printable name of the function. */
++ char cmd_char; /* mysql command character. NULL if none */
++ int (*func)(String *str, char *); /* Function to call to do the job. */
++ bool takes_params; /* Max parameters for command */
++ const char *doc; /* Documentation for this function. */
++} COMMANDS;
++
++static COMMANDS commands[] = {
++ {"?", '?', com_help, true, "Synonym for `help'."},
++ {"clear", 'c', com_clear, false, "Clear the current input statement."},
++ {"connect", 'r', com_connect, true,
++ "Reconnect to the server. Optional arguments are db and host."},
++ {"delimiter", 'd', com_delimiter, true, "Set statement delimiter."},
++#ifdef USE_POPEN
++ {"edit", 'e', com_edit, false, "Edit command with $EDITOR."},
++#endif
++ {"ego", 'G', com_ego, false,
++ "Send command to mysql server, display result vertically."},
++ {"exit", 'q', com_quit, false, "Exit mysql. Same as quit."},
++ {"go", 'g', com_go, false, "Send command to mysql server."},
++ {"help", 'h', com_help, true, "Display this help."},
++#ifdef USE_POPEN
++ {"nopager", 'n', com_nopager, false, "Disable pager, print to stdout."},
++#endif
++ {"notee", 't', com_notee, false, "Don't write into outfile."},
++#ifdef USE_POPEN
++ {"pager", 'P', com_pager, true,
++ "Set PAGER [to_pager]. Print the query results via PAGER."},
++#endif
++ {"print", 'p', com_print, false, "Print current command."},
++ {"prompt", 'R', com_prompt, true, "Change your mysql prompt."},
++ {"quit", 'q', com_quit, false, "Quit mysql."},
++ {"rehash", '#', com_rehash, false, "Rebuild completion hash."},
++ {"source", '.', com_source, true,
++ "Execute an SQL script file. Takes a file name as an argument."},
++ {"status", 's', com_status, false,
++ "Get status information from the server."},
++ {"system", '!', com_shell, true,
++ "Execute a system shell command, if enabled"},
++ {"tee", 'T', com_tee, true,
++ "Set outfile [to_outfile]. Append everything into given outfile."},
++ {"use", 'u', com_use, true,
++ "Use another database. Takes database name as argument."},
++ {"charset", 'C', com_charset, true,
++ "Switch to another charset. Might be needed for processing binlog with "
++ "multi-byte charsets."},
++ {"warnings", 'W', com_warnings, false,
++ "Show warnings after every statement."},
++ {"nowarning", 'w', com_nowarnings, false,
++ "Don't show warnings after every statement."},
++ {"resetconnection", 'x', com_resetconnection, false,
++ "Clean session context."},
++ {"query_attributes", 0, com_query_attributes, true,
++ "Sets string parameters (name1 value1 name2 value2 ...) for the next "
++ "query to pick up."},
++ {"ssl_session_data_print", 0, com_ssl_session_data_print, true,
++ "Serializes the current SSL session data to stdout or file"},
++ /* Get bash-like expansion for some commands */
++ {"create table", 0, nullptr, false, ""},
++ {"create database", 0, nullptr, false, ""},
++ {"show databases", 0, nullptr, false, ""},
++ {"show fields from", 0, nullptr, false, ""},
++ {"show keys from", 0, nullptr, false, ""},
++ {"show tables", 0, nullptr, false, ""},
++ {"load data from", 0, nullptr, false, ""},
++ {"alter table", 0, nullptr, false, ""},
++ {"set option", 0, nullptr, false, ""},
++ {"lock tables", 0, nullptr, false, ""},
++ {"unlock tables", 0, nullptr, false, ""},
++ /* generated 2006-12-28. Refresh occasionally from lexer. */
++ {"ACTION", 0, nullptr, false, ""},
++ {"ADD", 0, nullptr, false, ""},
++ {"AFTER", 0, nullptr, false, ""},
++ {"AGAINST", 0, nullptr, false, ""},
++ {"AGGREGATE", 0, nullptr, false, ""},
++ {"ALL", 0, nullptr, false, ""},
++ {"ALGORITHM", 0, nullptr, false, ""},
++ {"ALTER", 0, nullptr, false, ""},
++ {"ANALYZE", 0, nullptr, false, ""},
++ {"AND", 0, nullptr, false, ""},
++ {"ANY", 0, nullptr, false, ""},
++ {"AS", 0, nullptr, false, ""},
++ {"ASC", 0, nullptr, false, ""},
++ {"ASCII", 0, nullptr, false, ""},
++ {"ASENSITIVE", 0, nullptr, false, ""},
++ {"AUTO_INCREMENT", 0, nullptr, false, ""},
++ {"AVG", 0, nullptr, false, ""},
++ {"AVG_ROW_LENGTH", 0, nullptr, false, ""},
++ {"BACKUP", 0, nullptr, false, ""},
++ {"BDB", 0, nullptr, false, ""},
++ {"BEFORE", 0, nullptr, false, ""},
++ {"BEGIN", 0, nullptr, false, ""},
++ {"BERKELEYDB", 0, nullptr, false, ""},
++ {"BETWEEN", 0, nullptr, false, ""},
++ {"BIGINT", 0, nullptr, false, ""},
++ {"BINARY", 0, nullptr, false, ""},
++ {"BINLOG", 0, nullptr, false, ""},
++ {"BIT", 0, nullptr, false, ""},
++ {"BLOB", 0, nullptr, false, ""},
++ {"BOOL", 0, nullptr, false, ""},
++ {"BOOLEAN", 0, nullptr, false, ""},
++ {"BOTH", 0, nullptr, false, ""},
++ {"BTREE", 0, nullptr, false, ""},
++ {"BY", 0, nullptr, false, ""},
++ {"BYTE", 0, nullptr, false, ""},
++ {"CACHE", 0, nullptr, false, ""},
++ {"CALL", 0, nullptr, false, ""},
++ {"CASCADE", 0, nullptr, false, ""},
++ {"CASCADED", 0, nullptr, false, ""},
++ {"CASE", 0, nullptr, false, ""},
++ {"CHAIN", 0, nullptr, false, ""},
++ {"CHANGE", 0, nullptr, false, ""},
++ {"CHANGED", 0, nullptr, false, ""},
++ {"CHAR", 0, nullptr, false, ""},
++ {"CHARACTER", 0, nullptr, false, ""},
++ {"CHARSET", 0, nullptr, false, ""},
++ {"CHECK", 0, nullptr, false, ""},
++ {"CHECKSUM", 0, nullptr, false, ""},
++ {"CIPHER", 0, nullptr, false, ""},
++ {"CLIENT", 0, nullptr, false, ""},
++ {"CLOSE", 0, nullptr, false, ""},
++ {"CODE", 0, nullptr, false, ""},
++ {"COLLATE", 0, nullptr, false, ""},
++ {"COLLATION", 0, nullptr, false, ""},
++ {"COLUMN", 0, nullptr, false, ""},
++ {"COLUMNS", 0, nullptr, false, ""},
++ {"COMMENT", 0, nullptr, false, ""},
++ {"COMMIT", 0, nullptr, false, ""},
++ {"COMMITTED", 0, nullptr, false, ""},
++ {"COMPACT", 0, nullptr, false, ""},
++ {"COMPRESSED", 0, nullptr, false, ""},
++ {"CONCURRENT", 0, nullptr, false, ""},
++ {"CONDITION", 0, nullptr, false, ""},
++ {"CONNECTION", 0, nullptr, false, ""},
++ {"CONSISTENT", 0, nullptr, false, ""},
++ {"CONSTRAINT", 0, nullptr, false, ""},
++ {"CONTAINS", 0, nullptr, false, ""},
++ {"CONTINUE", 0, nullptr, false, ""},
++ {"CONVERT", 0, nullptr, false, ""},
++ {"CREATE", 0, nullptr, false, ""},
++ {"CROSS", 0, nullptr, false, ""},
++ {"CUBE", 0, nullptr, false, ""},
++ {"CURRENT_DATE", 0, nullptr, false, ""},
++ {"CURRENT_TIME", 0, nullptr, false, ""},
++ {"CURRENT_TIMESTAMP", 0, nullptr, false, ""},
++ {"CURRENT_USER", 0, nullptr, false, ""},
++ {"CURSOR", 0, nullptr, false, ""},
++ {"DATA", 0, nullptr, false, ""},
++ {"DATABASE", 0, nullptr, false, ""},
++ {"DATABASES", 0, nullptr, false, ""},
++ {"DATE", 0, nullptr, false, ""},
++ {"DATETIME", 0, nullptr, false, ""},
++ {"DAY", 0, nullptr, false, ""},
++ {"DAY_HOUR", 0, nullptr, false, ""},
++ {"DAY_MICROSECOND", 0, nullptr, false, ""},
++ {"DAY_MINUTE", 0, nullptr, false, ""},
++ {"DAY_SECOND", 0, nullptr, false, ""},
++ {"DEALLOCATE", 0, nullptr, false, ""},
++ {"DEC", 0, nullptr, false, ""},
++ {"DECIMAL", 0, nullptr, false, ""},
++ {"DECLARE", 0, nullptr, false, ""},
++ {"DEFAULT", 0, nullptr, false, ""},
++ {"DEFINER", 0, nullptr, false, ""},
++ {"DELAYED", 0, nullptr, false, ""},
++ {"DELAY_KEY_WRITE", 0, nullptr, false, ""},
++ {"DELETE", 0, nullptr, false, ""},
++ {"DESC", 0, nullptr, false, ""},
++ {"DESCRIBE", 0, nullptr, false, ""},
++ {"DETERMINISTIC", 0, nullptr, false, ""},
++ {"DIRECTORY", 0, nullptr, false, ""},
++ {"DISABLE", 0, nullptr, false, ""},
++ {"DISCARD", 0, nullptr, false, ""},
++ {"DISTINCT", 0, nullptr, false, ""},
++ {"DISTINCTROW", 0, nullptr, false, ""},
++ {"DIV", 0, nullptr, false, ""},
++ {"DO", 0, nullptr, false, ""},
++ {"DOUBLE", 0, nullptr, false, ""},
++ {"DROP", 0, nullptr, false, ""},
++ {"DUAL", 0, nullptr, false, ""},
++ {"DUMPFILE", 0, nullptr, false, ""},
++ {"DUPLICATE", 0, nullptr, false, ""},
++ {"DYNAMIC", 0, nullptr, false, ""},
++ {"EACH", 0, nullptr, false, ""},
++ {"ELSE", 0, nullptr, false, ""},
++ {"ELSEIF", 0, nullptr, false, ""},
++ {"ENABLE", 0, nullptr, false, ""},
++ {"ENCLOSED", 0, nullptr, false, ""},
++ {"END", 0, nullptr, false, ""},
++ {"ENGINE", 0, nullptr, false, ""},
++ {"ENGINES", 0, nullptr, false, ""},
++ {"ENUM", 0, nullptr, false, ""},
++ {"ERRORS", 0, nullptr, false, ""},
++ {"ESCAPE", 0, nullptr, false, ""},
++ {"ESCAPED", 0, nullptr, false, ""},
++ {"EVENTS", 0, nullptr, false, ""},
++ {"EXECUTE", 0, nullptr, false, ""},
++ {"EXISTS", 0, nullptr, false, ""},
++ {"EXIT", 0, nullptr, false, ""},
++ {"EXPANSION", 0, nullptr, false, ""},
++ {"EXPLAIN", 0, nullptr, false, ""},
++ {"EXTENDED", 0, nullptr, false, ""},
++ {"FALSE", 0, nullptr, false, ""},
++ {"FAST", 0, nullptr, false, ""},
++ {"FETCH", 0, nullptr, false, ""},
++ {"FIELDS", 0, nullptr, false, ""},
++ {"FILE", 0, nullptr, false, ""},
++ {"FIRST", 0, nullptr, false, ""},
++ {"FIXED", 0, nullptr, false, ""},
++ {"FLOAT", 0, nullptr, false, ""},
++ {"FLOAT4", 0, nullptr, false, ""},
++ {"FLOAT8", 0, nullptr, false, ""},
++ {"FLUSH", 0, nullptr, false, ""},
++ {"FOR", 0, nullptr, false, ""},
++ {"FORCE", 0, nullptr, false, ""},
++ {"FOREIGN", 0, nullptr, false, ""},
++ {"FOUND", 0, nullptr, false, ""},
++ {"FROM", 0, nullptr, false, ""},
++ {"FULL", 0, nullptr, false, ""},
++ {"FULLTEXT", 0, nullptr, false, ""},
++ {"FUNCTION", 0, nullptr, false, ""},
++ {"GEOMETRY", 0, nullptr, false, ""},
++ {"GEOMETRYCOLLECTION", 0, nullptr, false, ""},
++ {"GET_FORMAT", 0, nullptr, false, ""},
++ {"GLOBAL", 0, nullptr, false, ""},
++ {"GRANT", 0, nullptr, false, ""},
++ {"GRANTS", 0, nullptr, false, ""},
++ {"GROUP", 0, nullptr, false, ""},
++ {"HANDLER", 0, nullptr, false, ""},
++ {"HASH", 0, nullptr, false, ""},
++ {"HAVING", 0, nullptr, false, ""},
++ {"HELP", 0, nullptr, false, ""},
++ {"HIGH_PRIORITY", 0, nullptr, false, ""},
++ {"HOSTS", 0, nullptr, false, ""},
++ {"HOUR", 0, nullptr, false, ""},
++ {"HOUR_MICROSECOND", 0, nullptr, false, ""},
++ {"HOUR_MINUTE", 0, nullptr, false, ""},
++ {"HOUR_SECOND", 0, nullptr, false, ""},
++ {"IDENTIFIED", 0, nullptr, false, ""},
++ {"IF", 0, nullptr, false, ""},
++ {"IGNORE", 0, nullptr, false, ""},
++ {"IMPORT", 0, nullptr, false, ""},
++ {"IN", 0, nullptr, false, ""},
++ {"INDEX", 0, nullptr, false, ""},
++ {"INDEXES", 0, nullptr, false, ""},
++ {"INFILE", 0, nullptr, false, ""},
++ {"INNER", 0, nullptr, false, ""},
++ {"INNOBASE", 0, nullptr, false, ""},
++ {"INNODB", 0, nullptr, false, ""},
++ {"INOUT", 0, nullptr, false, ""},
++ {"INSENSITIVE", 0, nullptr, false, ""},
++ {"INSERT", 0, nullptr, false, ""},
++ {"INSERT_METHOD", 0, nullptr, false, ""},
++ {"INT", 0, nullptr, false, ""},
++ {"INT1", 0, nullptr, false, ""},
++ {"INT2", 0, nullptr, false, ""},
++ {"INT3", 0, nullptr, false, ""},
++ {"INT4", 0, nullptr, false, ""},
++ {"INT8", 0, nullptr, false, ""},
++ {"INTEGER", 0, nullptr, false, ""},
++ {"INTERVAL", 0, nullptr, false, ""},
++ {"INTO", 0, nullptr, false, ""},
++ {"IO_THREAD", 0, nullptr, false, ""},
++ {"IS", 0, nullptr, false, ""},
++ {"ISOLATION", 0, nullptr, false, ""},
++ {"ISSUER", 0, nullptr, false, ""},
++ {"ITERATE", 0, nullptr, false, ""},
++ {"INVOKER", 0, nullptr, false, ""},
++ {"JOIN", 0, nullptr, false, ""},
++ {"KEY", 0, nullptr, false, ""},
++ {"KEYS", 0, nullptr, false, ""},
++ {"KILL", 0, nullptr, false, ""},
++ {"LANGUAGE", 0, nullptr, false, ""},
++ {"LAST", 0, nullptr, false, ""},
++ {"LEADING", 0, nullptr, false, ""},
++ {"LEAVE", 0, nullptr, false, ""},
++ {"LEAVES", 0, nullptr, false, ""},
++ {"LEFT", 0, nullptr, false, ""},
++ {"LEVEL", 0, nullptr, false, ""},
++ {"LIKE", 0, nullptr, false, ""},
++ {"LIMIT", 0, nullptr, false, ""},
++ {"LINES", 0, nullptr, false, ""},
++ {"LINESTRING", 0, nullptr, false, ""},
++ {"LOAD", 0, nullptr, false, ""},
++ {"LOCAL", 0, nullptr, false, ""},
++ {"LOCALTIME", 0, nullptr, false, ""},
++ {"LOCALTIMESTAMP", 0, nullptr, false, ""},
++ {"LOCK", 0, nullptr, false, ""},
++ {"LOCKS", 0, nullptr, false, ""},
++ {"LOGS", 0, nullptr, false, ""},
++ {"LONG", 0, nullptr, false, ""},
++ {"LONGBLOB", 0, nullptr, false, ""},
++ {"LONGTEXT", 0, nullptr, false, ""},
++ {"LOOP", 0, nullptr, false, ""},
++ {"LOW_PRIORITY", 0, nullptr, false, ""},
++ {"MASTER", 0, nullptr, false, ""},
++ {"MASTER_CONNECT_RETRY", 0, nullptr, false, ""},
++ {"MASTER_HOST", 0, nullptr, false, ""},
++ {"MASTER_LOG_FILE", 0, nullptr, false, ""},
++ {"MASTER_LOG_POS", 0, nullptr, false, ""},
++ {"MASTER_PASSWORD", 0, nullptr, false, ""},
++ {"MASTER_PORT", 0, nullptr, false, ""},
++ {"MASTER_SERVER_ID", 0, nullptr, false, ""},
++ {"MASTER_SSL", 0, nullptr, false, ""},
++ {"MASTER_SSL_CA", 0, nullptr, false, ""},
++ {"MASTER_SSL_CAPATH", 0, nullptr, false, ""},
++ {"MASTER_SSL_CERT", 0, nullptr, false, ""},
++ {"MASTER_SSL_CIPHER", 0, nullptr, false, ""},
++ {"MASTER_TLS_VERSION", 0, nullptr, false, ""},
++ {"MASTER_SSL_KEY", 0, nullptr, false, ""},
++ {"MASTER_USER", 0, nullptr, false, ""},
++ {"MATCH", 0, nullptr, false, ""},
++ {"MAX_CONNECTIONS_PER_HOUR", 0, nullptr, false, ""},
++ {"MAX_QUERIES_PER_HOUR", 0, nullptr, false, ""},
++ {"MAX_ROWS", 0, nullptr, false, ""},
++ {"MAX_UPDATES_PER_HOUR", 0, nullptr, false, ""},
++ {"MAX_USER_CONNECTIONS", 0, nullptr, false, ""},
++ {"MEDIUM", 0, nullptr, false, ""},
++ {"MEDIUMBLOB", 0, nullptr, false, ""},
++ {"MEDIUMINT", 0, nullptr, false, ""},
++ {"MEDIUMTEXT", 0, nullptr, false, ""},
++ {"MERGE", 0, nullptr, false, ""},
++ {"MICROSECOND", 0, nullptr, false, ""},
++ {"MIDDLEINT", 0, nullptr, false, ""},
++ {"MIGRATE", 0, nullptr, false, ""},
++ {"MINUTE", 0, nullptr, false, ""},
++ {"MINUTE_MICROSECOND", 0, nullptr, false, ""},
++ {"MINUTE_SECOND", 0, nullptr, false, ""},
++ {"MIN_ROWS", 0, nullptr, false, ""},
++ {"MOD", 0, nullptr, false, ""},
++ {"MODE", 0, nullptr, false, ""},
++ {"MODIFIES", 0, nullptr, false, ""},
++ {"MODIFY", 0, nullptr, false, ""},
++ {"MONTH", 0, nullptr, false, ""},
++ {"MULTILINESTRING", 0, nullptr, false, ""},
++ {"MULTIPOINT", 0, nullptr, false, ""},
++ {"MULTIPOLYGON", 0, nullptr, false, ""},
++ {"MUTEX", 0, nullptr, false, ""},
++ {"NAME", 0, nullptr, false, ""},
++ {"NAMES", 0, nullptr, false, ""},
++ {"NATIONAL", 0, nullptr, false, ""},
++ {"NATURAL", 0, nullptr, false, ""},
++ {"NDB", 0, nullptr, false, ""},
++ {"NDBCLUSTER", 0, nullptr, false, ""},
++ {"NCHAR", 0, nullptr, false, ""},
++ {"NEW", 0, nullptr, false, ""},
++ {"NEXT", 0, nullptr, false, ""},
++ {"NO", 0, nullptr, false, ""},
++ {"NONE", 0, nullptr, false, ""},
++ {"NOT", 0, nullptr, false, ""},
++ {"NO_WRITE_TO_BINLOG", 0, nullptr, false, ""},
++ {"NULL", 0, nullptr, false, ""},
++ {"NUMERIC", 0, nullptr, false, ""},
++ {"NVARCHAR", 0, nullptr, false, ""},
++ {"OFFSET", 0, nullptr, false, ""},
++ {"ON", 0, nullptr, false, ""},
++ {"ONE", 0, nullptr, false, ""},
++ {"ONE_SHOT", 0, nullptr, false, ""},
++ {"OPEN", 0, nullptr, false, ""},
++ {"OPTIMIZE", 0, nullptr, false, ""},
++ {"OPTION", 0, nullptr, false, ""},
++ {"OPTIONALLY", 0, nullptr, false, ""},
++ {"OR", 0, nullptr, false, ""},
++ {"ORDER", 0, nullptr, false, ""},
++ {"OUT", 0, nullptr, false, ""},
++ {"OUTER", 0, nullptr, false, ""},
++ {"OUTFILE", 0, nullptr, false, ""},
++ {"PACK_KEYS", 0, nullptr, false, ""},
++ {"PARTIAL", 0, nullptr, false, ""},
++ {"PASSWORD", 0, nullptr, false, ""},
++ {"PHASE", 0, nullptr, false, ""},
++ {"POINT", 0, nullptr, false, ""},
++ {"POLYGON", 0, nullptr, false, ""},
++ {"PRECISION", 0, nullptr, false, ""},
++ {"PREPARE", 0, nullptr, false, ""},
++ {"PREV", 0, nullptr, false, ""},
++ {"PRIMARY", 0, nullptr, false, ""},
++ {"PRIVILEGES", 0, nullptr, false, ""},
++ {"PROCEDURE", 0, nullptr, false, ""},
++ {"PROCESS", 0, nullptr, false, ""},
++ {"PROCESSLIST", 0, nullptr, false, ""},
++ {"PURGE", 0, nullptr, false, ""},
++ {"QUARTER", 0, nullptr, false, ""},
++ {"QUERY", 0, nullptr, false, ""},
++ {"QUICK", 0, nullptr, false, ""},
++ {"READ", 0, nullptr, false, ""},
++ {"READS", 0, nullptr, false, ""},
++ {"REAL", 0, nullptr, false, ""},
++ {"RECOVER", 0, nullptr, false, ""},
++ {"REDUNDANT", 0, nullptr, false, ""},
++ {"REFERENCES", 0, nullptr, false, ""},
++ {"REGEXP", 0, nullptr, false, ""},
++ {"RELAY_LOG_FILE", 0, nullptr, false, ""},
++ {"RELAY_LOG_POS", 0, nullptr, false, ""},
++ {"RELAY_THREAD", 0, nullptr, false, ""},
++ {"RELEASE", 0, nullptr, false, ""},
++ {"RELOAD", 0, nullptr, false, ""},
++ {"RENAME", 0, nullptr, false, ""},
++ {"REPAIR", 0, nullptr, false, ""},
++ {"REPEATABLE", 0, nullptr, false, ""},
++ {"REPLACE", 0, nullptr, false, ""},
++ {"REPLICATION", 0, nullptr, false, ""},
++ {"REPEAT", 0, nullptr, false, ""},
++ {"REQUIRE", 0, nullptr, false, ""},
++ {"RESET", 0, nullptr, false, ""},
++ {"RESTORE", 0, nullptr, false, ""},
++ {"RESTRICT", 0, nullptr, false, ""},
++ {"RESUME", 0, nullptr, false, ""},
++ {"RETURN", 0, nullptr, false, ""},
++ {"RETURNS", 0, nullptr, false, ""},
++ {"REVOKE", 0, nullptr, false, ""},
++ {"RIGHT", 0, nullptr, false, ""},
++ {"RLIKE", 0, nullptr, false, ""},
++ {"ROLLBACK", 0, nullptr, false, ""},
++ {"ROLLUP", 0, nullptr, false, ""},
++ {"ROUTINE", 0, nullptr, false, ""},
++ {"ROW", 0, nullptr, false, ""},
++ {"ROWS", 0, nullptr, false, ""},
++ {"ROW_FORMAT", 0, nullptr, false, ""},
++ {"RTREE", 0, nullptr, false, ""},
++ {"SAVEPOINT", 0, nullptr, false, ""},
++ {"SCHEMA", 0, nullptr, false, ""},
++ {"SCHEMAS", 0, nullptr, false, ""},
++ {"SECOND", 0, nullptr, false, ""},
++ {"SECOND_MICROSECOND", 0, nullptr, false, ""},
++ {"SECURITY", 0, nullptr, false, ""},
++ {"SELECT", 0, nullptr, false, ""},
++ {"SENSITIVE", 0, nullptr, false, ""},
++ {"SEPARATOR", 0, nullptr, false, ""},
++ {"SERIAL", 0, nullptr, false, ""},
++ {"SERIALIZABLE", 0, nullptr, false, ""},
++ {"SESSION", 0, nullptr, false, ""},
++ {"SET", 0, nullptr, false, ""},
++ {"SHARE", 0, nullptr, false, ""},
++ {"SHOW", 0, nullptr, false, ""},
++ {"SHUTDOWN", 0, nullptr, false, ""},
++ {"SIGNED", 0, nullptr, false, ""},
++ {"SIMPLE", 0, nullptr, false, ""},
++ {"SLAVE", 0, nullptr, false, ""},
++ {"SNAPSHOT", 0, nullptr, false, ""},
++ {"SMALLINT", 0, nullptr, false, ""},
++ {"SOME", 0, nullptr, false, ""},
++ {"SONAME", 0, nullptr, false, ""},
++ {"SOUNDS", 0, nullptr, false, ""},
++ {"SPATIAL", 0, nullptr, false, ""},
++ {"SPECIFIC", 0, nullptr, false, ""},
++ {"SQL", 0, nullptr, false, ""},
++ {"SQLEXCEPTION", 0, nullptr, false, ""},
++ {"SQLSTATE", 0, nullptr, false, ""},
++ {"SQLWARNING", 0, nullptr, false, ""},
++ {"SQL_BIG_RESULT", 0, nullptr, false, ""},
++ {"SQL_BUFFER_RESULT", 0, nullptr, false, ""},
++ {"SQL_CALC_FOUND_ROWS", 0, nullptr, false, ""},
++ {"SQL_NO_CACHE", 0, nullptr, false, ""},
++ {"SQL_SMALL_RESULT", 0, nullptr, false, ""},
++ {"SQL_THREAD", 0, nullptr, false, ""},
++ {"SQL_TSI_SECOND", 0, nullptr, false, ""},
++ {"SQL_TSI_MINUTE", 0, nullptr, false, ""},
++ {"SQL_TSI_HOUR", 0, nullptr, false, ""},
++ {"SQL_TSI_DAY", 0, nullptr, false, ""},
++ {"SQL_TSI_WEEK", 0, nullptr, false, ""},
++ {"SQL_TSI_MONTH", 0, nullptr, false, ""},
++ {"SQL_TSI_QUARTER", 0, nullptr, false, ""},
++ {"SQL_TSI_YEAR", 0, nullptr, false, ""},
++ {"SSL", 0, nullptr, false, ""},
++ {"START", 0, nullptr, false, ""},
++ {"STARTING", 0, nullptr, false, ""},
++ {"STATUS", 0, nullptr, false, ""},
++ {"STOP", 0, nullptr, false, ""},
++ {"STORAGE", 0, nullptr, false, ""},
++ {"STRAIGHT_JOIN", 0, nullptr, false, ""},
++ {"STRING", 0, nullptr, false, ""},
++ {"STRIPED", 0, nullptr, false, ""},
++ {"SUBJECT", 0, nullptr, false, ""},
++ {"SUPER", 0, nullptr, false, ""},
++ {"SUSPEND", 0, nullptr, false, ""},
++ {"TABLE", 0, nullptr, false, ""},
++ {"TABLES", 0, nullptr, false, ""},
++ {"TABLESPACE", 0, nullptr, false, ""},
++ {"TEMPORARY", 0, nullptr, false, ""},
++ {"TEMPTABLE", 0, nullptr, false, ""},
++ {"TERMINATED", 0, nullptr, false, ""},
++ {"TEXT", 0, nullptr, false, ""},
++ {"THEN", 0, nullptr, false, ""},
++ {"TIME", 0, nullptr, false, ""},
++ {"TIMESTAMP", 0, nullptr, false, ""},
++ {"TIMESTAMPADD", 0, nullptr, false, ""},
++ {"TIMESTAMPDIFF", 0, nullptr, false, ""},
++ {"TINYBLOB", 0, nullptr, false, ""},
++ {"TINYINT", 0, nullptr, false, ""},
++ {"TINYTEXT", 0, nullptr, false, ""},
++ {"TO", 0, nullptr, false, ""},
++ {"TRAILING", 0, nullptr, false, ""},
++ {"TRANSACTION", 0, nullptr, false, ""},
++ {"TRIGGER", 0, nullptr, false, ""},
++ {"TRIGGERS", 0, nullptr, false, ""},
++ {"TRUE", 0, nullptr, false, ""},
++ {"TRUNCATE", 0, nullptr, false, ""},
++ {"TYPE", 0, nullptr, false, ""},
++ {"TYPES", 0, nullptr, false, ""},
++ {"UNCOMMITTED", 0, nullptr, false, ""},
++ {"UNDEFINED", 0, nullptr, false, ""},
++ {"UNDO", 0, nullptr, false, ""},
++ {"UNICODE", 0, nullptr, false, ""},
++ {"UNION", 0, nullptr, false, ""},
++ {"UNIQUE", 0, nullptr, false, ""},
++ {"UNKNOWN", 0, nullptr, false, ""},
++ {"UNLOCK", 0, nullptr, false, ""},
++ {"UNSIGNED", 0, nullptr, false, ""},
++ {"UNTIL", 0, nullptr, false, ""},
++ {"UPDATE", 0, nullptr, false, ""},
++ {"UPGRADE", 0, nullptr, false, ""},
++ {"USAGE", 0, nullptr, false, ""},
++ {"USE", 0, nullptr, false, ""},
++ {"USER", 0, nullptr, false, ""},
++ {"USER_RESOURCES", 0, nullptr, false, ""},
++ {"USE_FRM", 0, nullptr, false, ""},
++ {"USING", 0, nullptr, false, ""},
++ {"UTC_DATE", 0, nullptr, false, ""},
++ {"UTC_TIME", 0, nullptr, false, ""},
++ {"UTC_TIMESTAMP", 0, nullptr, false, ""},
++ {"VALUE", 0, nullptr, false, ""},
++ {"VALUES", 0, nullptr, false, ""},
++ {"VARBINARY", 0, nullptr, false, ""},
++ {"VARCHAR", 0, nullptr, false, ""},
++ {"VARCHARACTER", 0, nullptr, false, ""},
++ {"VARIABLES", 0, nullptr, false, ""},
++ {"VARYING", 0, nullptr, false, ""},
++ {"WARNINGS", 0, nullptr, false, ""},
++ {"WEEK", 0, nullptr, false, ""},
++ {"WHEN", 0, nullptr, false, ""},
++ {"WHERE", 0, nullptr, false, ""},
++ {"WHILE", 0, nullptr, false, ""},
++ {"VIEW", 0, nullptr, false, ""},
++ {"WITH", 0, nullptr, false, ""},
++ {"WORK", 0, nullptr, false, ""},
++ {"WRITE", 0, nullptr, false, ""},
++ {"X509", 0, nullptr, false, ""},
++ {"XOR", 0, nullptr, false, ""},
++ {"XA", 0, nullptr, false, ""},
++ {"YEAR", 0, nullptr, false, ""},
++ {"YEAR_MONTH", 0, nullptr, false, ""},
++ {"ZEROFILL", 0, nullptr, false, ""},
++ {"ABS", 0, nullptr, false, ""},
++ {"ACOS", 0, nullptr, false, ""},
++ {"ADDDATE", 0, nullptr, false, ""},
++ {"ADDTIME", 0, nullptr, false, ""},
++ {"AES_ENCRYPT", 0, nullptr, false, ""},
++ {"AES_DECRYPT", 0, nullptr, false, ""},
++ {"AREA", 0, nullptr, false, ""},
++ {"ASIN", 0, nullptr, false, ""},
++ {"ASBINARY", 0, nullptr, false, ""},
++ {"ASTEXT", 0, nullptr, false, ""},
++ {"ASWKB", 0, nullptr, false, ""},
++ {"ASWKT", 0, nullptr, false, ""},
++ {"ATAN", 0, nullptr, false, ""},
++ {"ATAN2", 0, nullptr, false, ""},
++ {"BENCHMARK", 0, nullptr, false, ""},
++ {"BIN", 0, nullptr, false, ""},
++ {"BIT_COUNT", 0, nullptr, false, ""},
++ {"BIT_OR", 0, nullptr, false, ""},
++ {"BIT_AND", 0, nullptr, false, ""},
++ {"BIT_XOR", 0, nullptr, false, ""},
++ {"CAST", 0, nullptr, false, ""},
++ {"CEIL", 0, nullptr, false, ""},
++ {"CEILING", 0, nullptr, false, ""},
++ {"BIT_LENGTH", 0, nullptr, false, ""},
++ {"CENTROID", 0, nullptr, false, ""},
++ {"CHAR_LENGTH", 0, nullptr, false, ""},
++ {"CHARACTER_LENGTH", 0, nullptr, false, ""},
++ {"COALESCE", 0, nullptr, false, ""},
++ {"COERCIBILITY", 0, nullptr, false, ""},
++ {"COMPRESS", 0, nullptr, false, ""},
++ {"CONCAT", 0, nullptr, false, ""},
++ {"CONCAT_WS", 0, nullptr, false, ""},
++ {"CONNECTION_ID", 0, nullptr, false, ""},
++ {"CONV", 0, nullptr, false, ""},
++ {"CONVERT_TZ", 0, nullptr, false, ""},
++ {"COUNT", 0, nullptr, false, ""},
++ {"COS", 0, nullptr, false, ""},
++ {"COT", 0, nullptr, false, ""},
++ {"CRC32", 0, nullptr, false, ""},
++ {"CROSSES", 0, nullptr, false, ""},
++ {"CURDATE", 0, nullptr, false, ""},
++ {"CURTIME", 0, nullptr, false, ""},
++ {"DATE_ADD", 0, nullptr, false, ""},
++ {"DATEDIFF", 0, nullptr, false, ""},
++ {"DATE_FORMAT", 0, nullptr, false, ""},
++ {"DATE_SUB", 0, nullptr, false, ""},
++ {"DAYNAME", 0, nullptr, false, ""},
++ {"DAYOFMONTH", 0, nullptr, false, ""},
++ {"DAYOFWEEK", 0, nullptr, false, ""},
++ {"DAYOFYEAR", 0, nullptr, false, ""},
++ {"DEGREES", 0, nullptr, false, ""},
++ {"DIMENSION", 0, nullptr, false, ""},
++ {"DISJOINT", 0, nullptr, false, ""},
++ {"ELT", 0, nullptr, false, ""},
++ {"ENDPOINT", 0, nullptr, false, ""},
++ {"ENVELOPE", 0, nullptr, false, ""},
++ {"EQUALS", 0, nullptr, false, ""},
++ {"EXTERIORRING", 0, nullptr, false, ""},
++ {"EXTRACT", 0, nullptr, false, ""},
++ {"EXP", 0, nullptr, false, ""},
++ {"EXPORT_SET", 0, nullptr, false, ""},
++ {"FIELD", 0, nullptr, false, ""},
++ {"FIND_IN_SET", 0, nullptr, false, ""},
++ {"FLOOR", 0, nullptr, false, ""},
++ {"FORMAT", 0, nullptr, false, ""},
++ {"FOUND_ROWS", 0, nullptr, false, ""},
++ {"FROM_DAYS", 0, nullptr, false, ""},
++ {"FROM_UNIXTIME", 0, nullptr, false, ""},
++ {"GET_LOCK", 0, nullptr, false, ""},
++ {"GEOMETRYN", 0, nullptr, false, ""},
++ {"GEOMETRYTYPE", 0, nullptr, false, ""},
++ {"GEOMCOLLFROMTEXT", 0, nullptr, false, ""},
++ {"GEOMCOLLFROMWKB", 0, nullptr, false, ""},
++ {"GEOMETRYCOLLECTIONFROMTEXT", 0, nullptr, false, ""},
++ {"GEOMETRYCOLLECTIONFROMWKB", 0, nullptr, false, ""},
++ {"GEOMETRYFROMTEXT", 0, nullptr, false, ""},
++ {"GEOMETRYFROMWKB", 0, nullptr, false, ""},
++ {"GEOMFROMTEXT", 0, nullptr, false, ""},
++ {"GEOMFROMWKB", 0, nullptr, false, ""},
++ {"GLENGTH", 0, nullptr, false, ""},
++ {"GREATEST", 0, nullptr, false, ""},
++ {"GROUP_CONCAT", 0, nullptr, false, ""},
++ {"GROUP_UNIQUE_USERS", 0, nullptr, false, ""},
++ {"HEX", 0, nullptr, false, ""},
++ {"IFNULL", 0, nullptr, false, ""},
++ {"INET_ATON", 0, nullptr, false, ""},
++ {"INET_NTOA", 0, nullptr, false, ""},
++ {"INSTR", 0, nullptr, false, ""},
++ {"INTERIORRINGN", 0, nullptr, false, ""},
++ {"INTERSECTS", 0, nullptr, false, ""},
++ {"ISCLOSED", 0, nullptr, false, ""},
++ {"ISEMPTY", 0, nullptr, false, ""},
++ {"ISNULL", 0, nullptr, false, ""},
++ {"IS_FREE_LOCK", 0, nullptr, false, ""},
++ {"IS_USED_LOCK", 0, nullptr, false, ""},
++ {"JSON_ARRAY_APPEND", 0, nullptr, false, ""},
++ {"JSON_ARRAY", 0, nullptr, false, ""},
++ {"JSON_CONTAINS", 0, nullptr, false, ""},
++ {"JSON_DEPTH", 0, nullptr, false, ""},
++ {"JSON_EXTRACT", 0, nullptr, false, ""},
++ {"JSON_INSERT", 0, nullptr, false, ""},
++ {"JSON_KEYS", 0, nullptr, false, ""},
++ {"JSON_LENGTH", 0, nullptr, false, ""},
++ {"JSON_MERGE", 0, nullptr, false, ""},
++ {"JSON_QUOTE", 0, nullptr, false, ""},
++ {"JSON_REPLACE", 0, nullptr, false, ""},
++ {"JSON_ROWOBJECT", 0, nullptr, false, ""},
++ {"JSON_SEARCH", 0, nullptr, false, ""},
++ {"JSON_SET", 0, nullptr, false, ""},
++ {"JSON_TYPE", 0, nullptr, false, ""},
++ {"JSON_UNQUOTE", 0, nullptr, false, ""},
++ {"JSON_VALID", 0, nullptr, false, ""},
++ {"JSON_CONTAINS_PATH", 0, nullptr, false, ""},
++ {"LAST_INSERT_ID", 0, nullptr, false, ""},
++ {"ISSIMPLE", 0, nullptr, false, ""},
++ {"LAST_DAY", 0, nullptr, false, ""},
++ {"LCASE", 0, nullptr, false, ""},
++ {"LEAST", 0, nullptr, false, ""},
++ {"LENGTH", 0, nullptr, false, ""},
++ {"LN", 0, nullptr, false, ""},
++ {"LINEFROMTEXT", 0, nullptr, false, ""},
++ {"LINEFROMWKB", 0, nullptr, false, ""},
++ {"LINESTRINGFROMTEXT", 0, nullptr, false, ""},
++ {"LINESTRINGFROMWKB", 0, nullptr, false, ""},
++ {"LOAD_FILE", 0, nullptr, false, ""},
++ {"LOCATE", 0, nullptr, false, ""},
++ {"LOG", 0, nullptr, false, ""},
++ {"LOG2", 0, nullptr, false, ""},
++ {"LOG10", 0, nullptr, false, ""},
++ {"LOWER", 0, nullptr, false, ""},
++ {"LPAD", 0, nullptr, false, ""},
++ {"LTRIM", 0, nullptr, false, ""},
++ {"MAKE_SET", 0, nullptr, false, ""},
++ {"MAKEDATE", 0, nullptr, false, ""},
++ {"MAKETIME", 0, nullptr, false, ""},
++ {"SOURCE_POS_WAIT", 0, nullptr, false, ""},
++ {"MAX", 0, nullptr, false, ""},
++ {"MBRCONTAINS", 0, nullptr, false, ""},
++ {"MBRDISJOINT", 0, nullptr, false, ""},
++ {"MBREQUAL", 0, nullptr, false, ""},
++ {"MBRINTERSECTS", 0, nullptr, false, ""},
++ {"MBROVERLAPS", 0, nullptr, false, ""},
++ {"MBRTOUCHES", 0, nullptr, false, ""},
++ {"MBRWITHIN", 0, nullptr, false, ""},
++ {"MD5", 0, nullptr, false, ""},
++ {"MID", 0, nullptr, false, ""},
++ {"MIN", 0, nullptr, false, ""},
++ {"MLINEFROMTEXT", 0, nullptr, false, ""},
++ {"MLINEFROMWKB", 0, nullptr, false, ""},
++ {"MPOINTFROMTEXT", 0, nullptr, false, ""},
++ {"MPOINTFROMWKB", 0, nullptr, false, ""},
++ {"MPOLYFROMTEXT", 0, nullptr, false, ""},
++ {"MPOLYFROMWKB", 0, nullptr, false, ""},
++ {"MONTHNAME", 0, nullptr, false, ""},
++ {"MULTILINESTRINGFROMTEXT", 0, nullptr, false, ""},
++ {"MULTILINESTRINGFROMWKB", 0, nullptr, false, ""},
++ {"MULTIPOINTFROMTEXT", 0, nullptr, false, ""},
++ {"MULTIPOINTFROMWKB", 0, nullptr, false, ""},
++ {"MULTIPOLYGONFROMTEXT", 0, nullptr, false, ""},
++ {"MULTIPOLYGONFROMWKB", 0, nullptr, false, ""},
++ {"NAME_CONST", 0, nullptr, false, ""},
++ {"NOW", 0, nullptr, false, ""},
++ {"NULLIF", 0, nullptr, false, ""},
++ {"NUMGEOMETRIES", 0, nullptr, false, ""},
++ {"NUMINTERIORRINGS", 0, nullptr, false, ""},
++ {"NUMPOINTS", 0, nullptr, false, ""},
++ {"OCTET_LENGTH", 0, nullptr, false, ""},
++ {"OCT", 0, nullptr, false, ""},
++ {"ORD", 0, nullptr, false, ""},
++ {"OVERLAPS", 0, nullptr, false, ""},
++ {"PERIOD_ADD", 0, nullptr, false, ""},
++ {"PERIOD_DIFF", 0, nullptr, false, ""},
++ {"PI", 0, nullptr, false, ""},
++ {"POINTFROMTEXT", 0, nullptr, false, ""},
++ {"POINTFROMWKB", 0, nullptr, false, ""},
++ {"POINTN", 0, nullptr, false, ""},
++ {"POLYFROMTEXT", 0, nullptr, false, ""},
++ {"POLYFROMWKB", 0, nullptr, false, ""},
++ {"POLYGONFROMTEXT", 0, nullptr, false, ""},
++ {"POLYGONFROMWKB", 0, nullptr, false, ""},
++ {"POSITION", 0, nullptr, false, ""},
++ {"POW", 0, nullptr, false, ""},
++ {"POWER", 0, nullptr, false, ""},
++ {"QUOTE", 0, nullptr, false, ""},
++ {"RADIANS", 0, nullptr, false, ""},
++ {"RAND", 0, nullptr, false, ""},
++ {"RELEASE_LOCK", 0, nullptr, false, ""},
++ {"REVERSE", 0, nullptr, false, ""},
++ {"ROUND", 0, nullptr, false, ""},
++ {"ROW_COUNT", 0, nullptr, false, ""},
++ {"RPAD", 0, nullptr, false, ""},
++ {"RTRIM", 0, nullptr, false, ""},
++ {"SEC_TO_TIME", 0, nullptr, false, ""},
++ {"SESSION_USER", 0, nullptr, false, ""},
++ {"SUBDATE", 0, nullptr, false, ""},
++ {"SIGN", 0, nullptr, false, ""},
++ {"SIN", 0, nullptr, false, ""},
++ {"SHA", 0, nullptr, false, ""},
++ {"SHA1", 0, nullptr, false, ""},
++ {"SLEEP", 0, nullptr, false, ""},
++ {"SOUNDEX", 0, nullptr, false, ""},
++ {"SPACE", 0, nullptr, false, ""},
++ {"SQRT", 0, nullptr, false, ""},
++ {"SRID", 0, nullptr, false, ""},
++ {"STARTPOINT", 0, nullptr, false, ""},
++ {"STD", 0, nullptr, false, ""},
++ {"STDDEV", 0, nullptr, false, ""},
++ {"STDDEV_POP", 0, nullptr, false, ""},
++ {"STDDEV_SAMP", 0, nullptr, false, ""},
++ {"STR_TO_DATE", 0, nullptr, false, ""},
++ {"STRCMP", 0, nullptr, false, ""},
++ {"SUBSTR", 0, nullptr, false, ""},
++ {"SUBSTRING", 0, nullptr, false, ""},
++ {"SUBSTRING_INDEX", 0, nullptr, false, ""},
++ {"SUBTIME", 0, nullptr, false, ""},
++ {"SUM", 0, nullptr, false, ""},
++ {"SYSDATE", 0, nullptr, false, ""},
++ {"SYSTEM_USER", 0, nullptr, false, ""},
++ {"TAN", 0, nullptr, false, ""},
++ {"TIME_FORMAT", 0, nullptr, false, ""},
++ {"TIME_TO_SEC", 0, nullptr, false, ""},
++ {"TIMEDIFF", 0, nullptr, false, ""},
++ {"TO_DAYS", 0, nullptr, false, ""},
++ {"TOUCHES", 0, nullptr, false, ""},
++ {"TRIM", 0, nullptr, false, ""},
++ {"UCASE", 0, nullptr, false, ""},
++ {"UNCOMPRESS", 0, nullptr, false, ""},
++ {"UNCOMPRESSED_LENGTH", 0, nullptr, false, ""},
++ {"UNHEX", 0, nullptr, false, ""},
++ {"UNIQUE_USERS", 0, nullptr, false, ""},
++ {"UNIX_TIMESTAMP", 0, nullptr, false, ""},
++ {"UPPER", 0, nullptr, false, ""},
++ {"UUID", 0, nullptr, false, ""},
++ {"VARIANCE", 0, nullptr, false, ""},
++ {"VAR_POP", 0, nullptr, false, ""},
++ {"VAR_SAMP", 0, nullptr, false, ""},
++ {"VERSION", 0, nullptr, false, ""},
++ {"WEEKDAY", 0, nullptr, false, ""},
++ {"WEEKOFYEAR", 0, nullptr, false, ""},
++ {"WITHIN", 0, nullptr, false, ""},
++ {"X", 0, nullptr, false, ""},
++ {"Y", 0, nullptr, false, ""},
++ {"YEARWEEK", 0, nullptr, false, ""},
++ /* end sentinel */
++ {(char *)nullptr, 0, nullptr, false, ""}};
++
++static const char *load_default_groups[] = {"mysql", "client", nullptr};
++
++#ifdef HAVE_READLINE
++/*
++ HIST_ENTRY is defined for libedit, but not for the real readline
++ Need to redefine it for real readline to find it
++*/
++#if !defined(HAVE_HIST_ENTRY)
++typedef struct _hist_entry {
++ const char *line;
++ const char *data;
++} HIST_ENTRY;
++#endif
++
++extern "C" int add_history(const char *command); /* From readline directory */
++extern "C" int read_history(const char *command);
++extern "C" int write_history(const char *command);
++extern "C" HIST_ENTRY *history_get(int num);
++extern "C" int history_length;
++static int not_in_history(const char *line);
++static void initialize_readline(char *name);
++#endif /* HAVE_READLINE */
++
++static COMMANDS *find_command(char *name);
++static COMMANDS *find_command(char cmd_name);
++static bool add_line(String &buffer, char *line, size_t line_length,
++ char *in_string, bool *ml_comment, bool truncated);
++static void remove_cntrl(String *buffer);
++static void print_table_data(MYSQL_RES *result);
++static void print_table_data_html(MYSQL_RES *result);
++static void print_table_data_xml(MYSQL_RES *result);
++static void print_tab_data(MYSQL_RES *result);
++static void print_table_data_vertically(MYSQL_RES *result);
++static void print_warnings(void);
++static ulong start_timer(void);
++static void end_timer(ulong start_time, char *buff);
++static void mysql_end_timer(ulong start_time, char *buff);
++static void nice_time(double sec, char *buff, bool part_second);
++static void kill_query(const char *reason);
++extern "C" void mysql_end(int sig);
++extern "C" void handle_ctrlc_signal(int);
++extern "C" void handle_quit_signal(int sig);
++#if defined(HAVE_TERMIOS_H) && defined(GWINSZ_IN_SYS_IOCTL)
++static void window_resize(int);
++#endif
++
++const char DELIMITER_NAME[] = "delimiter";
++const uint DELIMITER_NAME_LEN = sizeof(DELIMITER_NAME) - 1;
++inline bool is_delimiter_command(char *name, ulong len) {
++ /*
++ Delimiter command has a parameter, so the length of the whole command
++ is larger than DELIMITER_NAME_LEN. We don't care the parameter, so
++ only name(first DELIMITER_NAME_LEN bytes) is checked.
++ */
++ return (len >= DELIMITER_NAME_LEN &&
++ !my_strnncoll(
++ charset_info, pointer_cast<uchar *>(name), DELIMITER_NAME_LEN,
++ pointer_cast<const uchar *>(DELIMITER_NAME), DELIMITER_NAME_LEN));
++}
++
++/**
++ Get the index of a command in the commands array.
++
++ @param cmd_char Short form command.
++
++ @return int
++ The index of the command is returned if it is found, else -1 is returned.
++*/
++inline int get_command_index(char cmd_char) {
++ /*
++ All client-specific commands are in the first part of commands array
++ and have a function to implement it.
++ */
++ for (uint i = 0; commands[i].func != nullptr; i++)
++ if (commands[i].cmd_char == cmd_char) return i;
++ return -1;
++}
++
++static int delimiter_index = -1;
++static int charset_index = -1;
++static bool real_binary_mode = false;
++
++#ifdef _WIN32
++BOOL windows_ctrl_handler(DWORD fdwCtrlType) {
++ switch (fdwCtrlType) {
++ case CTRL_C_EVENT:
++ case CTRL_BREAK_EVENT:
++ handle_ctrlc_signal(SIGINT);
++ /* Indicate that signal has beed handled. */
++ return true;
++ case CTRL_CLOSE_EVENT:
++ case CTRL_LOGOFF_EVENT:
++ case CTRL_SHUTDOWN_EVENT:
++ handle_quit_signal(SIGINT + 1);
++ }
++ /* Pass signal to the next control handler function. */
++ return false;
++}
++#endif
++
++int main(int argc, char *argv[]) {
++ char buff[80];
++
++ MY_INIT(argv[0]);
++ DBUG_TRACE;
++ DBUG_PROCESS(argv[0]);
++
++ charset_index = get_command_index('C');
++ delimiter_index = get_command_index('d');
++ delimiter_str = delimiter;
++ default_prompt = my_strdup(
++ PSI_NOT_INSTRUMENTED,
++ getenv("MYSQL_PS1") ? getenv("MYSQL_PS1") : "mysql> ", MYF(MY_WME));
++ current_prompt = my_strdup(PSI_NOT_INSTRUMENTED, default_prompt, MYF(MY_WME));
++ prompt_counter = 0;
++
++ outfile[0] = 0; // no (default) outfile
++ my_stpcpy(pager, "stdout"); // the default, if --pager wasn't given
++ {
++ char *tmp = getenv("PAGER");
++ if (tmp && strlen(tmp)) {
++ default_pager_set = true;
++ my_stpcpy(default_pager, tmp);
++ }
++ }
++ if (!isatty(0) || !isatty(1)) {
++ status.batch = true;
++ opt_silent = 1;
++ ignore_errors = false;
++ } else
++ status.add_to_history = true;
++ status.exit_status = 1;
++
++ {
++ /*
++ The file descriptor-layer may be out-of-sync with the file-number layer,
++ so we make sure that "stdout" is really open. If its file is closed then
++ explicitly close the FD layer.
++ */
++ int stdout_fileno_copy;
++ stdout_fileno_copy = dup(fileno(stdout)); /* Okay if fileno fails. */
++ if (stdout_fileno_copy == -1) {
++ fclose(stdout);
++#ifdef LINUX_ALPINE
++ // On Alpine linux we need to open a dummy file, so that the first
++ // call to socket() does not get file number 1
++ // If socket gets file number 1, then everything printed to stdout
++ // will be sent back to the server over the socket connection.
++ fopen("/dev/null", "r");
++#endif
++ } else
++ close(stdout_fileno_copy); /* Clean up dup(). */
++ }
++
++#ifdef _WIN32
++ /* Convert command line parameters from UTF16LE to UTF8MB4. */
++ my_win_translate_command_line_args(&my_charset_utf8mb4_bin, &argc, &argv);
++#endif
++
++ my_getopt_use_args_separator = true;
++ if (load_defaults("my", load_default_groups, &argc, &argv, &argv_alloc)) {
++ my_end(0);
++ return EXIT_FAILURE;
++ }
++ my_getopt_use_args_separator = false;
++
++ get_current_os_user();
++ get_current_os_sudouser();
++ if (get_options(argc, (char **)argv)) {
++ my_end(0);
++ return EXIT_FAILURE;
++ }
++ if (status.batch && !status.line_buff &&
++ !(status.line_buff = batch_readline_init(MAX_BATCH_BUFFER_SIZE, stdin))) {
++ put_info(
++ "Can't initialize batch_readline - may be the input source is "
++ "a directory or a block device.",
++ INFO_ERROR, 0);
++ my_end(0);
++ return EXIT_FAILURE;
++ }
++ if (!opt_binary_as_hex_set_explicitly && isatty(0) && isatty(1))
++ opt_binhex = true;
++ if (mysql_server_init(0, nullptr, nullptr)) {
++ put_error(nullptr);
++ my_end(0);
++ return EXIT_FAILURE;
++ }
++ glob_buffer.mem_realloc((status.batch) ? batch_io_size : 512);
++ completion_hash_init(&ht, 128);
++ memset(&mysql, 0, sizeof(mysql));
++ global_attrs = new client_query_attributes();
++ if (sql_connect(current_host, current_db, current_user, opt_silent)) {
++ quick = true; // Avoid history
++ status.exit_status = 1;
++ mysql_end(-1);
++ }
++ if (!status.batch) ignore_errors = true; // Don't abort monitor
++
++#ifndef _WIN32
++ signal(SIGINT, handle_ctrlc_signal); // Catch SIGINT to clean up
++ signal(SIGQUIT, mysql_end); // Catch SIGQUIT to clean up
++ signal(SIGHUP, handle_quit_signal); // Catch SIGHUP to clean up
++#else
++ SetConsoleCtrlHandler((PHANDLER_ROUTINE)windows_ctrl_handler, true);
++#endif
++
++#if defined(HAVE_TERMIOS_H) && defined(GWINSZ_IN_SYS_IOCTL)
++ /* Readline will call this if it installs a handler */
++ signal(SIGWINCH, window_resize);
++ /* call the SIGWINCH handler to get the default term width */
++ window_resize(0);
++#endif
++
++ put_info("Welcome to the MySQL monitor. Commands end with ; or \\g.",
++ INFO_INFO);
++ snprintf(glob_buffer.ptr(), glob_buffer.alloced_length(),
++ "Your MySQL connection id is %lu\nServer version: %s\n",
++ mysql_thread_id(&mysql), server_version_string(&mysql));
++ put_info(glob_buffer.ptr(), INFO_INFO);
++
++ put_info(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000"), INFO_INFO);
++
++ if (!status.batch) {
++ // history ignore patterns are initialized to default values
++ ignore_matcher.add_patterns(HI_DEFAULTS);
++
++ /*
++ Additional patterns may be supplied using either --histignore option or
++ MYSQL_HISTIGNORE environment variable. If supplied, they'll get appended
++ to the default patterns. In case both are specified, pattern(s) supplied
++ using --histignore option will be used.
++ */
++ if (opt_histignore)
++ ignore_matcher.add_patterns(opt_histignore);
++ else if (getenv("MYSQL_HISTIGNORE"))
++ ignore_matcher.add_patterns(getenv("MYSQL_HISTIGNORE"));
++
++#ifdef HAVE_READLINE
++ if (!quick) {
++ initialize_readline(const_cast<char *>(my_progname));
++
++ /* read-history from file, default ~/.mysql_history*/
++ if (getenv("MYSQL_HISTFILE"))
++ histfile = my_strdup(PSI_NOT_INSTRUMENTED, getenv("MYSQL_HISTFILE"),
++ MYF(MY_WME));
++ else if (getenv("HOME")) {
++ histfile = (char *)my_malloc(
++ PSI_NOT_INSTRUMENTED,
++ (uint)strlen(getenv("HOME")) + (uint)strlen("/.mysql_history") + 2,
++ MYF(MY_WME));
++ if (histfile) sprintf(histfile, "%s/.mysql_history", getenv("HOME"));
++ char link_name[FN_REFLEN];
++ if (my_readlink(link_name, histfile, 0) == 0 &&
++ strncmp(link_name, "/dev/null", 10) == 0) {
++ /* The .mysql_history file is a symlink to /dev/null, don't use it */
++ my_free(histfile);
++ histfile = nullptr;
++ }
++ }
++
++ /* We used to suggest setting MYSQL_HISTFILE=/dev/null. */
++ if (histfile && strncmp(histfile, "/dev/null", 10) == 0)
++ histfile = nullptr;
++
++ if (histfile && histfile[0]) {
++ if (verbose) tee_fprintf(stdout, "Reading history-file %s\n", histfile);
++ read_history(histfile);
++ if (!(histfile_tmp =
++ (char *)my_malloc(PSI_NOT_INSTRUMENTED,
++ (uint)strlen(histfile) + 5, MYF(MY_WME)))) {
++ fprintf(stderr, "Couldn't allocate memory for temp histfile!\n");
++ return EXIT_FAILURE;
++ }
++ sprintf(histfile_tmp, "%s.TMP", histfile);
++ }
++ }
++#endif
++ }
++
++ sprintf(
++ buff, "%s",
++ "Type 'help;' or '\\h' for help. Type '\\c' to clear the current input "
++ "statement.\n");
++ put_info(buff, INFO_INFO);
++
++ uint protocol = MYSQL_PROTOCOL_DEFAULT;
++ uint ssl_mode = 0;
++ if (!mysql_get_option(&mysql, MYSQL_OPT_PROTOCOL, &protocol) &&
++ !mysql_get_option(&mysql, MYSQL_OPT_SSL_MODE, &ssl_mode)) {
++ if (protocol == MYSQL_PROTOCOL_SOCKET && ssl_mode >= SSL_MODE_REQUIRED)
++ put_info(
++ "You are enforcing ssl connection via unix socket. Please consider\n"
++ "switching ssl off as it does not make connection via unix socket\n"
++ "any more secure.",
++ INFO_INFO);
++ }
++
++ status.exit_status = read_and_execute(!status.batch);
++ if (opt_outfile) end_tee();
++ mysql_end(0);
++ return 0; // Keep compiler happy
++}
++
++void mysql_end(int sig) {
++#ifndef _WIN32
++ /*
++ Ignoring SIGQUIT, SIGINT and SIGHUP signals when cleanup process starts.
++ This will help in resolving the double free issues, which occurs in case
++ the signal handler function is started in between the clean up function.
++ */
++ signal(SIGQUIT, SIG_IGN);
++ signal(SIGINT, SIG_IGN);
++ signal(SIGHUP, SIG_IGN);
++#endif
++
++ if (ssl_session_data) mysql_free_ssl_session_data(&mysql, ssl_session_data);
++ mysql_close(&mysql);
++#ifdef HAVE_READLINE
++ if (!status.batch && !quick && histfile && histfile[0]) {
++ /* write-history */
++ if (verbose) tee_fprintf(stdout, "Writing history-file %s\n", histfile);
++ if (!write_history(histfile_tmp))
++ my_rename(histfile_tmp, histfile, MYF(MY_WME));
++ }
++ batch_readline_end(status.line_buff);
++ completion_hash_free(&ht);
++ hash_mem_root.Clear();
++
++ my_free(histfile);
++ my_free(histfile_tmp);
++#endif
++ my_free(opt_histignore);
++
++ my_free(current_os_user);
++ my_free(current_os_sudouser);
++
++ if (opt_syslog) my_closelog();
++
++ if (sig >= 0) put_info(sig ? "Aborted" : "Bye", INFO_RESULT);
++ glob_buffer.mem_free();
++ old_buffer.mem_free();
++ processed_prompt.mem_free();
++ my_free(server_version);
++ free_passwords();
++ my_free(opt_mysql_unix_port);
++ my_free(current_db);
++ my_free(current_host);
++ my_free(dns_srv_name);
++ my_free(current_user);
++ my_free(full_username);
++ my_free(part_username);
++ my_free(default_prompt);
++#if defined(_WIN32)
++ my_free(shared_memory_base_name);
++#endif
++ my_free(current_prompt);
++ mysql_server_end();
++ my_end(my_end_arg);
++ if (global_attrs != nullptr) {
++ delete global_attrs;
++ global_attrs = nullptr;
++ }
++ exit(status.exit_status);
++}
++
++/**
++ SIGINT signal handler.
++
++ This function handles SIGINT (Ctrl - C). It sends a 'KILL [QUERY]' command
++ to the server if a query is currently executing. On Windows, 'Ctrl - Break'
++ is treated alike.
++
++ FIXME: POSIX allows only a very limited set of interactions from signal
++ handlers, as the main thread could have nearly any state at the time of the
++ signal and is suspended until the signal handler returns. In particular,
++ only variables of type sig_atomic_t can be set and tested, and most C library
++ functions (including malloc()) are banned. Thus, calling kill_query() here
++ is forbidden and should not be done.
++*/
++
++void handle_ctrlc_signal(int) {
++ sigint_received = true;
++
++ /* Skip rest if --sigint-ignore is used. */
++ if (opt_sigint_ignore) return;
++
++ if (executing_query) kill_query("^C");
++ /* else, do nothing, just terminate the current line (like /c command). */
++ return;
++}
++
++/**
++ Handler to perform a cleanup and quit the program.
++
++ This function would send a 'KILL [QUERY]' command to the server if a
++ query is currently executing and then it invokes mysql_thread_end()/
++ mysql_end() in order to terminate the mysql client process.
++
++ @param sig Signal number
++*/
++
++void handle_quit_signal(int sig [[maybe_unused]]) {
++ const char *reason = "Terminal close";
++
++ if (!executing_query) {
++ tee_fprintf(stdout, "%s -- exit!\n", reason);
++ goto err;
++ }
++
++ kill_query(reason);
++
++err:
++#ifdef _WIN32
++ /*
++ When a signal is raised on Windows, the OS creates a new thread to
++ handle the interrupt. Once that thread completes, the main thread
++ continues running only to find that it's resources have already been
++ free'd when the signal handler called mysql_end().
++ */
++ mysql_thread_end();
++ return;
++#else
++ mysql_end(sig);
++#endif
++}
++
++/* Send 'KILL QUERY' command to the server. */
++static void kill_query(const char *reason) {
++ char kill_buffer[40];
++ MYSQL *kill_mysql = nullptr;
++
++ kill_mysql = mysql_init(kill_mysql);
++ init_connection_options(kill_mysql);
++
++#ifdef HAVE_SETNS
++ if (opt_network_namespace && set_network_namespace(opt_network_namespace)) {
++ goto err;
++ }
++#endif
++
++ MYSQL *ret;
++ if (dns_srv_name)
++ ret = mysql_real_connect_dns_srv(kill_mysql, dns_srv_name, current_user,
++ nullptr, "", 0);
++ else
++ ret = mysql_real_connect(kill_mysql, current_host, current_user, nullptr,
++ "", opt_mysql_port, opt_mysql_unix_port, 0);
++ if (!ret) {
++#ifdef HAVE_SETNS
++ if (opt_network_namespace) (void)restore_original_network_namespace();
++#endif
++ tee_fprintf(stdout,
++ "%s -- Sorry, cannot connect to the server to kill "
++ "query, giving up ...\n",
++ reason);
++ goto err;
++ }
++
++#ifdef HAVE_SETNS
++ if (opt_network_namespace && restore_original_network_namespace()) goto err;
++#endif
++
++ interrupted_query = true;
++
++ /* mysqld < 5 does not understand KILL QUERY, skip to KILL CONNECTION */
++ sprintf(kill_buffer, "KILL %s%lu",
++ (mysql_get_server_version(&mysql) < 50000) ? "" : "QUERY ",
++ mysql_thread_id(&mysql));
++
++ if (verbose)
++ tee_fprintf(stdout, "%s -- sending \"%s\" to server ...\n", reason,
++ kill_buffer);
++ mysql_real_query(kill_mysql, kill_buffer,
++ static_cast<ulong>(strlen(kill_buffer)));
++ tee_fprintf(stdout, "%s -- query aborted\n", reason);
++
++err:
++#ifdef HAVE_SETNS
++ if (opt_network_namespace) (void)release_network_namespace_resources();
++#endif
++ mysql_close(kill_mysql);
++
++ return;
++}
++
++#if defined(HAVE_TERMIOS_H) && defined(GWINSZ_IN_SYS_IOCTL)
++void window_resize(int) {
++ struct winsize window_size;
++
++ if (ioctl(fileno(stdin), TIOCGWINSZ, &window_size) == 0)
++ terminal_width = window_size.ws_col;
++}
++#endif
++
++static bool opt_system_command = true;
++
++static struct my_option my_long_options[] = {
++ {"help", '?', "Display this help and exit.", nullptr, nullptr, nullptr,
++ GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"help", 'I', "Synonym for -?", nullptr, nullptr, nullptr, GET_NO_ARG,
++ NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"auto-rehash", OPT_AUTO_REHASH,
++ "Enable automatic rehashing. One doesn't need to use 'rehash' to get "
++ "table "
++ "and field completion, but startup and reconnecting may take a longer "
++ "time. "
++ "Disable with --disable-auto-rehash.",
++ &opt_rehash, &opt_rehash, nullptr, GET_BOOL, NO_ARG, 1, 0, 0, nullptr, 0,
++ nullptr},
++ {"no-auto-rehash", 'A',
++ "No automatic rehashing. One has to use 'rehash' to get table and field "
++ "completion. This gives a quicker start of mysql and disables rehashing "
++ "on reconnect.",
++ nullptr, nullptr, nullptr, GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"auto-vertical-output", OPT_AUTO_VERTICAL_OUTPUT,
++ "Automatically switch to vertical output mode if the result is wider "
++ "than the terminal width.",
++ &auto_vertical_output, &auto_vertical_output, nullptr, GET_BOOL, NO_ARG, 0,
++ 0, 0, nullptr, 0, nullptr},
++ {"batch", 'B',
++ "Don't use history file. Disable interactive behavior. (Enables "
++ "--silent.)",
++ nullptr, nullptr, nullptr, GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"bind-address", 0, "IP address to bind to.", (uchar **)&opt_bind_addr,
++ (uchar **)&opt_bind_addr, nullptr, GET_STR, REQUIRED_ARG, 0, 0, 0, nullptr,
++ 0, nullptr},
++ {"binary-as-hex", OPT_MYSQL_BINARY_AS_HEX,
++ "Print binary data as hex. Enabled by default for interactive terminals.",
++ &opt_binhex, &opt_binhex, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"character-sets-dir", OPT_CHARSETS_DIR,
++ "Directory for character set files.", &charsets_dir, &charsets_dir,
++ nullptr, GET_STR, REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"column-type-info", OPT_COLUMN_TYPES, "Display column type information.",
++ &column_types_flag, &column_types_flag, nullptr, GET_BOOL, NO_ARG, 0, 0, 0,
++ nullptr, 0, nullptr},
++ {"comments", 'c',
++ "Preserve comments. Send comments to the server."
++ " The default is --skip-comments (discard comments), enable with "
++ "--comments.",
++ &preserve_comments, &preserve_comments, nullptr, GET_BOOL, NO_ARG, 0, 0, 0,
++ nullptr, 0, nullptr},
++ {"compress", 'C', "Use compression in server/client protocol.",
++ &opt_compress, &opt_compress, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr,
++ 0, nullptr},
++#ifdef NDEBUG
++ {"debug", '#', "This is a non-debug version. Catch this and exit.", nullptr,
++ nullptr, nullptr, GET_DISABLED, OPT_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"debug-check", OPT_DEBUG_CHECK,
++ "This is a non-debug version. Catch this and exit.", nullptr, nullptr,
++ nullptr, GET_DISABLED, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"debug-info", 'T', "This is a non-debug version. Catch this and exit.",
++ nullptr, nullptr, nullptr, GET_DISABLED, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++#else
++ {"debug", '#', "Output debug log.", &default_dbug_option,
++ &default_dbug_option, nullptr, GET_STR, OPT_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"debug-check", OPT_DEBUG_CHECK,
++ "Check memory and open file usage at exit.", &debug_check_flag,
++ &debug_check_flag, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"debug-info", 'T', "Print some debug info at exit.", &debug_info_flag,
++ &debug_info_flag, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++#endif
++ {"database", 'D', "Database to use.", ¤t_db, ¤t_db, nullptr,
++ GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"default-character-set", OPT_DEFAULT_CHARSET,
++ "Set the default character set.", &default_charset, &default_charset,
++ nullptr, GET_STR, REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"delimiter", OPT_DELIMITER, "Delimiter to be used.", &delimiter_str,
++ &delimiter_str, nullptr, GET_STR, REQUIRED_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"enable_cleartext_plugin", OPT_ENABLE_CLEARTEXT_PLUGIN,
++ "Enable/disable the clear text authentication plugin.",
++ &opt_enable_cleartext_plugin, &opt_enable_cleartext_plugin, nullptr,
++ GET_BOOL, OPT_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"execute", 'e',
++ "Execute command and quit. (Disables --force and history file.)", nullptr,
++ nullptr, nullptr, GET_STR, REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"vertical", 'E', "Print the output of a query (rows) vertically.",
++ &vertical, &vertical, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"force", 'f', "Continue even if we get an SQL error.", &ignore_errors,
++ &ignore_errors, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"histignore", OPT_HISTIGNORE,
++ "A colon-separated list of patterns to "
++ "keep statements from getting logged into syslog and mysql history.",
++ &opt_histignore, &opt_histignore, nullptr, GET_STR_ALLOC, REQUIRED_ARG, 0,
++ 0, 0, nullptr, 0, nullptr},
++ {"named-commands", 'G',
++ "Enable named commands. Named commands mean this program's internal "
++ "commands; see mysql> help . When enabled, the named commands can be "
++ "used from any line of the query, otherwise only from the first line, "
++ "before an enter. Disable with --disable-named-commands. This option "
++ "is disabled by default.",
++ &named_cmds, &named_cmds, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"ignore-spaces", 'i', "Ignore space after function names.", &ignore_spaces,
++ &ignore_spaces, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"init-command", OPT_INIT_COMMAND,
++ "SQL Command to execute when connecting to MySQL server. Will "
++ "automatically be re-executed when reconnecting.",
++ &opt_init_command, &opt_init_command, nullptr, GET_STR, REQUIRED_ARG, 0, 0,
++ 0, nullptr, 0, nullptr},
++ {"local-infile", OPT_LOCAL_INFILE, "Enable/disable LOAD DATA LOCAL INFILE.",
++ &opt_local_infile, &opt_local_infile, nullptr, GET_BOOL, OPT_ARG, 0, 0, 0,
++ nullptr, 0, nullptr},
++ {"no-beep", 'b', "Turn off beep on error.", &opt_nobeep, &opt_nobeep,
++ nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"host", 'h', "Connect to host.", ¤t_host, ¤t_host, nullptr,
++ GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"dns-srv-name", 0, "Connect to a DNS SRV resource", &dns_srv_name,
++ &dns_srv_name, nullptr, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"html", 'H', "Produce HTML output.", &opt_html, &opt_html, nullptr,
++ GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"xml", 'X', "Produce XML output.", &opt_xml, &opt_xml, nullptr, GET_BOOL,
++ NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"line-numbers", OPT_LINE_NUMBERS, "Write line numbers for errors.",
++ &line_numbers, &line_numbers, nullptr, GET_BOOL, NO_ARG, 1, 0, 0, nullptr,
++ 0, nullptr},
++ {"skip-line-numbers", 'L', "Don't write line number for errors.", nullptr,
++ nullptr, nullptr, GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"unbuffered", 'n', "Flush buffer after each query.", &unbuffered,
++ &unbuffered, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"column-names", OPT_COLUMN_NAMES, "Write column names in results.",
++ &column_names, &column_names, nullptr, GET_BOOL, NO_ARG, 1, 0, 0, nullptr,
++ 0, nullptr},
++ {"skip-column-names", 'N', "Don't write column names in results.", nullptr,
++ nullptr, nullptr, GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"sigint-ignore", OPT_SIGINT_IGNORE, "Ignore SIGINT (CTRL-C).",
++ &opt_sigint_ignore, &opt_sigint_ignore, nullptr, GET_BOOL, NO_ARG, 0, 0, 0,
++ nullptr, 0, nullptr},
++ {"one-database", 'o',
++ "Ignore statements except those that occur while the default "
++ "database is the one named at the command line.",
++ nullptr, nullptr, nullptr, GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++#ifdef USE_POPEN
++ {"pager", OPT_PAGER,
++ "Pager to use to display results. If you don't supply an option, the "
++ "default pager is taken from your ENV variable PAGER. Valid pagers are "
++ "less, more, cat [> filename], etc. See interactive help (\\h) also. "
++ "This option does not work in batch mode. Disable with --disable-pager. "
++ "This option is disabled by default.",
++ nullptr, nullptr, nullptr, GET_STR, OPT_ARG, 0, 0, 0, nullptr, 0, nullptr},
++#endif
++#include "multi_factor_passwordopt-longopts.h"
++#ifdef _WIN32
++ {"pipe", 'W', "Use named pipes to connect to server.", 0, 0, 0, GET_NO_ARG,
++ NO_ARG, 0, 0, 0, 0, 0, 0},
++#endif
++ {"port", 'P',
++ "Port number to use for connection or 0 for default to, in "
++ "order of preference, my.cnf, $MYSQL_TCP_PORT, "
++#if MYSQL_PORT_DEFAULT == 0
++ "/etc/services, "
++#endif
++ "built-in default (" STRINGIFY_ARG(MYSQL_PORT) ").",
++ &opt_mysql_port, &opt_mysql_port, nullptr, GET_UINT, REQUIRED_ARG, 0, 0, 0,
++ nullptr, 0, nullptr},
++ {"prompt", OPT_PROMPT, "Set the mysql prompt to this value.",
++ ¤t_prompt, ¤t_prompt, nullptr, GET_STR_ALLOC, REQUIRED_ARG, 0,
++ 0, 0, nullptr, 0, nullptr},
++ {"protocol", OPT_MYSQL_PROTOCOL,
++ "The protocol to use for connection (tcp, socket, pipe, memory).", nullptr,
++ nullptr, nullptr, GET_STR, REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"quick", 'q',
++ "Don't cache result, print it row by row. This may slow down the server "
++ "if the output is suspended. Doesn't use history file.",
++ &quick, &quick, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"raw", 'r', "Write fields without conversion. Used with --batch.",
++ &opt_raw_data, &opt_raw_data, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr,
++ 0, nullptr},
++ {"reconnect", OPT_RECONNECT,
++ "Reconnect if the connection is lost. Disable "
++ "with --disable-reconnect. This option is enabled by default.",
++ &opt_reconnect, &opt_reconnect, nullptr, GET_BOOL, NO_ARG, 1, 0, 0,
++ nullptr, 0, nullptr},
++ {"silent", 's',
++ "Be more silent. Print results with a tab as separator, "
++ "each row on new line.",
++ nullptr, nullptr, nullptr, GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++#if defined(_WIN32)
++ {"shared-memory-base-name", OPT_SHARED_MEMORY_BASE_NAME,
++ "Base name of shared memory.", &shared_memory_base_name,
++ &shared_memory_base_name, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0,
++ 0},
++#endif
++ {"socket", 'S', "The socket file to use for connection.",
++ &opt_mysql_unix_port, &opt_mysql_unix_port, nullptr, GET_STR_ALLOC,
++ REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++#include "caching_sha2_passwordopt-longopts.h"
++#include "sslopt-longopts.h"
++
++ {"table", 't', "Output in table format.", &output_tables, &output_tables,
++ nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"tee", OPT_TEE,
++ "Append everything into outfile. See interactive help (\\h) also. "
++ "Does not work in batch mode. Disable with --disable-tee. "
++ "This option is disabled by default.",
++ nullptr, nullptr, nullptr, GET_STR, REQUIRED_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"user", 'u', "User for login if not current user.", ¤t_user,
++ ¤t_user, nullptr, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"safe-updates", 'U', "Only allow UPDATE and DELETE that uses keys.",
++ &safe_updates, &safe_updates, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr,
++ 0, nullptr},
++ {"i-am-a-dummy", 'U', "Synonym for option --safe-updates, -U.",
++ &safe_updates, &safe_updates, nullptr, GET_BOOL, NO_ARG, 0, 0, 0, nullptr,
++ 0, nullptr},
++ {"verbose", 'v', "Write more. (-v -v -v gives the table output format).",
++ nullptr, nullptr, nullptr, GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"version", 'V', "Output version information and exit.", nullptr, nullptr,
++ nullptr, GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"wait", 'w', "Wait and retry if connection is down.", nullptr, nullptr,
++ nullptr, GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"connect_timeout", OPT_CONNECT_TIMEOUT,
++ "Number of seconds before connection timeout.", &opt_connect_timeout,
++ &opt_connect_timeout, nullptr, GET_ULONG, REQUIRED_ARG, 0, 0, 3600 * 12,
++ nullptr, 0, nullptr},
++ {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,
++ "The maximum packet length to send to or receive from server.",
++ &opt_max_allowed_packet, &opt_max_allowed_packet, nullptr, GET_ULONG,
++ REQUIRED_ARG, 16 * 1024L * 1024L, 4096,
++ (longlong)2 * 1024L * 1024L * 1024L, nullptr, 1024, nullptr},
++ {"net_buffer_length", OPT_NET_BUFFER_LENGTH,
++ "The buffer size for TCP/IP and socket communication.",
++ &opt_net_buffer_length, &opt_net_buffer_length, nullptr, GET_ULONG,
++ REQUIRED_ARG, 16384, 1024, 512 * 1024 * 1024L, nullptr, 1024, nullptr},
++ {"select_limit", OPT_SELECT_LIMIT,
++ "Automatic limit for SELECT when using --safe-updates.", &select_limit,
++ &select_limit, nullptr, GET_ULONG, REQUIRED_ARG, 1000L, 1, ULONG_MAX,
++ nullptr, 1, nullptr},
++ {"max_join_size", OPT_MAX_JOIN_SIZE,
++ "Automatic limit for rows in a join when using --safe-updates.",
++ &max_join_size, &max_join_size, nullptr, GET_ULONG, REQUIRED_ARG, 1000000L,
++ 1, ULONG_MAX, nullptr, 1, nullptr},
++ {"show-warnings", OPT_SHOW_WARNINGS, "Show warnings after every statement.",
++ &show_warnings, &show_warnings, nullptr, GET_BOOL, NO_ARG, 0, 0, 0,
++ nullptr, 0, nullptr},
++ {"syslog", 'j',
++ "Log filtered interactive commands to syslog. Filtering of "
++ "commands depends on the patterns supplied via histignore option besides "
++ "the default patterns.",
++ nullptr, nullptr, nullptr, GET_NO_ARG, NO_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"plugin_dir", OPT_PLUGIN_DIR, "Directory for client-side plugins.",
++ &opt_plugin_dir, &opt_plugin_dir, nullptr, GET_STR, REQUIRED_ARG, 0, 0, 0,
++ nullptr, 0, nullptr},
++ {"default_auth", OPT_DEFAULT_AUTH,
++ "Default authentication client-side plugin to use.", &opt_default_auth,
++ &opt_default_auth, nullptr, GET_STR, REQUIRED_ARG, 0, 0, 0, nullptr, 0,
++ nullptr},
++ {"binary-mode", OPT_BINARY_MODE,
++ "By default, ASCII '\\0' is disallowed and '\\r\\n' is translated to "
++ "'\\n'. "
++ "This switch turns off both features, and also turns off parsing of all "
++ "client"
++ "commands except \\C and DELIMITER, in non-interactive mode (for input "
++ "piped to mysql or loaded using the 'source' command). This is necessary "
++ "when processing output from mysqlbinlog that may contain blobs.",
++ &opt_binary_mode, &opt_binary_mode, nullptr, GET_BOOL, NO_ARG, 0, 0, 0,
++ nullptr, 0, nullptr},
++ {"connect-expired-password", 0,
++ "Notify the server that this client is prepared to handle expired "
++ "password sandbox mode.",
++ &opt_connect_expired_password, &opt_connect_expired_password, nullptr,
++ GET_BOOL, NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++#ifndef NDEBUG
++ {"build-completion-hash", 0,
++ "Build completion hash even when it is in batch mode. It is used for "
++ "test purpose, so it is just built when DEBUG is on.",
++ &opt_build_completion_hash, &opt_build_completion_hash, nullptr, GET_BOOL,
++ NO_ARG, 0, 0, 0, nullptr, 0, nullptr},
++#endif
++#ifdef HAVE_SETNS
++ {"network-namespace", 0,
++ "Network namespace to use for connection via tcp with a server.",
++ &opt_network_namespace, &opt_network_namespace, nullptr, GET_STR,
++ REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++#endif
++ {"compression-algorithms", 0,
++ "Use compression algorithm in server/client protocol. Valid values "
++ "are any combination of 'zstd','zlib','uncompressed'.",
++ &opt_compress_algorithm, &opt_compress_algorithm, nullptr, GET_STR,
++ REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"zstd-compression-level", 0,
++ "Use this compression level in the client/server protocol, in case "
++ "--compression-algorithms=zstd. Valid range is between 1 and 22, "
++ "inclusive. Default is 3.",
++ &opt_zstd_compress_level, &opt_zstd_compress_level, nullptr, GET_UINT,
++ REQUIRED_ARG, 3, 1, 22, nullptr, 0, nullptr},
++ {"load_data_local_dir", OPT_LOAD_DATA_LOCAL_DIR,
++ "Directory path safe for LOAD DATA LOCAL INFILE to read from.",
++ &opt_load_data_local_dir, &opt_load_data_local_dir, nullptr, GET_STR,
++ REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"fido-register-factor", 0,
++ "Specifies authentication factor, for which registration needs to be "
++ "done.",
++ &opt_fido_register_factor, &opt_fido_register_factor, nullptr, GET_STR,
++ REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"authentication-oci-client-config-profile", 0,
++ "Specifies the configuration profile whose configuration options are to "
++ "be read from the OCI configuration file. Default is DEFAULT.",
++ &opt_authentication_oci_client_config_profile,
++ &opt_authentication_oci_client_config_profile, nullptr, GET_STR,
++ REQUIRED_ARG, 0, 0, 0, nullptr, 0, nullptr},
++ {"oci-config-file", 0,
++ "Specifies the location of the OCI configuration file. Default for Linux "
++ "is ~/.oci/config and %HOME/.oci/config on Windows.",
++ &opt_oci_config_file, &opt_oci_config_file, nullptr, GET_STR, REQUIRED_ARG,
++ 0, 0, 0, nullptr, 0, nullptr},
++#include "authentication_kerberos_clientopt-longopts.h"
++ {"system-command", 0,
++ "Enable (by default) or disable the system mysql command.",
++ &opt_system_command, &opt_system_command, nullptr, GET_BOOL, NO_ARG, 1, 0,
++ 0, nullptr, 0, nullptr},
++ {nullptr, 0, nullptr, nullptr, nullptr, nullptr, GET_NO_ARG, NO_ARG, 0, 0,
++ 0, nullptr, 0, nullptr}};
++
++static void usage(int version) {
++ print_version();
++
++ if (version) return;
++ puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000"));
++ printf("Usage: %s [OPTIONS] [database]\n", my_progname);
++ my_print_help(my_long_options);
++ print_defaults("my", load_default_groups);
++ my_print_variables(my_long_options);
++}
++
++bool get_one_option(int optid, const struct my_option *opt [[maybe_unused]],
++ char *argument) {
++ switch (optid) {
++ case OPT_CHARSETS_DIR:
++ strmake(mysql_charsets_dir, argument, sizeof(mysql_charsets_dir) - 1);
++ charsets_dir = mysql_charsets_dir;
++ break;
++ case OPT_DELIMITER:
++ if (argument == disabled_my_option) {
++ my_stpcpy(delimiter, DEFAULT_DELIMITER);
++ } else {
++ /* Check that delimiter does not contain a backslash */
++ if (!strstr(argument, "\\")) {
++ strmake(delimiter, argument, sizeof(delimiter) - 1);
++ } else {
++ put_info("DELIMITER cannot contain a backslash character",
++ INFO_ERROR);
++ return false;
++ }
++ }
++ delimiter_length = (uint)strlen(delimiter);
++ delimiter_str = delimiter;
++ break;
++ case OPT_LOCAL_INFILE:
++ using_opt_local_infile = true;
++ break;
++ case OPT_ENABLE_CLEARTEXT_PLUGIN:
++ using_opt_enable_cleartext_plugin = true;
++ break;
++ case OPT_TEE:
++ if (argument == disabled_my_option) {
++ if (opt_outfile) end_tee();
++ } else
++ init_tee(argument);
++ break;
++ case OPT_PAGER:
++ if (argument == disabled_my_option)
++ opt_nopager = true;
++ else {
++ opt_nopager = false;
++ if (argument && strlen(argument)) {
++ default_pager_set = true;
++ strmake(pager, argument, sizeof(pager) - 1);
++ my_stpcpy(default_pager, pager);
++ } else if (default_pager_set)
++ my_stpcpy(pager, default_pager);
++ else
++ opt_nopager = true;
++ }
++ break;
++ case OPT_MYSQL_PROTOCOL:
++ opt_protocol =
++ find_type_or_exit(argument, &sql_protocol_typelib, opt->name);
++ break;
++ case 'A':
++ opt_rehash = false;
++ break;
++ case 'N':
++ column_names = false;
++ break;
++ case 'e':
++ status.batch = true;
++ status.add_to_history = false;
++ if (!status.line_buff)
++ ignore_errors = false; // do it for the first -e only
++ if (!(status.line_buff =
++ batch_readline_command(status.line_buff, argument)))
++ return true;
++ break;
++ case 'j':
++ if (my_openlog("MysqlClient", 0, LOG_USER)) {
++ /* error */
++ put_info(strerror(errno), INFO_ERROR, errno);
++ return true;
++ }
++ opt_syslog = true;
++ break;
++ case 'o':
++ if (argument == disabled_my_option)
++ one_database = false;
++ else
++ one_database = skip_updates = true;
++ break;
++ PARSE_COMMAND_LINE_PASSWORD_OPTION;
++ case '#':
++ DBUG_PUSH(argument ? argument : default_dbug_option);
++ debug_info_flag = true;
++ break;
++ case 's':
++ if (argument == disabled_my_option)
++ opt_silent = 0;
++ else
++ opt_silent++;
++ break;
++ case 'v':
++ if (argument == disabled_my_option)
++ verbose = 0;
++ else
++ verbose++;
++ break;
++ case 'B':
++ status.batch = true;
++ status.add_to_history = false;
++ opt_silent = std::max(opt_silent, 1U); // more silent
++ break;
++ case 'W':
++#ifdef _WIN32
++ opt_protocol = MYSQL_PROTOCOL_PIPE;
++#endif
++ break;
++#include "sslopt-case.h"
++
++#include "authentication_kerberos_clientopt-case.h"
++
++ case 'V':
++ usage(1);
++ exit(0);
++ case 'I':
++ case '?':
++ usage(0);
++ exit(0);
++ case OPT_MYSQL_BINARY_AS_HEX:
++ opt_binhex = (argument != disabled_my_option);
++ opt_binary_as_hex_set_explicitly = true;
++ break;
++ case 'C':
++ CLIENT_WARN_DEPRECATED("--compress", "--compression-algorithms");
++ break;
++ }
++ return false;
++}
++
++static int get_options(int argc, char **argv) {
++ char *tmp, *pagpoint;
++ int ho_error;
++
++ tmp = (char *)getenv("MYSQL_HOST");
++ if (tmp) current_host = my_strdup(PSI_NOT_INSTRUMENTED, tmp, MYF(MY_WME));
++
++ pagpoint = getenv("PAGER");
++ if (!((char *)(pagpoint))) {
++ my_stpcpy(pager, "stdout");
++ opt_nopager = true;
++ } else
++ my_stpcpy(pager, pagpoint);
++ my_stpcpy(default_pager, pager);
++
++ if (mysql_get_option(nullptr, MYSQL_OPT_MAX_ALLOWED_PACKET,
++ &opt_max_allowed_packet) ||
++ mysql_get_option(nullptr, MYSQL_OPT_NET_BUFFER_LENGTH,
++ &opt_max_allowed_packet)) {
++ exit(1);
++ }
++
++ if ((ho_error =
++ handle_options(&argc, &argv, my_long_options, get_one_option)))
++ exit(ho_error);
++
++ if (mysql_options(nullptr, MYSQL_OPT_MAX_ALLOWED_PACKET,
++ &opt_max_allowed_packet) ||
++ mysql_options(nullptr, MYSQL_OPT_NET_BUFFER_LENGTH,
++ &opt_net_buffer_length)) {
++ exit(1);
++ }
++
++ if (status.batch) /* disable pager and outfile in this case */
++ {
++ my_stpcpy(default_pager, "stdout");
++ my_stpcpy(pager, "stdout");
++ opt_nopager = true;
++ default_pager_set = false;
++ opt_outfile = false;
++ opt_reconnect = false;
++ connect_flag = 0; /* Not in interactive mode */
++ }
++
++ if (argc > 1) {
++ usage(0);
++ exit(1);
++ }
++ if (argc == 1) {
++ skip_updates = false;
++ my_free(current_db);
++ current_db = my_strdup(PSI_NOT_INSTRUMENTED, *argv, MYF(MY_WME));
++ }
++ if (debug_info_flag) my_end_arg = MY_CHECK_ERROR | MY_GIVE_INFO;
++ if (debug_check_flag) my_end_arg = MY_CHECK_ERROR;
++
++ if (ignore_spaces) connect_flag |= CLIENT_IGNORE_SPACE;
++
++ return (0);
++}
++
++static int read_and_execute(bool interactive) {
++#if defined(_WIN32)
++ String tmpbuf;
++ String buffer;
++#endif
++
++ /*
++ line can be allocated by:
++ - batch_readline. Use my_free()
++ - my_win_console_readline. Do not free, see tmpbuf.
++ - readline. Use free()
++ */
++ char *line = nullptr;
++ char in_string = 0;
++ ulong line_number = 0;
++ bool ml_comment = false;
++ COMMANDS *com;
++ size_t line_length = 0;
++ status.exit_status = 1;
++
++ real_binary_mode = !interactive && opt_binary_mode;
++ for (;;) {
++ /* Reset as SIGINT has already got handled. */
++ sigint_received = false;
++
++ if (!interactive) {
++ /*
++ batch_readline can return 0 on EOF or error.
++ In that case, we need to double check that we have a valid
++ line before actually setting line_length to read_length.
++ */
++ line = batch_readline(status.line_buff, real_binary_mode);
++ if (line) {
++ line_length = status.line_buff->read_length;
++
++ /*
++ ASCII 0x00 is not allowed appearing in queries if it is not in
++ binary mode.
++ */
++ if (!real_binary_mode && strlen(line) != line_length) {
++ status.exit_status = 1;
++ String msg;
++ msg.append(
++ "ASCII '\\0' appeared in the statement, but this is not "
++ "allowed unless option --binary-mode is enabled and mysql is "
++ "run in non-interactive mode. Set --binary-mode to 1 if ASCII "
++ "'\\0' is expected. Query: '");
++ msg.append(glob_buffer);
++ msg.append(line);
++ msg.append("'.");
++ put_info(msg.c_ptr(), INFO_ERROR);
++ break;
++ }
++
++ /*
++ Skip UTF8 Byte Order Marker (BOM) 0xEFBBBF.
++ Editors like "notepad" put this marker in
++ the very beginning of a text file when
++ you save the file using "Unicode UTF-8" format.
++ */
++ if (!line_number && (uchar)line[0] == 0xEF && (uchar)line[1] == 0xBB &&
++ (uchar)line[2] == 0xBF) {
++ line += 3;
++ // decrease the line length accordingly to the 3 bytes chopped
++ line_length -= 3;
++ }
++ }
++ line_number++;
++ if (!glob_buffer.length()) status.query_start_line = line_number;
++ } else {
++ const char *prompt =
++ (ml_comment ? " /*> "
++ : glob_buffer.is_empty() ? construct_prompt()
++ : !in_string ? " -> "
++ : in_string == '\'' ? " '> "
++ : (in_string == '`' ? " `> " : " \"> "));
++ if (opt_outfile && glob_buffer.is_empty()) fflush(OUTFILE);
++
++#if defined(_WIN32)
++ size_t nread;
++ tee_fputs(prompt, stdout);
++ if (!tmpbuf.is_alloced()) tmpbuf.alloc(65535);
++ tmpbuf.length(0);
++ buffer.length(0);
++ line = my_win_console_readline(charset_info, (char *)tmpbuf.ptr(),
++ tmpbuf.alloced_length(), &nread);
++ if (line && (nread == 0)) {
++ tee_puts("^C", stdout);
++ reset_prompt(&in_string, &ml_comment);
++ continue;
++ } else if (*line == 0x1A) /* (Ctrl + Z) */
++ break;
++#else
++ if (opt_outfile) fputs(prompt, OUTFILE);
++ /*
++ free the previous entered line.
++ */
++ if (line) free(line);
++ line = readline(prompt);
++
++ if (sigint_received) {
++ sigint_received = false;
++ tee_puts("^C", stdout);
++ reset_prompt(&in_string, &ml_comment);
++ continue;
++ }
++#endif /* defined(_WIN32) */
++ /*
++ When Ctrl+d or Ctrl+z is pressed, the line may be NULL on some OS
++ which may cause coredump.
++ */
++ if (opt_outfile && line) fprintf(OUTFILE, "%s\n", line);
++
++ line_length = line ? strlen(line) : 0;
++ }
++ // End of file or system error
++ if (!line) {
++ if (status.line_buff && status.line_buff->error)
++ status.exit_status = 1;
++ else
++ status.exit_status = 0;
++ break;
++ }
++
++ /*
++ Check if line is a mysql command line
++ (We want to allow help, print and clear anywhere at line start
++ */
++ if ((named_cmds || glob_buffer.is_empty()) && !ml_comment && !in_string &&
++ (com = find_command(line))) {
++ if ((*com->func)(&glob_buffer, line) > 0) {
++ // lets log the exit/quit command.
++ if (interactive && status.add_to_history && com->cmd_char == 'q')
++ add_filtered_history(line);
++ break;
++ }
++ if (glob_buffer.is_empty()) // If buffer was emptied
++ in_string = 0;
++ if (interactive && status.add_to_history) add_filtered_history(line);
++ continue;
++ }
++ if (add_line(glob_buffer, line, line_length, &in_string, &ml_comment,
++ status.line_buff ? status.line_buff->truncated : false))
++ break;
++ }
++ /* if in batch mode, send last query even if it doesn't end with \g or go */
++
++ if (!interactive && !status.exit_status) {
++ remove_cntrl(&glob_buffer);
++ if (!glob_buffer.is_empty()) {
++ status.exit_status = 1;
++ if (com_go(&glob_buffer, line) <= 0) status.exit_status = 0;
++ }
++ }
++
++#if defined(_WIN32)
++ buffer.mem_free();
++ tmpbuf.mem_free();
++#else
++ if (interactive)
++ /*
++ free the last entered line.
++ */
++ free(line);
++#endif
++
++ /*
++ If the function is called by 'source' command, it will return to
++ interactive mode, so real_binary_mode should be false. Otherwise, it will
++ exit the program, it is safe to set real_binary_mode to false.
++ */
++ real_binary_mode = false;
++ return status.exit_status;
++}
++
++static inline void reset_prompt(char *in_string, bool *ml_comment) {
++ glob_buffer.length(0);
++ *ml_comment = false;
++ *in_string = 0;
++}
++
++/**
++ It checks if the input is a short form command. It returns the command's
++ pointer if a command is found, else return NULL. Note that if binary-mode
++ is set, then only @\C is searched for.
++
++ @param cmd_char A character of one byte.
++
++ @return
++ the command's pointer or NULL.
++*/
++static COMMANDS *find_command(char cmd_char) {
++ DBUG_TRACE;
++ DBUG_PRINT("enter", ("cmd_char: %d", cmd_char));
++
++ int index = -1;
++
++ /*
++ In binary-mode, we disallow all mysql commands except '\C'
++ and DELIMITER.
++ */
++ if (real_binary_mode) {
++ if (cmd_char == 'C') index = charset_index;
++ } else
++ index = get_command_index(cmd_char);
++
++ if (index >= 0) {
++ DBUG_PRINT("exit", ("found command: %s", commands[index].name));
++ return &commands[index];
++ } else
++ return (COMMANDS *)nullptr;
++}
++
++/**
++ It checks if the input is a long form command. It returns the command's
++ pointer if a command is found, else return NULL. Note that if binary-mode
++ is set, then only DELIMITER is searched for.
++
++ @param name A string.
++ @return
++ the command's pointer or NULL.
++*/
++static COMMANDS *find_command(char *name) {
++ uint len;
++ char *end;
++ DBUG_TRACE;
++
++ assert(name != nullptr);
++ DBUG_PRINT("enter", ("name: '%s'", name));
++
++ while (my_isspace(charset_info, *name)) name++;
++ /*
++ If there is an \\g in the row or if the row has a delimiter but
++ this is not a delimiter command, let add_line() take care of
++ parsing the row and calling find_command().
++ */
++ if ((!real_binary_mode && strstr(name, "\\g")) ||
++ (strstr(name, delimiter) &&
++ !is_delimiter_command(name, DELIMITER_NAME_LEN)))
++ return (COMMANDS *)nullptr;
++
++ if ((end = strcont(name, " \t"))) {
++ len = (uint)(end - name);
++ while (my_isspace(charset_info, *end)) end++;
++ if (!*end) end = nullptr; // no arguments to function
++ } else
++ len = (uint)strlen(name);
++
++ int index = -1;
++ if (real_binary_mode) {
++ if (is_delimiter_command(name, len)) index = delimiter_index;
++ } else {
++ /*
++ All commands are in the first part of commands array and have a function
++ to implement it.
++ */
++ for (uint i = 0; commands[i].func; i++) {
++ if (!my_strnncoll(&my_charset_latin1, (uchar *)name, len,
++ pointer_cast<const uchar *>(commands[i].name), len) &&
++ (commands[i].name[len] == '\0') &&
++ (!end || commands[i].takes_params)) {
++ index = i;
++ break;
++ }
++ }
++ }
++
++ if (index >= 0) {
++ DBUG_PRINT("exit", ("found command: %s", commands[index].name));
++ return &commands[index];
++ }
++ return (COMMANDS *)nullptr;
++}
++
++static bool add_line(String &buffer, char *line, size_t line_length,
++ char *in_string, bool *ml_comment, bool truncated) {
++ uchar inchar;
++ char buff[80], *pos, *out;
++ COMMANDS *com;
++ bool need_space = false;
++ enum { SSC_NONE = 0, SSC_CONDITIONAL, SSC_HINT } ss_comment = SSC_NONE;
++ DBUG_TRACE;
++
++ if (!line[0] && buffer.is_empty()) return false;
++
++ if (status.add_to_history && line[0]) add_filtered_history(line);
++
++ char *end_of_line = line + line_length;
++
++ for (pos = out = line; pos < end_of_line; pos++) {
++ inchar = (uchar)*pos;
++ if (!preserve_comments) {
++ // Skip spaces at the beginning of a statement
++ if (my_isspace(charset_info, inchar) && (out == line) &&
++ buffer.is_empty())
++ continue;
++ }
++ // Accept multi-byte characters as-is
++ int length;
++ if (use_mb(charset_info) &&
++ (length = my_ismbchar(charset_info, pos, end_of_line))) {
++ if (!*ml_comment || preserve_comments) {
++ while (length--) *out++ = *pos++;
++ pos--;
++ } else
++ pos += length - 1;
++ continue;
++ }
++ if (!*ml_comment && inchar == '\\' &&
++ !(*in_string &&
++ (mysql.server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES))) {
++ // Found possbile one character command like \c
++
++ if (!(inchar = (uchar) * ++pos)) break; // readline adds one '\'
++ if (*in_string || inchar == 'N') // \N is short for NULL
++ { // Don't allow commands in string
++ *out++ = '\\';
++ if ((inchar == '`') && (*in_string == inchar))
++ pos--;
++ else
++ *out++ = (char)inchar;
++ continue;
++ }
++ if ((com = find_command((char)inchar))) {
++ // Flush previously accepted characters
++ if (out != line) {
++ buffer.append(line, (uint)(out - line));
++ out = line;
++ }
++
++ if ((*com->func)(&buffer, pos - 1) > 0) return true; // Quit
++ if (com->takes_params) {
++ if (ss_comment) {
++ /*
++ If a client-side macro appears inside a server-side comment,
++ discard all characters in the comment after the macro (that is,
++ until the end of the comment rather than the next delimiter)
++ */
++ for (pos++; *pos && (*pos != '*' || *(pos + 1) != '/'); pos++)
++ ;
++ pos--;
++ } else {
++ for (pos++; *pos && (*pos != *delimiter ||
++ !is_prefix(pos + 1, delimiter + 1));
++ pos++)
++ ; // Remove parameters
++ if (!*pos)
++ pos--;
++ else
++ pos += delimiter_length - 1; // Point at last delim char
++ }
++ }
++ } else {
++ sprintf(buff, "Unknown command '\\%c'.", inchar);
++ if (put_info(buff, INFO_ERROR) > 0) return true;
++ *out++ = '\\';
++ *out++ = (char)inchar;
++ continue;
++ }
++ } else if (!*ml_comment && !*in_string && ss_comment != SSC_HINT &&
++ is_prefix(pos, delimiter)) {
++ // Found a statement. Continue parsing after the delimiter
++ pos += delimiter_length;
++
++ if (preserve_comments) {
++ while (my_isspace(charset_info, *pos)) *out++ = *pos++;
++ }
++ // Flush previously accepted characters
++ if (out != line) {
++ buffer.append(line, (uint32)(out - line));
++ out = line;
++ }
++
++ if (preserve_comments &&
++ ((*pos == '#') || ((*pos == '-') && (pos[1] == '-') &&
++ my_isspace(charset_info, pos[2])))) {
++ // Add trailing single line comments to this statement
++ buffer.append(pos);
++ pos += strlen(pos);
++ }
++
++ pos--;
++
++ if ((com = find_command(buffer.c_ptr()))) {
++ if ((*com->func)(&buffer, buffer.c_ptr()) > 0) return true; // Quit
++ } else {
++ if (com_go(&buffer, nullptr) > 0) // < 0 is not fatal
++ return true;
++ }
++ buffer.length(0);
++ } else if (!*ml_comment &&
++ (!*in_string &&
++ (inchar == '#' ||
++ (inchar == '-' && pos[1] == '-' &&
++ /*
++ The third byte is either whitespace or is the
++ end of the line -- which would occur only
++ because of the user sending newline -- which is
++ itself whitespace and should also match.
++ */
++ (my_isspace(charset_info, pos[2]) || !pos[2]))))) {
++ // Flush previously accepted characters
++ if (out != line) {
++ buffer.append(line, (uint32)(out - line));
++ out = line;
++ }
++
++ // comment to end of line
++ if (preserve_comments) {
++ bool started_with_nothing = !buffer.length();
++
++ buffer.append(pos);
++
++ /*
++ A single-line comment by itself gets sent immediately so that
++ client commands (delimiter, status, etc) will be interpreted on
++ the next line.
++ */
++ if (started_with_nothing) {
++ if (com_go(&buffer, nullptr) > 0) // < 0 is not fatal
++ return true;
++ buffer.length(0);
++ }
++ }
++
++ break;
++ } else if (!*in_string && inchar == '/' && pos[1] == '*' && pos[2] != '!' &&
++ pos[2] != '+' && ss_comment != SSC_HINT) {
++ if (preserve_comments) {
++ *out++ = *pos++; // copy '/'
++ *out++ = *pos; // copy '*'
++ } else
++ pos++;
++ *ml_comment = true;
++ if (out != line) {
++ buffer.append(line, (uint)(out - line));
++ out = line;
++ }
++ } else if (*ml_comment && !ss_comment && inchar == '*' &&
++ *(pos + 1) == '/') {
++ if (preserve_comments) {
++ *out++ = *pos++; // copy '*'
++ *out++ = *pos; // copy '/'
++ } else
++ pos++;
++ *ml_comment = false;
++ if (out != line) {
++ buffer.append(line, (uint32)(out - line));
++ out = line;
++ }
++ // Consumed a 2 chars or more, and will add 1 at most,
++ // so using the 'line' buffer to edit data in place is ok.
++ need_space = true;
++ } else { // Add found char to buffer
++ if (!*in_string && inchar == '/' && pos[1] == '*') {
++ if (pos[2] == '!')
++ ss_comment = SSC_CONDITIONAL;
++ else if (pos[2] == '+')
++ ss_comment = SSC_HINT;
++ } else if (!*in_string && ss_comment && inchar == '*' &&
++ *(pos + 1) == '/')
++ ss_comment = SSC_NONE;
++ if (inchar == *in_string)
++ *in_string = 0;
++ else if (!*ml_comment && !*in_string && ss_comment != SSC_HINT &&
++ (inchar == '\'' || inchar == '"' || inchar == '`'))
++ *in_string = (char)inchar;
++ if (!*ml_comment || preserve_comments) {
++ if (need_space && !my_isspace(charset_info, (char)inchar)) *out++ = ' ';
++ need_space = false;
++ *out++ = (char)inchar;
++ }
++ }
++ }
++ if (out != line || !buffer.is_empty()) {
++ uint length = (uint)(out - line);
++
++ if (!truncated &&
++ (!is_delimiter_command(line, length) || (*in_string || *ml_comment))) {
++ /*
++ Don't add a new line in case there's a DELIMITER command to be
++ added to the glob buffer (e.g. on processing a line like
++ "<command>;DELIMITER <non-eof>") : similar to how a new line is
++ not added in the case when the DELIMITER is the first command
++ entered with an empty glob buffer. However, if the delimiter is
++ part of a string or a comment, the new line should be added. (e.g.
++ SELECT '\ndelimiter\n';\n)
++ */
++ *out++ = '\n';
++ length++;
++ }
++ if (buffer.length() + length >= buffer.alloced_length())
++ buffer.mem_realloc(buffer.length() + length + batch_io_size);
++ if ((!*ml_comment || preserve_comments) && buffer.append(line, length))
++ return true;
++ }
++ return false;
++}
++
++/*****************************************************************
++ Interface to Readline Completion
++******************************************************************/
++
++#ifdef HAVE_READLINE
++
++static char *new_command_generator(const char *text, int);
++static char **new_mysql_completion(const char *text, int start, int end);
++
++/*
++ Tell the GNU Readline library how to complete. We want to try to complete
++ on command names if this is the first word in the line, or on filenames
++ if not.
++*/
++
++#if defined(EDITLINE_HAVE_COMPLETION_CHAR)
++char *no_completion(const char *, int) { return nullptr; }
++#elif defined(EDITLINE_HAVE_COMPLETION_INT)
++int no_completion(const char *, int) { return 0; }
++#else
++char *no_completion() { return nullptr; }
++#endif
++
++/*
++ returns 0 if line matches the previous history entry
++ returns 1 if the line doesn't match the previous history entry
++*/
++static int not_in_history(const char *line) {
++ HIST_ENTRY *oldhist = history_get(history_length);
++
++ if (oldhist == nullptr) return 1;
++ if (strcmp(oldhist->line, line) == 0) return 0;
++ return 1;
++}
++
++#if defined(USE_NEW_EDITLINE_INTERFACE)
++static int fake_magic_space(int, int)
++#else
++static int fake_magic_space(const char *, int)
++#endif
++{
++ rl_insert(1, ' ');
++ return 0;
++}
++
++static void initialize_readline(char *name) {
++ /* Allow conditional parsing of the ~/.inputrc file. */
++ rl_readline_name = name;
++
++ /* Accept all locales. */
++ setlocale(LC_ALL, "");
++
++ /* Tell the completer that we want a crack first. */
++#if defined(EDITLINE_HAVE_COMPLETION_CHAR)
++ rl_attempted_completion_function = &new_mysql_completion;
++ rl_completion_entry_function = &no_completion;
++
++ rl_add_defun("magic-space", &fake_magic_space, -1);
++#elif defined(EDITLINE_HAVE_COMPLETION_INT)
++ rl_attempted_completion_function = &new_mysql_completion;
++ rl_completion_entry_function = &no_completion;
++ rl_add_defun("magic-space", &fake_magic_space, -1);
++#else
++ rl_attempted_completion_function = (CPPFunction *)&new_mysql_completion;
++ rl_completion_entry_function = &no_completion;
++#endif
++}
++
++/*
++ Attempt to complete on the contents of TEXT. START and END show the
++ region of TEXT that contains the word to complete. We can use the
++ entire line in case we want to do some simple parsing. Return the
++ array of matches, or NULL if there aren't any.
++*/
++
++static char **new_mysql_completion(const char *text, int start [[maybe_unused]],
++ int end [[maybe_unused]]) {
++ if (!status.batch && !quick)
++#if defined(USE_NEW_EDITLINE_INTERFACE)
++ return rl_completion_matches(text, new_command_generator);
++#else
++ return completion_matches(const_cast<char *>(text), new_command_generator);
++#endif
++ else
++ return (char **)nullptr;
++}
++
++static char *new_command_generator(const char *text, int state) {
++ static int textlen;
++ char *ptr;
++ static Bucket *b;
++ static entry *e;
++ static uint i;
++
++ if (!state) textlen = (uint)strlen(text);
++
++ if (textlen > 0) { /* lookup in the hash */
++ if (!state) {
++ uint len;
++
++ b = find_all_matches(&ht, text, (uint)strlen(text), &len);
++ if (!b) return NullS;
++ e = b->pData;
++ }
++
++ if (e) {
++ ptr = strdup(e->str);
++ e = e->pNext;
++ return ptr;
++ }
++ } else { /* traverse the entire hash, ugly but works */
++
++ if (!state) {
++ /* find the first used bucket */
++ for (i = 0; i < ht.nTableSize; i++) {
++ if (ht.arBuckets[i]) {
++ b = ht.arBuckets[i];
++ e = b->pData;
++ break;
++ }
++ }
++ }
++ ptr = NullS;
++ while (e && !ptr) { /* find valid entry in bucket */
++ if ((uint)strlen(e->str) == b->nKeyLength) ptr = strdup(e->str);
++ /* find the next used entry */
++ e = e->pNext;
++ if (!e) { /* find the next used bucket */
++ b = b->pNext;
++ if (!b) {
++ for (i++; i < ht.nTableSize; i++) {
++ if (ht.arBuckets[i]) {
++ b = ht.arBuckets[i];
++ e = b->pData;
++ break;
++ }
++ }
++ } else
++ e = b->pData;
++ }
++ }
++ if (ptr) return ptr;
++ }
++ return NullS;
++}
++
++/* Build up the completion hash */
++
++static void build_completion_hash(bool rehash, bool write_info) {
++ COMMANDS *cmd = commands;
++ MYSQL_RES *databases = nullptr, *tables = nullptr;
++ MYSQL_RES *fields;
++ static char ***field_names = nullptr;
++ MYSQL_ROW database_row, table_row;
++ MYSQL_FIELD *sql_field;
++ char buf[NAME_LEN * 2 + 2]; // table name plus field name plus 2
++ int i, j, num_fields;
++ DBUG_TRACE;
++
++#ifndef NDEBUG
++ if (!opt_build_completion_hash)
++#endif
++ {
++ if (status.batch || quick || !current_db)
++ return; // We don't need completion in batches
++ }
++
++ if (!rehash) return;
++
++ /* Free old used memory */
++ if (field_names) field_names = nullptr;
++ completion_hash_clean(&ht);
++ hash_mem_root.Clear();
++
++ /* hash this file's known subset of SQL commands */
++ while (cmd->name) {
++ add_word(&ht, cmd->name);
++ cmd++;
++ }
++
++ /* hash MySQL functions (to be implemented) */
++
++ /* hash all database names */
++ if (mysql_query(&mysql, "show databases") == 0) {
++ if (!(databases = mysql_store_result(&mysql)))
++ put_info(mysql_error(&mysql), INFO_INFO);
++ else {
++ while ((database_row = mysql_fetch_row(databases))) {
++ char *str = strdup_root(&hash_mem_root, (char *)database_row[0]);
++ if (str) add_word(&ht, (char *)str);
++ }
++ mysql_free_result(databases);
++ }
++ }
++ /* hash all table names */
++ if (mysql_query(&mysql, "show tables") == 0) {
++ if (!(tables = mysql_store_result(&mysql)))
++ put_info(mysql_error(&mysql), INFO_INFO);
++ else {
++ if (mysql_num_rows(tables) > 0 && !opt_silent && write_info) {
++ tee_fprintf(stdout,
++ "\
++Reading table information for completion of table and column names\n\
++You can turn off this feature to get a quicker startup with -A\n\n");
++ }
++ while ((table_row = mysql_fetch_row(tables))) {
++ char *str = strdup_root(&hash_mem_root, (char *)table_row[0]);
++ if (str && !completion_hash_exists(&ht, (char *)str, (uint)strlen(str)))
++ add_word(&ht, str);
++ }
++ }
++ }
++
++ /* hash all field names, both with the table prefix and without it */
++ if (!tables) /* no tables */
++ {
++ return;
++ }
++ mysql_data_seek(tables, 0);
++ if (!(field_names = (char ***)hash_mem_root.Alloc(
++ sizeof(char **) * (uint)(mysql_num_rows(tables) + 1)))) {
++ mysql_free_result(tables);
++ return;
++ }
++ i = 0;
++ while ((table_row = mysql_fetch_row(tables))) {
++ if ((fields =
++ mysql_list_fields(&mysql, (const char *)table_row[0], NullS))) {
++ num_fields = mysql_num_fields(fields);
++ if (!(field_names[i] = (char **)hash_mem_root.Alloc(
++ sizeof(char *) * (num_fields * 2 + 1)))) {
++ mysql_free_result(fields);
++ break;
++ }
++ field_names[i][num_fields * 2] = nullptr;
++ j = 0;
++ while ((sql_field = mysql_fetch_field(fields))) {
++ sprintf(buf, "%.64s.%.64s", table_row[0], sql_field->name);
++ field_names[i][j] = strdup_root(&hash_mem_root, buf);
++ add_word(&ht, field_names[i][j]);
++ field_names[i][num_fields + j] =
++ strdup_root(&hash_mem_root, sql_field->name);
++ if (!completion_hash_exists(
++ &ht, field_names[i][num_fields + j],
++ (uint)strlen(field_names[i][num_fields + j])))
++ add_word(&ht, field_names[i][num_fields + j]);
++ j++;
++ }
++ mysql_free_result(fields);
++ } else
++ field_names[i] = nullptr;
++
++ i++;
++ }
++ mysql_free_result(tables);
++ field_names[i] = nullptr; // End pointer
++}
++
++/* for gnu readline */
++
++#ifndef HAVE_INDEX
++extern "C" {
++extern char *index(const char *, int c), *rindex(const char *, int);
++
++char *index(const char *s, int c) {
++ for (;;) {
++ if (*s == (char)c) return (char *)s;
++ if (!*s++) return NullS;
++ }
++}
++
++char *rindex(const char *s, int c) {
++ char *t;
++
++ t = NullS;
++ do
++ if (*s == (char)c) t = (char *)s;
++ while (*s++);
++ return (char *)t;
++}
++}
++#endif /* ! HAVE_INDEX */
++#endif /* HAVE_READLINE */
++
++static void fix_line(String *final_command) {
++ int total_lines = 1;
++ char *ptr = final_command->c_ptr();
++ String fixed_buffer; /* Converted buffer */
++
++ /* Character if we are in a string or not */
++ char str_char = '\0';
++
++ /* find out how many lines we have and remove newlines */
++ while (*ptr != '\0') {
++ switch (*ptr) {
++ /* string character */
++ case '"':
++ case '\'':
++ case '`':
++ if (str_char == '\0') /* open string */
++ str_char = *ptr;
++ else if (str_char == *ptr) /* close string */
++ str_char = '\0';
++ fixed_buffer.append(ptr, 1);
++ break;
++ case '\n':
++ /* not in string, change to space if in string, leave it alone */
++ fixed_buffer.append(str_char == '\0' ? " " : "\n");
++ total_lines++;
++ break;
++ case '\\':
++ fixed_buffer.append('\\');
++ /* need to see if the backslash is escaping anything */
++ if (str_char) {
++ ptr++;
++ /* special characters that need escaping */
++ if (*ptr == '\'' || *ptr == '"' || *ptr == '\\')
++ fixed_buffer.append(ptr, 1);
++ else
++ ptr--;
++ }
++ break;
++
++ default:
++ fixed_buffer.append(ptr, 1);
++ }
++ ptr++;
++ }
++ if (total_lines > 1) add_filtered_history(fixed_buffer.ptr());
++}
++
++/* Add the given line to mysql history and syslog. */
++static void add_filtered_history(const char *string) {
++ // line shouldn't be on history ignore list
++ if (ignore_matcher.is_matching(string, charset_info)) return;
++
++#ifdef HAVE_READLINE
++ if (!quick && not_in_history(string)) add_history(string);
++#endif
++
++ if (opt_syslog) add_syslog(string);
++}
++
++void add_syslog(const char *line) {
++ char buff[MAX_SYSLOG_MESSAGE_SIZE];
++ snprintf(buff, sizeof(buff),
++ "SYSTEM_USER:'%s', MYSQL_USER:'%s', "
++ "CONNECTION_ID:%lu, DB_SERVER:'%s', DB:'%s', QUERY:'%s'",
++ /* use the cached user/sudo_user value. */
++ current_os_sudouser ? current_os_sudouser
++ : current_os_user ? current_os_user
++ : "--",
++ current_user ? current_user : "--", mysql_thread_id(&mysql),
++ current_host ? current_host : "--", current_db ? current_db : "--",
++ line);
++
++ (void)my_syslog(charset_info, INFORMATION_LEVEL, buff);
++ return;
++}
++
++static int reconnect(void) {
++ /* purecov: begin tested */
++ if (opt_reconnect) {
++ put_info("No connection. Trying to reconnect...", INFO_INFO);
++ (void)com_connect((String *)nullptr, nullptr);
++ if (opt_rehash && connected) com_rehash(nullptr, nullptr);
++ }
++ if (!connected) return put_info("Can't connect to the server\n", INFO_ERROR);
++ /* purecov: end */
++ return 0;
++}
++
++/**
++ Checks the current DB and updates the global variable current_db
++ If the command fails hen he current_db is set to nullptr.
++
++ @return Error state
++ @retval true An error occurred
++ @retval false Success; current_db is updated
++*/
++static bool get_current_db() {
++ MYSQL_RES *res;
++
++ /* If one_database is set, current_db is not supposed to change. */
++ if (one_database) return false;
++
++ my_free(current_db);
++ current_db = nullptr;
++ /* In case of error below current_db will be NULL */
++ if (!mysql_query(&mysql, "SELECT DATABASE()") &&
++ (res = mysql_use_result(&mysql))) {
++ MYSQL_ROW row = mysql_fetch_row(res);
++ if (row && row[0])
++ current_db = my_strdup(PSI_NOT_INSTRUMENTED, row[0], MYF(MY_WME));
++ mysql_free_result(res);
++ } else {
++ /* We failed to issue the command and we likely lost connection */
++ return true;
++ }
++ return false;
++}
++
++/***************************************************************************
++ The different commands
++***************************************************************************/
++
++static int mysql_real_query_for_lazy(const char *buf, size_t length,
++ bool set_params = false) {
++ int error = 0;
++ for (uint retry = 0;; retry++) {
++ error = 0;
++
++ if (set_params && global_attrs->set_params(&mysql)) break;
++ if (!mysql_real_query(&mysql, buf, (ulong)length)) break;
++ error = put_error(&mysql);
++ if ((mysql_errno(&mysql) != CR_SERVER_GONE_ERROR &&
++ mysql_errno(&mysql) != CR_SERVER_LOST &&
++ mysql.net.error != NET_ERROR_SOCKET_UNUSABLE) ||
++ retry > 1 || !opt_reconnect)
++ break;
++ if (reconnect()) break;
++ }
++ if (set_params) global_attrs->clear(connected ? &mysql : nullptr);
++ return error;
++}
++
++static int mysql_store_result_for_lazy(MYSQL_RES **result) {
++ if ((*result = mysql_store_result(&mysql))) return 0;
++
++ if (mysql_error(&mysql)[0]) return put_error(&mysql);
++ return 0;
++}
++
++static void print_help_item(MYSQL_ROW *cur, int num_name, int num_cat,
++ char *last_char) {
++ char ccat = (*cur)[num_cat][0];
++ if (*last_char != ccat) {
++ put_info(ccat == 'Y' ? "categories:" : "topics:", INFO_INFO);
++ *last_char = ccat;
++ }
++ tee_fprintf(PAGER, " %s\n", (*cur)[num_name]);
++}
++
++static int com_server_help(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]], char *help_arg) {
++ MYSQL_ROW cur;
++ const char *server_cmd;
++ char cmd_buf[100 + 1];
++ MYSQL_RES *result;
++ int error;
++
++ if (help_arg[0] != '\'') {
++ char *end_arg = strend(help_arg);
++ if (--end_arg) {
++ while (my_isspace(charset_info, *end_arg)) end_arg--;
++ *++end_arg = '\0';
++ }
++ (void)strxnmov(cmd_buf, sizeof(cmd_buf), "help '", help_arg, "'", NullS);
++ } else
++ (void)strxnmov(cmd_buf, sizeof(cmd_buf), "help ", help_arg, NullS);
++
++ server_cmd = cmd_buf;
++
++ if (!status.batch) {
++ old_buffer = *buffer;
++ old_buffer.copy();
++ }
++
++ if (!connected && reconnect()) return 1;
++
++ if ((error =
++ mysql_real_query_for_lazy(server_cmd, (int)strlen(server_cmd))) ||
++ (error = mysql_store_result_for_lazy(&result)))
++ return error;
++
++ if (result) {
++ unsigned int num_fields = mysql_num_fields(result);
++ uint64_t num_rows = mysql_num_rows(result);
++ mysql_fetch_fields(result);
++ if (num_fields == 3 && num_rows == 1) {
++ if (!(cur = mysql_fetch_row(result))) {
++ error = -1;
++ goto err;
++ }
++
++ init_pager();
++ tee_fprintf(PAGER, "Name: \'%s\'\n", cur[0]);
++ tee_fprintf(PAGER, "Description:\n%s", cur[1]);
++ if (cur[2] && *((char *)cur[2]))
++ tee_fprintf(PAGER, "Examples:\n%s", cur[2]);
++ tee_fprintf(PAGER, "\n");
++ end_pager();
++ } else if (num_fields >= 2 && num_rows) {
++ init_pager();
++ char last_char = 0;
++
++ int num_name = 0, num_cat = 0;
++
++ if (num_fields == 2) {
++ put_info("Many help items for your request exist.", INFO_INFO);
++ put_info(
++ "To make a more specific request, please type 'help "
++ "<item>',\nwhere <item> is one of the following",
++ INFO_INFO);
++ num_name = 0;
++ num_cat = 1;
++ } else if ((cur = mysql_fetch_row(result))) {
++ tee_fprintf(PAGER, "You asked for help about help category: \"%s\"\n",
++ cur[0]);
++ put_info(
++ "For more information, type 'help <item>', where <item> is one "
++ "of "
++ "the following",
++ INFO_INFO);
++ num_name = 1;
++ num_cat = 2;
++ print_help_item(&cur, 1, 2, &last_char);
++ }
++
++ while ((cur = mysql_fetch_row(result)))
++ print_help_item(&cur, num_name, num_cat, &last_char);
++ tee_fprintf(PAGER, "\n");
++ end_pager();
++ } else {
++ put_info("\nNothing found", INFO_INFO);
++ if (native_strncasecmp(server_cmd, "help 'contents'", 15) == 0) {
++ put_info("\nPlease check if 'help tables' are loaded.\n", INFO_INFO);
++ goto err;
++ }
++ put_info(
++ "Please try to run 'help contents' for a list of all accessible "
++ "topics\n",
++ INFO_INFO);
++ }
++ }
++
++err:
++ mysql_free_result(result);
++ return error;
++}
++
++static int com_help(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ int i, j;
++ char *help_arg = strchr(line, ' '), buff[32], *end;
++ if (help_arg) {
++ while (my_isspace(charset_info, *help_arg)) help_arg++;
++ if (*help_arg) return com_server_help(buffer, line, help_arg);
++ }
++
++ put_info(
++ "\nFor information about MySQL products and services, visit:\n"
++ " http://www.mysql.com/\n"
++ "For developer information, including the MySQL Reference Manual, "
++ "visit:\n"
++ " http://dev.mysql.com/\n"
++ "To buy MySQL Enterprise support, training, or other products, visit:\n"
++ " https://shop.mysql.com/\n",
++ INFO_INFO);
++ put_info("List of all MySQL commands:", INFO_INFO);
++ if (!named_cmds)
++ put_info(
++ "Note that all text commands must be first on line and end with ';'",
++ INFO_INFO);
++ for (i = 0; commands[i].name; i++) {
++ end = my_stpcpy(buff, commands[i].name);
++ for (j = (int)strlen(commands[i].name); j < 10; j++)
++ end = my_stpcpy(end, " ");
++ if (commands[i].func) {
++ if (commands[i].cmd_char)
++ tee_fprintf(stdout, "%s(\\%c) %s\n", buff, commands[i].cmd_char,
++ commands[i].doc);
++ else
++ tee_fprintf(stdout, "%s %s\n", buff, commands[i].doc);
++ }
++ }
++ if (connected && mysql_get_server_version(&mysql) >= 40100)
++ put_info("\nFor server side help, type 'help contents'\n", INFO_INFO);
++ return 0;
++}
++
++/* ARGSUSED */
++static int com_clear(String *buffer, char *line [[maybe_unused]]) {
++ if (status.add_to_history) fix_line(buffer);
++ buffer->length(0);
++ return 0;
++}
++
++/* ARGSUSED */
++static int com_charset(String *buffer [[maybe_unused]], char *line) {
++ char buff[256], *param;
++ const CHARSET_INFO *new_cs;
++ strmake(buff, line, sizeof(buff) - 1);
++ param = get_arg(buff, false);
++ if (!param || !*param) {
++ return put_info("Usage: \\C charset_name | charset charset_name",
++ INFO_ERROR, 0);
++ }
++ new_cs = get_charset_by_csname(param, MY_CS_PRIMARY, MYF(MY_WME));
++ if (new_cs) {
++ charset_info = new_cs;
++ mysql_set_character_set(&mysql, charset_info->csname);
++ default_charset = charset_info->csname;
++ put_info("Charset changed", INFO_INFO);
++ } else
++ put_info("Charset is not found", INFO_INFO);
++ return 0;
++}
++
++/*
++ Execute command
++ Returns: 0 if ok
++ -1 if not fatal error
++ 1 if fatal error
++*/
++
++static int com_go(String *buffer, char *line [[maybe_unused]]) {
++ char buff[200]; /* about 110 chars used so far */
++ char time_buff[52 + 3 + 1]; /* time max + space&parens + NUL */
++ MYSQL_RES *result;
++ ulong timer, warnings = 0;
++ uint error = 0;
++ int err = 0;
++
++ interrupted_query = false;
++ if (!status.batch) {
++ old_buffer = *buffer; // Save for edit command
++ old_buffer.copy();
++ }
++
++ /* Remove garbage for nicer messages */
++ buff[0] = 0;
++ remove_cntrl(buffer);
++
++ if (buffer->is_empty()) {
++ if (status.batch) // Ignore empty quries
++ return 0;
++ return put_info("No query specified\n", INFO_ERROR);
++ }
++ if (!connected && reconnect()) {
++ buffer->length(0); // Remove query on error
++ return opt_reconnect ? -1 : 1; // Fatal error
++ }
++ if (verbose) (void)com_print(buffer, nullptr);
++
++ if (skip_updates && (buffer->length() < 4 ||
++ my_strnncoll(charset_info, (const uchar *)buffer->ptr(),
++ 4, (const uchar *)"SET ", 4))) {
++ (void)put_info("Ignoring query to other database", INFO_INFO);
++ return 0;
++ }
++
++ timer = start_timer();
++ executing_query = true;
++ error = mysql_real_query_for_lazy(buffer->ptr(), buffer->length(), true);
++
++ if (status.add_to_history) {
++ buffer->append(vertical ? "\\G" : delimiter);
++ /* Append final command onto history and syslog. */
++ fix_line(buffer);
++ }
++ buffer->length(0);
++
++ if (error) goto end;
++
++ do {
++ char *pos;
++ bool batchmode = (status.batch && verbose <= 1);
++ buff[0] = 0;
++
++ if (quick) {
++ if (!(result = mysql_use_result(&mysql)) && mysql_field_count(&mysql)) {
++ error = put_error(&mysql);
++ goto end;
++ }
++ } else {
++ error = mysql_store_result_for_lazy(&result);
++ if (error) goto end;
++ }
++
++ if (verbose >= 3 || !opt_silent)
++ mysql_end_timer(timer, time_buff);
++ else
++ time_buff[0] = '\0';
++
++ /* Every branch must truncate buff . */
++ if (result) {
++ if (!mysql_num_rows(result) && !quick && !column_types_flag) {
++ my_stpcpy(buff, "Empty set");
++ if (opt_xml) {
++ /*
++ We must print XML header and footer
++ to produce a well-formed XML even if
++ the result set is empty (Bug#27608).
++ */
++ init_pager();
++ print_table_data_xml(result);
++ end_pager();
++ }
++ } else {
++ init_pager();
++ if (opt_html)
++ print_table_data_html(result);
++ else if (opt_xml)
++ print_table_data_xml(result);
++ else if (vertical || (auto_vertical_output &&
++ (terminal_width < get_result_width(result))))
++ print_table_data_vertically(result);
++ else if (opt_silent && verbose <= 2 && !output_tables)
++ print_tab_data(result);
++ else
++ print_table_data(result);
++ if (!batchmode)
++ sprintf(buff, "%" PRId64 " %s in set", mysql_num_rows(result),
++ mysql_num_rows(result) == 1LL ? "row" : "rows");
++ end_pager();
++ if (mysql_errno(&mysql)) error = put_error(&mysql);
++ }
++ } else if (mysql_affected_rows(&mysql) == ~(ulonglong)0)
++ my_stpcpy(buff, "Query OK");
++ else if (!batchmode)
++ sprintf(buff, "Query OK, %" PRId64 " %s affected",
++ mysql_affected_rows(&mysql),
++ mysql_affected_rows(&mysql) == 1LL ? "row" : "rows");
++
++ pos = strend(buff);
++ if ((warnings = mysql_warning_count(&mysql)) && !batchmode) {
++ *pos++ = ',';
++ *pos++ = ' ';
++ pos = longlong10_to_str(warnings, pos, 10);
++ pos = my_stpcpy(pos, " warning");
++ if (warnings != 1) *pos++ = 's';
++ }
++ my_stpcpy(pos, time_buff);
++ put_info(buff, INFO_RESULT);
++ if (mysql_info(&mysql)) put_info(mysql_info(&mysql), INFO_RESULT);
++ put_info("", INFO_RESULT); // Empty row
++
++ if (result && !mysql_eof(result)) /* Something wrong when using quick */
++ error = put_error(&mysql);
++ else if (unbuffered)
++ fflush(stdout);
++ mysql_free_result(result);
++ } while (!(err = mysql_next_result(&mysql)));
++ if (err >= 1) error = put_error(&mysql);
++
++end:
++
++ /* Show warnings if any or error occurred */
++ if (show_warnings == 1 && (warnings >= 1 || error)) print_warnings();
++
++ if (!error && (mysql.server_status & SERVER_STATUS_DB_DROPPED))
++ get_current_db();
++
++ executing_query = false;
++ return error; /* New command follows */
++}
++
++static void init_pager() {
++#ifdef USE_POPEN
++ if (!opt_nopager) {
++ if (!(PAGER = popen(pager, "w"))) {
++ tee_fprintf(stdout, "popen() failed! defaulting PAGER to stdout!\n");
++ PAGER = stdout;
++ }
++ } else
++#endif
++ PAGER = stdout;
++}
++
++static void end_pager() {
++#ifdef USE_POPEN
++ if (!opt_nopager) pclose(PAGER);
++#endif
++}
++
++static void init_tee(const char *file_name) {
++ FILE *new_outfile;
++ if (opt_outfile) end_tee();
++ if (!(new_outfile = my_fopen(file_name, O_APPEND | O_WRONLY, MYF(MY_WME)))) {
++ tee_fprintf(stdout, "Error logging to file '%s'\n", file_name);
++ return;
++ }
++ OUTFILE = new_outfile;
++ strmake(outfile, file_name, FN_REFLEN - 1);
++ tee_fprintf(stdout, "Logging to file '%s'\n", file_name);
++ opt_outfile = true;
++ return;
++}
++
++static void end_tee() {
++ my_fclose(OUTFILE, MYF(0));
++ OUTFILE = nullptr;
++ opt_outfile = false;
++ return;
++}
++
++static int com_ego(String *buffer, char *line) {
++ int result;
++ bool oldvertical = vertical;
++ vertical = true;
++ result = com_go(buffer, line);
++ vertical = oldvertical;
++ return result;
++}
++
++const char *fieldtype2str(enum enum_field_types type);
++
++static char *fieldflags2str(uint f) {
++ static char buf[1024];
++ char *s = buf;
++ *s = 0;
++#define ff2s_check_flag(X) \
++ if (f & X##_FLAG) { \
++ s = my_stpcpy(s, #X " "); \
++ f &= ~X##_FLAG; \
++ }
++ ff2s_check_flag(NOT_NULL);
++ ff2s_check_flag(PRI_KEY);
++ ff2s_check_flag(UNIQUE_KEY);
++ ff2s_check_flag(MULTIPLE_KEY);
++ ff2s_check_flag(BLOB);
++ ff2s_check_flag(UNSIGNED);
++ ff2s_check_flag(ZEROFILL);
++ ff2s_check_flag(BINARY);
++ ff2s_check_flag(ENUM);
++ ff2s_check_flag(AUTO_INCREMENT);
++ ff2s_check_flag(TIMESTAMP);
++ ff2s_check_flag(SET);
++ ff2s_check_flag(NO_DEFAULT_VALUE);
++ ff2s_check_flag(NUM);
++ ff2s_check_flag(PART_KEY);
++ ff2s_check_flag(GROUP);
++ ff2s_check_flag(UNIQUE);
++ ff2s_check_flag(BINCMP);
++ ff2s_check_flag(ON_UPDATE_NOW);
++#undef ff2s_check_flag
++ if (f) sprintf(s, " unknows=0x%04x", f);
++ return buf;
++}
++
++static void print_field_types(MYSQL_RES *result) {
++ MYSQL_FIELD *field;
++ uint i = 0;
++
++ while ((field = mysql_fetch_field(result))) {
++ tee_fprintf(PAGER,
++ "Field %3u: `%s`\n"
++ "Catalog: `%s`\n"
++ "Database: `%s`\n"
++ "Table: `%s`\n"
++ "Org_table: `%s`\n"
++ "Type: %s\n"
++ "Collation: %s (%u)\n"
++ "Length: %lu\n"
++ "Max_length: %lu\n"
++ "Decimals: %u\n"
++ "Flags: %s\n\n",
++ ++i, field->name, field->catalog, field->db, field->table,
++ field->org_table, fieldtype2str(field->type),
++ get_collation_name(field->charsetnr), field->charsetnr,
++ field->length, field->max_length, field->decimals,
++ fieldflags2str(field->flags));
++ }
++ tee_puts("", PAGER);
++}
++
++/* Used to determine if we should invoke print_as_hex for this field */
++
++static bool is_binary_field(MYSQL_FIELD *field) {
++ if ((field->charsetnr == 63) &&
++ (field->type == MYSQL_TYPE_BIT || field->type == MYSQL_TYPE_BLOB ||
++ field->type == MYSQL_TYPE_LONG_BLOB ||
++ field->type == MYSQL_TYPE_MEDIUM_BLOB ||
++ field->type == MYSQL_TYPE_TINY_BLOB ||
++ field->type == MYSQL_TYPE_VAR_STRING ||
++ field->type == MYSQL_TYPE_STRING || field->type == MYSQL_TYPE_VARCHAR ||
++ field->type == MYSQL_TYPE_GEOMETRY))
++ return true;
++ return false;
++}
++
++/* Print binary value as hex literal (0x ...) */
++
++static void print_as_hex(FILE *output_file, const char *str, ulong len,
++ ulong total_bytes_to_send) {
++ const char *ptr = str, *end = ptr + len;
++ ulong i;
++
++ if (str != nullptr) {
++ fprintf(output_file, "0x");
++ for (; ptr < end; ptr++)
++ fprintf(output_file, "%02X",
++ *(static_cast<const uchar *>(static_cast<const void *>(ptr))));
++ /* Printed string length: two chars "0x" + two chars for each byte. */
++ i = 2 + len * 2;
++ } else {
++ i = fprintf(output_file, "NULL");
++ }
++ for (; i < total_bytes_to_send; i++)
++ tee_putc(static_cast<int>(' '), output_file);
++}
++
++static void print_table_data(MYSQL_RES *result) {
++ String separator(256);
++ MYSQL_ROW cur;
++ MYSQL_FIELD *field;
++ bool *num_flag;
++ size_t sz;
++
++ if (column_types_flag) {
++ print_field_types(result);
++ if (!mysql_num_rows(result)) return;
++ mysql_field_seek(result, 0);
++ }
++ sz = sizeof(bool) * mysql_num_fields(result);
++ num_flag = (bool *)my_safe_alloca(sz, MAX_ALLOCA_SIZE);
++ separator.copy("+", 1, charset_info);
++ while ((field = mysql_fetch_field(result))) {
++ size_t length = column_names ? field->name_length : 0;
++ if (quick)
++ length = max<size_t>(length, field->length);
++ else
++ length = max<size_t>(length, field->max_length);
++ if (length < 4 && !IS_NOT_NULL(field->flags))
++ length = 4; // Room for "NULL"
++ if (opt_binhex && is_binary_field(field)) length = 2 + length * 2;
++ field->max_length = (ulong)length;
++ separator.fill(separator.length() + length + 2, '-');
++ separator.append('+');
++ }
++ separator.append('\0'); // End marker for \0
++ tee_puts(separator.ptr(), PAGER);
++ if (column_names) {
++ mysql_field_seek(result, 0);
++ (void)tee_fputs("|", PAGER);
++ for (uint off = 0; (field = mysql_fetch_field(result)); off++) {
++ size_t name_length = strlen(field->name);
++ size_t numcells = charset_info->cset->numcells(charset_info, field->name,
++ field->name + name_length);
++ size_t display_length = field->max_length + name_length - numcells;
++ tee_fprintf(PAGER, " %-*s |",
++ min<int>((int)display_length, MAX_COLUMN_LENGTH),
++ field->name);
++ num_flag[off] = IS_NUM(field->type);
++ }
++ (void)tee_fputs("\n", PAGER);
++ tee_puts(separator.ptr(), PAGER);
++ }
++
++ while ((cur = mysql_fetch_row(result))) {
++ ulong *lengths = mysql_fetch_lengths(result);
++ (void)tee_fputs("| ", PAGER);
++ mysql_field_seek(result, 0);
++ for (uint off = 0; off < mysql_num_fields(result); off++) {
++ const char *buffer;
++ uint data_length;
++ uint field_max_length;
++ size_t visible_length;
++ uint extra_padding;
++
++ if (off) (void)tee_fputs(" ", PAGER);
++
++ if (cur[off] == nullptr) {
++ buffer = "NULL";
++ data_length = 4;
++ } else {
++ buffer = cur[off];
++ data_length = (uint)lengths[off];
++ }
++
++ field = mysql_fetch_field(result);
++ field_max_length = field->max_length;
++
++ /*
++ How many text cells on the screen will this string span? If it
++ contains multibyte characters, then the number of characters we occupy
++ on screen will be fewer than the number of bytes we occupy in memory.
++
++ We need to find how much screen real-estate we will occupy to know how
++ many extra padding-characters we should send with the printing
++ function.
++ */
++ visible_length = charset_info->cset->numcells(charset_info, buffer,
++ buffer + data_length);
++ extra_padding = (uint)(data_length - visible_length);
++
++ if (opt_binhex && is_binary_field(field))
++ print_as_hex(PAGER, cur[off], lengths[off], field_max_length);
++ else if (field_max_length > MAX_COLUMN_LENGTH)
++ tee_print_sized_data(buffer, data_length,
++ MAX_COLUMN_LENGTH + extra_padding, false);
++ else {
++ if (num_flag[off] != 0) /* if it is numeric, we right-justify it */
++ tee_print_sized_data(buffer, data_length,
++ field_max_length + extra_padding, true);
++ else
++ tee_print_sized_data(buffer, data_length,
++ field_max_length + extra_padding, false);
++ }
++ tee_fputs(" |", PAGER);
++ }
++ (void)tee_fputs("\n", PAGER);
++
++ // Check interrupted_query last; this ensures that we get at least one
++ // row. This is useful for aborted EXPLAIN ANALYZE queries.
++ if (interrupted_query) break;
++ }
++ tee_puts(separator.ptr(), PAGER);
++ my_safe_afree((bool *)num_flag, sz, MAX_ALLOCA_SIZE);
++}
++
++/**
++ Return the length of a field after it would be rendered into text.
++
++ This doesn't know or care about multibyte characters. Assume we're
++ using such a charset. We can't know that all of the upcoming rows
++ for this column will have bytes that each render into some fraction
++ of a character. It's at least possible that a row has bytes that
++ all render into one character each, and so the maximum length is
++ still the number of bytes. (Assumption 1: This can't be better
++ because we can never know the number of characters that the DB is
++ going to send -- only the number of bytes. 2: Chars <= Bytes.)
++
++ @param field Pointer to a field to be inspected
++
++ @returns number of character positions to be used, at most
++*/
++static int get_field_disp_length(MYSQL_FIELD *field) {
++ uint length = column_names ? field->name_length : 0;
++
++ if (quick)
++ length = max<uint>(length, field->length);
++ else
++ length = max<uint>(length, field->max_length);
++
++ if (length < 4 && !IS_NOT_NULL(field->flags))
++ length = 4; /* Room for "NULL" */
++
++ return length;
++}
++
++/**
++ For a new result, return the max number of characters that any
++ upcoming row may return.
++
++ @param result Pointer to the result to judge
++
++ @returns The max number of characters in any row of this result
++*/
++static int get_result_width(MYSQL_RES *result) {
++ unsigned int len = 0;
++ MYSQL_FIELD *field;
++ MYSQL_FIELD_OFFSET offset;
++
++#ifndef NDEBUG
++ offset = mysql_field_tell(result);
++ assert(offset == 0);
++#else
++ offset = 0;
++#endif
++
++ while ((field = mysql_fetch_field(result)) != nullptr)
++ len +=
++ get_field_disp_length(field) + 3; /* plus bar, space, & final space */
++
++ (void)mysql_field_seek(result, offset);
++
++ return len + 1; /* plus final bar. */
++}
++
++static void tee_print_sized_data(const char *data, unsigned int data_length,
++ unsigned int total_bytes_to_send,
++ bool right_justified) {
++ /*
++ For '\0's print ASCII spaces instead, as '\0' is eaten by (at
++ least my) console driver, and that messes up the pretty table
++ grid. (The \0 is also the reason we can't use fprintf() .)
++ */
++ unsigned int i;
++
++ if (right_justified)
++ for (i = data_length; i < total_bytes_to_send; i++)
++ tee_putc((int)' ', PAGER);
++
++ tee_write(PAGER, data, data_length, MY_PRINT_SPS_0 | MY_PRINT_MB);
++
++ if (!right_justified)
++ for (i = data_length; i < total_bytes_to_send; i++)
++ tee_putc((int)' ', PAGER);
++}
++
++static void print_table_data_html(MYSQL_RES *result) {
++ MYSQL_ROW cur;
++ MYSQL_FIELD *field;
++
++ mysql_field_seek(result, 0);
++ (void)tee_fputs("<TABLE BORDER=1><TR>", PAGER);
++ if (column_names) {
++ while ((field = mysql_fetch_field(result))) {
++ tee_fputs("<TH>", PAGER);
++ if (field->name && field->name[0])
++ xmlencode_print(field->name, field->name_length);
++ else
++ tee_fputs(field->name ? " " : "NULL", PAGER);
++ tee_fputs("</TH>", PAGER);
++ }
++ (void)tee_fputs("</TR>", PAGER);
++ }
++ while ((cur = mysql_fetch_row(result))) {
++ if (interrupted_query) break;
++ ulong *lengths = mysql_fetch_lengths(result);
++ field = mysql_fetch_fields(result);
++ (void)tee_fputs("<TR>", PAGER);
++ for (uint i = 0; i < mysql_num_fields(result); i++) {
++ (void)tee_fputs("<TD>", PAGER);
++ if (opt_binhex && is_binary_field(&field[i]))
++ print_as_hex(PAGER, cur[i], lengths[i], lengths[i]);
++ else
++ xmlencode_print(cur[i], lengths[i]);
++ (void)tee_fputs("</TD>", PAGER);
++ }
++ (void)tee_fputs("</TR>", PAGER);
++ }
++ (void)tee_fputs("</TABLE>", PAGER);
++}
++
++static void print_table_data_xml(MYSQL_RES *result) {
++ MYSQL_ROW cur;
++ MYSQL_FIELD *fields;
++
++ mysql_field_seek(result, 0);
++
++ tee_fputs("<?xml version=\"1.0\"?>\n\n<resultset statement=\"", PAGER);
++ xmlencode_print(glob_buffer.ptr(), (int)strlen(glob_buffer.ptr()));
++ tee_fputs("\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">",
++ PAGER);
++
++ fields = mysql_fetch_fields(result);
++ while ((cur = mysql_fetch_row(result))) {
++ if (interrupted_query) break;
++ ulong *lengths = mysql_fetch_lengths(result);
++ (void)tee_fputs("\n <row>\n", PAGER);
++ for (uint i = 0; i < mysql_num_fields(result); i++) {
++ tee_fprintf(PAGER, "\t<field name=\"");
++ xmlencode_print(fields[i].name, (uint)strlen(fields[i].name));
++ if (cur[i]) {
++ tee_fprintf(PAGER, "\">");
++ if (opt_binhex && is_binary_field(&fields[i]))
++ print_as_hex(PAGER, cur[i], lengths[i], lengths[i]);
++ else
++ xmlencode_print(cur[i], lengths[i]);
++ tee_fprintf(PAGER, "</field>\n");
++ } else
++ tee_fprintf(PAGER, "\" xsi:nil=\"true\" />\n");
++ }
++ (void)tee_fputs(" </row>\n", PAGER);
++ }
++ (void)tee_fputs("</resultset>\n", PAGER);
++}
++
++static void print_table_data_vertically(MYSQL_RES *result) {
++ MYSQL_ROW cur;
++ uint max_length = 0;
++ MYSQL_FIELD *field;
++
++ while ((field = mysql_fetch_field(result))) {
++ uint length = field->name_length;
++ if (length > max_length) max_length = length;
++ field->max_length = length;
++ }
++
++ mysql_field_seek(result, 0);
++ for (uint row_count = 1; (cur = mysql_fetch_row(result)); row_count++) {
++ if (interrupted_query) break;
++ mysql_field_seek(result, 0);
++ tee_fprintf(
++ PAGER,
++ "*************************** %d. row ***************************\n",
++ row_count);
++
++ ulong *lengths = mysql_fetch_lengths(result);
++
++ for (uint off = 0; off < mysql_num_fields(result); off++) {
++ field = mysql_fetch_field(result);
++ if (column_names)
++ tee_fprintf(PAGER, "%*s: ", (int)max_length, field->name);
++ if (cur[off]) {
++ if (opt_binhex && is_binary_field(field))
++ print_as_hex(PAGER, cur[off], lengths[off], lengths[off]);
++ else
++ tee_write(PAGER, cur[off], lengths[off],
++ MY_PRINT_SPS_0 | MY_PRINT_MB);
++ tee_putc('\n', PAGER);
++ } else
++ tee_fprintf(PAGER, "NULL\n");
++ }
++ }
++}
++
++/* print_warnings should be called right after executing a statement */
++
++static void print_warnings() {
++ const char *query;
++ MYSQL_RES *result;
++ MYSQL_ROW cur;
++ uint64_t num_rows;
++
++ /* Save current error before calling "show warnings" */
++ uint error = mysql_errno(&mysql);
++
++ /* Get the warnings */
++ query = "show warnings";
++ mysql_real_query_for_lazy(query, strlen(query));
++ mysql_store_result_for_lazy(&result);
++
++ /* Bail out when no warnings */
++ if (!result || !(num_rows = mysql_num_rows(result))) goto end;
++
++ cur = mysql_fetch_row(result);
++
++ /*
++ Don't print a duplicate of the current error. It is possible for SHOW
++ WARNINGS to return multiple errors with the same code, but different
++ messages. To be safe, skip printing the duplicate only if it is the only
++ warning.
++ */
++ if (!cur || (num_rows == 1 && error == (uint)strtoul(cur[1], nullptr, 10)))
++ goto end;
++
++ /* Print the warnings */
++ init_pager();
++ do {
++ tee_fprintf(PAGER, "%s (Code %s): %s\n", cur[0], cur[1], cur[2]);
++ } while ((cur = mysql_fetch_row(result)));
++ end_pager();
++
++end:
++ mysql_free_result(result);
++}
++
++static const char *array_value(const char **array, char key) {
++ for (; *array; array += 2)
++ if (**array == key) return array[1];
++ return nullptr;
++}
++
++static void xmlencode_print(const char *src, uint length) {
++ if (!src)
++ tee_fputs("NULL", PAGER);
++ else
++ tee_write(PAGER, src, length, MY_PRINT_XML | MY_PRINT_MB);
++}
++
++static void safe_put_field(const char *pos, ulong length) {
++ if (!pos)
++ tee_fputs("NULL", PAGER);
++ else {
++ int flags =
++ MY_PRINT_MB | (opt_raw_data ? 0 : (MY_PRINT_ESC_0 | MY_PRINT_CTRL));
++ /* Can't use tee_fputs(), it stops with NUL characters. */
++ tee_write(PAGER, pos, length, flags);
++ }
++}
++
++static void print_tab_data(MYSQL_RES *result) {
++ MYSQL_ROW cur;
++ MYSQL_FIELD *field;
++ ulong *lengths;
++
++ if (opt_silent < 2 && column_names) {
++ int first = 0;
++ while ((field = mysql_fetch_field(result))) {
++ if (first++) (void)tee_fputs("\t", PAGER);
++ (void)tee_fputs(field->name, PAGER);
++ }
++ (void)tee_fputs("\n", PAGER);
++ }
++ while ((cur = mysql_fetch_row(result))) {
++ lengths = mysql_fetch_lengths(result);
++ field = mysql_fetch_fields(result);
++ if (opt_binhex && is_binary_field(&field[0]))
++ print_as_hex(PAGER, cur[0], lengths[0], lengths[0]);
++ else
++ safe_put_field(cur[0], lengths[0]);
++ for (uint off = 1; off < mysql_num_fields(result); off++) {
++ (void)tee_fputs("\t", PAGER);
++ if (opt_binhex && field && is_binary_field(&field[off]))
++ print_as_hex(PAGER, cur[off], lengths[off], lengths[off]);
++ else
++ safe_put_field(cur[off], lengths[off]);
++ }
++ (void)tee_fputs("\n", PAGER);
++ }
++}
++
++static int com_tee(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ char file_name[FN_REFLEN], *end, *param;
++
++ while (my_isspace(charset_info, *line)) line++;
++ if (!(param = strchr(line, ' '))) // if outfile wasn't given, use the default
++ {
++ if (!strlen(outfile)) {
++ printf("No previous outfile available, you must give a filename!\n");
++ return 0;
++ } else if (opt_outfile) {
++ tee_fprintf(stdout, "Currently logging to file '%s'\n", outfile);
++ return 0;
++ } else
++ param = outfile; // resume using the old outfile
++ }
++
++ /* eliminate the spaces before the parameters */
++ while (my_isspace(charset_info, *param)) param++;
++ end = strmake(file_name, param, sizeof(file_name) - 1);
++ /* remove end space from command line */
++ while (end > file_name && (my_isspace(charset_info, end[-1]) ||
++ my_iscntrl(charset_info, end[-1])))
++ end--;
++ end[0] = 0;
++ if (end == file_name) {
++ printf("No outfile specified!\n");
++ return 0;
++ }
++ init_tee(file_name);
++ return 0;
++}
++
++static int com_notee(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ if (opt_outfile) end_tee();
++ tee_fprintf(stdout, "Outfile disabled.\n");
++ return 0;
++}
++
++/*
++ Sorry, this command is not available in Windows.
++*/
++
++#ifdef USE_POPEN
++static int com_pager(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ char pager_name[FN_REFLEN], *end, *param;
++
++ if (status.batch) return 0;
++ /* Skip spaces in front of the pager command */
++ while (my_isspace(charset_info, *line)) line++;
++ /* Skip the pager command */
++ param = strchr(line, ' ');
++ /* Skip the spaces between the command and the argument */
++ while (param && my_isspace(charset_info, *param)) param++;
++ if (!param || !strlen(param)) // if pager was not given, use the default
++ {
++ if (!default_pager_set) {
++ tee_fprintf(stdout, "Default pager wasn't set, using stdout.\n");
++ opt_nopager = true;
++ my_stpcpy(pager, "stdout");
++ PAGER = stdout;
++ return 0;
++ }
++ my_stpcpy(pager, default_pager);
++ } else {
++ end = strmake(pager_name, param, sizeof(pager_name) - 1);
++ while (end > pager_name && (my_isspace(charset_info, end[-1]) ||
++ my_iscntrl(charset_info, end[-1])))
++ end--;
++ end[0] = 0;
++ my_stpcpy(pager, pager_name);
++ my_stpcpy(default_pager, pager_name);
++ }
++ opt_nopager = false;
++ tee_fprintf(stdout, "PAGER set to '%s'\n", pager);
++ return 0;
++}
++
++static int com_nopager(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ my_stpcpy(pager, "stdout");
++ opt_nopager = true;
++ PAGER = stdout;
++ tee_fprintf(stdout, "PAGER set to stdout\n");
++ return 0;
++}
++#endif
++
++/*
++ Sorry, you can't send the result to an editor in Win32
++*/
++
++#ifdef USE_POPEN
++static int com_edit(String *buffer, char *line [[maybe_unused]]) {
++ char filename[FN_REFLEN], buff[160];
++ int fd, tmp;
++ const char *editor;
++
++ if ((fd = create_temp_file(filename, NullS, "sql", O_CREAT | O_WRONLY,
++ KEEP_FILE, MYF(MY_WME))) < 0)
++ goto err;
++ if (buffer->is_empty() && !old_buffer.is_empty())
++ (void)my_write(fd, (uchar *)old_buffer.ptr(), old_buffer.length(),
++ MYF(MY_WME));
++ else
++ (void)my_write(fd, (uchar *)buffer->ptr(), buffer->length(), MYF(MY_WME));
++ (void)my_close(fd, MYF(0));
++
++ if (!(editor = (char *)getenv("EDITOR")) &&
++ !(editor = (char *)getenv("VISUAL")))
++ editor = "vi";
++ strxmov(buff, editor, " ", filename, NullS);
++ if (system(buff) == -1) goto err;
++
++ MY_STAT stat_arg;
++ if (!my_stat(filename, &stat_arg, MYF(MY_WME))) goto err;
++ if ((fd = my_open(filename, O_RDONLY, MYF(MY_WME))) < 0) goto err;
++ (void)buffer->alloc((uint)stat_arg.st_size);
++ if ((tmp = read(fd, buffer->ptr(), buffer->alloced_length())) >= 0L)
++ buffer->length((uint)tmp);
++ else
++ buffer->length(0);
++ (void)my_close(fd, MYF(0));
++ (void)my_delete(filename, MYF(MY_WME));
++err:
++ return 0;
++}
++#endif
++
++/* If arg is given, exit without errors. This happens on command 'quit' */
++
++static int com_quit(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ status.exit_status = 0;
++ return 1;
++}
++
++static int com_rehash(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++#ifdef HAVE_READLINE
++ build_completion_hash(true, false);
++#endif
++ return 0;
++}
++
++static int com_shell(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ char *shell_cmd;
++
++ /* Skip space from line begin */
++ while (my_isspace(charset_info, *line)) line++;
++ if (!(shell_cmd = strchr(line, ' '))) {
++ put_info("Usage: \\! shell-command", INFO_ERROR);
++ return -1;
++ }
++
++ if (!opt_system_command) {
++ return put_info(
++ "'system' command received, but the --system-command option is off. "
++ "Skipping.",
++ INFO_ERROR);
++ }
++ /*
++ The output of the shell command does not
++ get directed to the pager or the outfile
++ */
++ if (system(shell_cmd) == -1) {
++ put_info(strerror(errno), INFO_ERROR, errno);
++ return -1;
++ }
++ return 0;
++}
++
++static int com_print(String *buffer, char *line [[maybe_unused]]) {
++ tee_puts("--------------", stdout);
++ (void)tee_fputs(buffer->c_ptr(), stdout);
++ if (!buffer->length() || (*buffer)[buffer->length() - 1] != '\n')
++ tee_putc('\n', stdout);
++ tee_puts("--------------\n", stdout);
++ return 0; /* If empty buffer */
++}
++
++/* ARGSUSED */
++static int com_connect(String *buffer, char *line) {
++ char *tmp, buff[256];
++ bool save_rehash = opt_rehash;
++ int error;
++
++ memset(buff, 0, sizeof(buff));
++ if (buffer) {
++ /*
++ Two null bytes are needed in the end of buff to allow
++ get_arg to find end of string the second time it's called.
++ */
++ tmp = strmake(buff, line, sizeof(buff) - 2);
++#ifdef EXTRA_DEBUG
++ tmp[1] = 0;
++#endif
++ tmp = get_arg(buff, false);
++ if (tmp && *tmp) {
++ my_free(current_db);
++ current_db = my_strdup(PSI_NOT_INSTRUMENTED, tmp, MYF(MY_WME));
++ tmp = get_arg(buff, true);
++ if (tmp) {
++ my_free(current_host);
++ current_host = my_strdup(PSI_NOT_INSTRUMENTED, tmp, MYF(MY_WME));
++ my_free(dns_srv_name);
++ dns_srv_name = nullptr;
++ }
++ } else {
++ /* Quick re-connect */
++ opt_rehash = false; /* purecov: tested */
++ }
++ buffer->length(0); // command used
++ } else
++ opt_rehash = false;
++ error = sql_connect(current_host, current_db, current_user, 0);
++ opt_rehash = save_rehash;
++
++ if (connected) {
++ sprintf(buff, "Connection id: %lu", mysql_thread_id(&mysql));
++ put_info(buff, INFO_INFO);
++ sprintf(buff, "Current database: %.128s\n",
++ current_db ? current_db : "*** NONE ***");
++ put_info(buff, INFO_INFO);
++ }
++ return error;
++}
++
++static int com_source(String *buffer [[maybe_unused]], char *line) {
++ char source_name[FN_REFLEN], *end, *param;
++ LINE_BUFFER *line_buff;
++ int error;
++ STATUS old_status;
++ FILE *sql_file;
++
++ /* Skip space from file name */
++ while (my_isspace(charset_info, *line)) line++;
++ if (!(param = strchr(line, ' '))) // Skip command name
++ return put_info("Usage: \\. <filename> | source <filename>", INFO_ERROR, 0);
++ while (my_isspace(charset_info, *param)) param++;
++ end = strmake(source_name, param, sizeof(source_name) - 1);
++ while (end > source_name && (my_isspace(charset_info, end[-1]) ||
++ my_iscntrl(charset_info, end[-1])))
++ end--;
++ end[0] = 0;
++ unpack_filename(source_name, source_name);
++ /* open file name */
++ if (!(sql_file = my_fopen(source_name, O_RDONLY | MY_FOPEN_BINARY, MYF(0)))) {
++ char buff[FN_REFLEN + 60];
++ sprintf(buff, "Failed to open file '%s', error: %d", source_name, errno);
++ return put_info(buff, INFO_ERROR, 0);
++ }
++
++ if (!(line_buff = batch_readline_init(MAX_BATCH_BUFFER_SIZE, sql_file))) {
++ my_fclose(sql_file, MYF(0));
++ return put_info("Can't initialize batch_readline", INFO_ERROR, 0);
++ }
++
++ /* Save old status */
++ old_status = status;
++ memset(&status, 0, sizeof(status));
++
++ status.batch = old_status.batch; // Run in batch mode
++ status.line_buff = line_buff;
++ status.file_name = source_name;
++ glob_buffer.length(0); // Empty command buffer
++ error = read_and_execute(false);
++ status = old_status; // Continue as before
++ my_fclose(sql_file, MYF(0));
++ batch_readline_end(line_buff);
++ return error;
++}
++
++/* ARGSUSED */
++static int com_delimiter(String *buffer [[maybe_unused]], char *line) {
++ char buff[256], *tmp;
++
++ strmake(buff, line, sizeof(buff) - 1);
++ tmp = get_arg(buff, false);
++
++ if (!tmp || !*tmp) {
++ put_info("DELIMITER must be followed by a 'delimiter' character or string",
++ INFO_ERROR);
++ return 0;
++ } else {
++ if (strstr(tmp, "\\")) {
++ put_info("DELIMITER cannot contain a backslash character", INFO_ERROR);
++ return 0;
++ }
++ }
++ strmake(delimiter, tmp, sizeof(delimiter) - 1);
++ delimiter_length = (int)strlen(delimiter);
++ delimiter_str = delimiter;
++ return 0;
++}
++
++/* ARGSUSED */
++static int com_use(String *buffer [[maybe_unused]], char *line) {
++ char *tmp, buff[FN_REFLEN + 1];
++ int select_db;
++ uint warnings;
++
++ memset(buff, 0, sizeof(buff));
++
++ /*
++ In case of quotes used, try to get the normalized db name.
++ */
++ if (get_quote_count(line) > 0) {
++ if (normalize_dbname(line, buff, sizeof(buff))) return put_error(&mysql);
++ tmp = buff;
++ } else {
++ strmake(buff, line, sizeof(buff) - 1);
++ tmp = get_arg(buff, false);
++ }
++
++ if (!tmp || !*tmp) {
++ put_info("USE must be followed by a database name", INFO_ERROR);
++ return 0;
++ }
++ /*
++ We need to recheck the current database, because it may change
++ under our feet, for example if DROP DATABASE or RENAME DATABASE
++ (latter one not yet available by the time the comment was written)
++ If this command fails we assume we lost connection.
++ */
++ if (get_current_db()) connected = false;
++
++ if (!current_db || cmp_database(charset_info, current_db, tmp)) {
++ if (one_database) {
++ skip_updates = true;
++ select_db = 0; // don't do mysql_select_db()
++ } else
++ select_db = 2; // do mysql_select_db() and build_completion_hash()
++ } else {
++ /*
++ USE to the current db specified.
++ We do need to send mysql_select_db() to make server
++ update database level privileges, which might
++ change since last USE (see bug#10979).
++ For performance purposes, we'll skip rebuilding of completion hash.
++ */
++ skip_updates = false;
++ select_db = 1; // do only mysql_select_db(), without completion
++ }
++
++ if (select_db) {
++ /*
++ reconnect once if connection is down or if connection was found to
++ be down during query
++ */
++ if (!connected && reconnect())
++ return opt_reconnect ? -1 : 1; // Fatal error
++ if (mysql_select_db(&mysql, tmp)) {
++ if (mysql_errno(&mysql) != CR_SERVER_GONE_ERROR) return put_error(&mysql);
++
++ if (reconnect()) return opt_reconnect ? -1 : 1; // Fatal error
++ if (mysql_select_db(&mysql, tmp)) return put_error(&mysql);
++ }
++ my_free(current_db);
++ current_db = my_strdup(PSI_NOT_INSTRUMENTED, tmp, MYF(MY_WME));
++#ifdef HAVE_READLINE
++ if (select_db > 1) build_completion_hash(opt_rehash, true);
++#endif
++ }
++
++ if (0 < (warnings = mysql_warning_count(&mysql))) {
++ snprintf(buff, sizeof(buff), "Database changed, %u warning%s", warnings,
++ warnings > 1 ? "s" : "");
++ put_info(buff, INFO_INFO);
++ if (show_warnings == 1) print_warnings();
++ } else
++ put_info("Database changed", INFO_INFO);
++ return 0;
++}
++
++/**
++ Normalize database name.
++
++ @param [in] line The command.
++ @param [out] buff Normalized db name.
++ @param [in] buff_size Buffer size.
++
++ @return Operation status
++ @retval 0 Success
++ @retval 1 Failure
++
++ @note Sometimes server normalizes the database names
++ & APIs like mysql_select_db() expect normalized
++ database names. Since it is difficult to perform
++ the name conversion/normalization on the client
++ side, this function tries to get the normalized
++ dbname (indirectly) from the server.
++*/
++
++static int normalize_dbname(const char *line, char *buff, uint buff_size) {
++ MYSQL_RES *res = nullptr;
++
++ /* Send the "USE db" command to the server. */
++ if (mysql_query(&mysql, line)) return 1;
++
++ /*
++ Now, get the normalized database name and store it
++ into the buff.
++ */
++ if (!mysql_query(&mysql, "SELECT DATABASE()") &&
++ (res = mysql_use_result(&mysql))) {
++ MYSQL_ROW row = mysql_fetch_row(res);
++ if (row && row[0]) {
++ size_t len = strlen(row[0]);
++ /* Make sure there is enough room to store the dbname. */
++ if ((len > buff_size) || !memcpy(buff, row[0], len)) {
++ mysql_free_result(res);
++ return 1;
++ }
++ }
++ mysql_free_result(res);
++ }
++
++ /* Restore the original database. */
++ if (current_db && mysql_select_db(&mysql, current_db)) return 1;
++
++ return 0;
++}
++
++static int com_warnings(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ show_warnings = true;
++ put_info("Show warnings enabled.", INFO_INFO);
++ return 0;
++}
++
++static int com_nowarnings(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ show_warnings = false;
++ put_info("Show warnings disabled.", INFO_INFO);
++ return 0;
++}
++
++static int com_query_attributes(String *buffer [[maybe_unused]], char *line) {
++ char buff[1024], *param, name[1024];
++ memset(buff, 0, sizeof(buff));
++ strmake(buff, line, sizeof(buff) - 1);
++ param = buff;
++ global_attrs->clear(connected ? &mysql : nullptr);
++ do {
++ param = get_arg(param, param != buff);
++ if (!param || !*param) break;
++
++ strncpy(name, param, sizeof(name) - 1);
++ param = get_arg(param, true);
++ if (!param || !*param) {
++ return put_info("Usage: query_attributes name1 value1 name2 value2 ...",
++ INFO_ERROR, 0);
++ }
++
++ if (global_attrs->push_param(name, param))
++ return put_info("Failed to push a parameter", INFO_ERROR, 0);
++ } while (param != nullptr);
++ return 0;
++}
++
++static int com_ssl_session_data_print(String *buffer [[maybe_unused]],
++ char *line) {
++ char msgbuf[256];
++ char *param = get_arg(line, false);
++ const char *err_text = nullptr;
++ FILE *fo = nullptr;
++ void *data = nullptr;
++
++ if (param) {
++ if (nullptr == (fo = fopen(param, "w"))) {
++ err_text = "Failed to open the output file";
++ goto end;
++ }
++ } else
++ fo = stdout;
++
++ data = mysql_get_ssl_session_data(&mysql, 0, nullptr);
++ if (!data) {
++ err_text = nullptr;
++ put_error(&mysql);
++ goto end;
++ }
++ if (0 > fputs(reinterpret_cast<char *>(data), fo)) {
++ snprintf(msgbuf, sizeof(msgbuf), "Write of session data failed: %d (%s)",
++ errno, strerror(errno));
++ err_text = &msgbuf[0];
++ goto end;
++ }
++ if (fo == stdout) fputs("\n", fo);
++
++end:
++ if (data) mysql_free_ssl_session_data(&mysql, data);
++ if (fo && fo != stdout) fclose(fo);
++ if (err_text) return put_info(err_text, INFO_ERROR);
++ return 0;
++}
++
++/*
++ Gets argument from a command on the command line. If get_next_arg is
++ not defined, skips the command and returns the first argument. The
++ line is modified by adding zero to the end of the argument. If
++ get_next_arg is defined, then the function searches for end of string
++ first, after found, returns the next argument and adds zero to the
++ end. If you ever wish to use this feature, remember to initialize all
++ items in the array to zero first.
++*/
++
++char *get_arg(char *line, bool get_next_arg) {
++ char *ptr, *start;
++ bool quoted = false, valid_arg = false;
++ char qtype = 0;
++
++ ptr = line;
++ if (get_next_arg) {
++ for (; *ptr; ptr++)
++ ;
++ if (*(ptr + 1)) ptr++;
++ } else {
++ /* skip leading white spaces */
++ while (my_isspace(charset_info, *ptr)) ptr++;
++ if (*ptr == '\\') // short command was used
++ ptr += 2;
++ else
++ while (*ptr && !my_isspace(charset_info, *ptr)) // skip command
++ ptr++;
++ }
++ if (!*ptr) return NullS;
++ while (my_isspace(charset_info, *ptr)) ptr++;
++ if (*ptr == '\'' || *ptr == '\"' || *ptr == '`') {
++ qtype = *ptr;
++ quoted = true;
++ ptr++;
++ }
++ for (start = ptr; *ptr; ptr++) {
++ // if it is a quoted string do not remove backslash
++ if (!quoted && *ptr == '\\' && ptr[1]) // escaped character
++ {
++ // Remove the backslash
++ my_stpmov(ptr, ptr + 1);
++ } else if ((!quoted && *ptr == ' ') || (quoted && *ptr == qtype)) {
++ *ptr = 0;
++ break;
++ }
++ }
++ valid_arg = ptr != start;
++ return valid_arg ? start : NullS;
++}
++
++/*
++ Number of quotes present in the command's argument.
++*/
++static int get_quote_count(const char *line) {
++ int quote_count = 0;
++ const char *quote = line;
++
++ while ((quote = strpbrk(quote, "'`\"")) != nullptr) {
++ quote_count++;
++ quote++;
++ }
++
++ return quote_count;
++}
++
++static int sql_real_connect(char *host, char *database, char *user, char *,
++ uint silent) {
++ if (connected) {
++ connected = false;
++#ifdef HAVE_SETNS
++ if (opt_network_namespace) (void)release_network_namespace_resources();
++#endif
++ mysql_close(&mysql);
++ }
++
++ mysql_init(&mysql);
++ if (init_connection_options(&mysql)) {
++ put_error_if_any(&mysql);
++ (void)fflush(stdout);
++ return ignore_errors ? -1 : 1;
++ }
++#ifdef _WIN32
++ uint cnv_errors;
++ String converted_database, converted_user;
++ if (!my_charset_same(&my_charset_utf8mb4_bin, mysql.charset)) {
++ /* Convert user and database from UTF8MB4 to connection character set */
++ if (user) {
++ converted_user.copy(user, strlen(user) + 1, &my_charset_utf8mb4_bin,
++ mysql.charset, &cnv_errors);
++ user = (char *)converted_user.ptr();
++ }
++ if (database) {
++ converted_database.copy(database, strlen(database) + 1,
++ &my_charset_utf8mb4_bin, mysql.charset,
++ &cnv_errors);
++ database = (char *)converted_database.ptr();
++ }
++ }
++#endif
++
++#ifdef HAVE_SETNS
++ if (opt_network_namespace && set_network_namespace(opt_network_namespace)) {
++ if (!silent) {
++ char msgbuf[PATH_MAX];
++ snprintf(msgbuf, sizeof(msgbuf), "Network namespace error: %s",
++ strerror(errno));
++ put_info(msgbuf, INFO_ERROR);
++ }
++
++ return ignore_errors ? -1 : 1; // Abort
++ }
++#endif
++ MYSQL *ret;
++ if (dns_srv_name)
++ ret = mysql_real_connect_dns_srv(&mysql, dns_srv_name, user, nullptr,
++ database,
++ connect_flag | CLIENT_MULTI_STATEMENTS);
++ else
++ ret = mysql_real_connect(&mysql, host, user, nullptr, database,
++ opt_mysql_port, opt_mysql_unix_port,
++ connect_flag | CLIENT_MULTI_STATEMENTS);
++ if (!ret) {
++#ifdef HAVE_SETNS
++ if (opt_network_namespace) (void)restore_original_network_namespace();
++#endif
++ if (mysql_errno(&mysql) == ER_MUST_CHANGE_PASSWORD_LOGIN) {
++ tee_fprintf(stdout,
++ "Please use --connect-expired-password option or "
++ "invoke mysql in interactive mode.\n");
++ return ignore_errors ? -1 : 1;
++ }
++ if (!silent || (mysql_errno(&mysql) != CR_CONN_HOST_ERROR &&
++ mysql_errno(&mysql) != CR_CONNECTION_ERROR)) {
++ (void)put_error(&mysql);
++ (void)fflush(stdout);
++ return ignore_errors ? -1 : 1; // Abort
++ }
++ return -1; // Retryable
++ }
++
++ /* do user registration */
++ if (opt_fido_register_factor) {
++ char errmsg[FN_REFLEN];
++ if (user_device_registration(&mysql, opt_fido_register_factor, errmsg)) {
++ put_info(errmsg, INFO_ERROR);
++ return 1;
++ }
++ }
++
++#ifdef HAVE_SETNS
++ if (opt_network_namespace && restore_original_network_namespace()) {
++ if (!silent) {
++ char msgbuf[PATH_MAX];
++ snprintf(msgbuf, sizeof(msgbuf), "Network namespace error: %s",
++ strerror(errno));
++ put_info(msgbuf, INFO_ERROR);
++ }
++
++ return ignore_errors ? -1 : 1; // Abort
++ }
++#endif
++
++ if (ssl_client_check_post_connect_ssl_setup(
++ &mysql, [](const char *err) { put_info(err, INFO_ERROR); }))
++ return 1;
++
++ void *new_ssl_session_data = mysql_get_ssl_session_data(&mysql, 0, nullptr);
++ if (new_ssl_session_data != nullptr) {
++ if (ssl_session_data != nullptr)
++ mysql_free_ssl_session_data(&mysql, ssl_session_data);
++ ssl_session_data = new_ssl_session_data;
++ } else {
++ DBUG_PRINT("error", ("unable to save SSL session"));
++ }
++#ifdef _WIN32
++ /* Convert --execute buffer from UTF8MB4 to connection character set */
++ if (!execute_buffer_conversion_done && status.line_buff &&
++ !status.line_buff->file && /* Convert only -e buffer, not real file */
++ status.line_buff->buffer < status.line_buff->end && /* Non-empty */
++ !my_charset_same(&my_charset_utf8mb4_bin, mysql.charset)) {
++ String tmp;
++ size_t len = status.line_buff->end - status.line_buff->buffer;
++ uint dummy_errors;
++ /*
++ Don't convert trailing '\n' character - it was appended during
++ last batch_readline_command() call.
++ Otherwise we'll get an extra line, which makes some tests fail.
++ */
++ if (status.line_buff->buffer[len - 1] == '\n') len--;
++ if (tmp.copy(status.line_buff->buffer, len, &my_charset_utf8mb4_bin,
++ mysql.charset, &dummy_errors))
++ return 1;
++
++ /* Free the old line buffer */
++ batch_readline_end(status.line_buff);
++
++ /* Re-initialize line buffer from the converted string */
++ if (!(status.line_buff = batch_readline_command(nullptr, tmp.c_ptr_safe())))
++ return 1;
++ }
++ execute_buffer_conversion_done = true;
++#endif /* _WIN32 */
++
++ charset_info = mysql.charset;
++
++ connected = true;
++ mysql.reconnect = debug_info_flag; // We want to know if this happens
++#ifdef HAVE_READLINE
++ build_completion_hash(opt_rehash, true);
++#endif
++ return 0;
++}
++
++/* Initialize options for the given connection handle. */
++static bool init_connection_options(MYSQL *mysql) {
++ bool handle_expired = (opt_connect_expired_password || !status.batch);
++
++ if (opt_init_command)
++ mysql_options(mysql, MYSQL_INIT_COMMAND, opt_init_command);
++
++ if (opt_connect_timeout) {
++ uint timeout = opt_connect_timeout;
++ mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (char *)&timeout);
++ }
++
++ if (opt_bind_addr) mysql_options(mysql, MYSQL_OPT_BIND, opt_bind_addr);
++
++ if (opt_compress) mysql_options(mysql, MYSQL_OPT_COMPRESS, NullS);
++ if (opt_compress_algorithm)
++ mysql_options(mysql, MYSQL_OPT_COMPRESSION_ALGORITHMS,
++ opt_compress_algorithm);
++
++ mysql_options(mysql, MYSQL_OPT_ZSTD_COMPRESSION_LEVEL,
++ &opt_zstd_compress_level);
++
++ if (using_opt_local_infile)
++ mysql_options(mysql, MYSQL_OPT_LOCAL_INFILE, (char *)&opt_local_infile);
++
++ if (SSL_SET_OPTIONS(mysql)) {
++ tee_fprintf(stdout, "%s", SSL_SET_OPTIONS_ERROR);
++ return true;
++ }
++
++ if (ssl_session_data)
++ mysql_options(mysql, MYSQL_OPT_SSL_SESSION_DATA, ssl_session_data);
++
++ if (opt_protocol)
++ mysql_options(mysql, MYSQL_OPT_PROTOCOL, (char *)&opt_protocol);
++
++#if defined(_WIN32)
++ if (shared_memory_base_name)
++ mysql_options(mysql, MYSQL_SHARED_MEMORY_BASE_NAME,
++ shared_memory_base_name);
++#endif
++
++ if (safe_updates) {
++ char init_command[100];
++ sprintf(init_command,
++ "SET SQL_SAFE_UPDATES=1,SQL_SELECT_LIMIT=%lu,MAX_JOIN_SIZE=%lu",
++ select_limit, max_join_size);
++ mysql_options(mysql, MYSQL_INIT_COMMAND, init_command);
++ }
++
++ if (mysql_set_character_set(mysql, default_charset)) return true;
++
++ if (opt_plugin_dir && *opt_plugin_dir)
++ mysql_options(mysql, MYSQL_PLUGIN_DIR, opt_plugin_dir);
++
++ if (opt_load_data_local_dir &&
++ mysql_options(mysql, MYSQL_OPT_LOAD_DATA_LOCAL_DIR,
++ opt_load_data_local_dir))
++ return true;
++
++ if (opt_default_auth && *opt_default_auth)
++ mysql_options(mysql, MYSQL_DEFAULT_AUTH, opt_default_auth);
++
++ set_server_public_key(mysql);
++
++ set_get_server_public_key_option(mysql);
++
++ if (using_opt_enable_cleartext_plugin)
++ mysql_options(mysql, MYSQL_ENABLE_CLEARTEXT_PLUGIN,
++ (char *)&opt_enable_cleartext_plugin);
++
++ mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_RESET, nullptr);
++ mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "program_name", "mysql");
++ if (current_os_user)
++ mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "os_user",
++ current_os_user);
++ if (current_os_sudouser)
++ mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "os_sudouser",
++ current_os_sudouser);
++
++ mysql_options(mysql, MYSQL_OPT_CAN_HANDLE_EXPIRED_PASSWORDS, &handle_expired);
++
++ set_password_options(mysql);
++
++ struct st_mysql_client_plugin *oci_iam_plugin = mysql_client_find_plugin(
++ mysql, "authentication_oci_client", MYSQL_CLIENT_AUTHENTICATION_PLUGIN);
++
++ /* set authentication_oci_client config profile option if required */
++ if (opt_authentication_oci_client_config_profile != nullptr) {
++ if (!oci_iam_plugin) {
++ put_info("Cannot load the authentication_oci_client plugin.", INFO_ERROR);
++ return true;
++ }
++ if (mysql_plugin_options(oci_iam_plugin,
++ "authentication-oci-client-config-profile",
++ opt_authentication_oci_client_config_profile)) {
++ put_info(
++ "Failed to set config profile for authentication_oci_client "
++ "plugin.",
++ INFO_ERROR);
++ return true;
++ }
++ }
++ /* set OCI config file option if required */
++ if (opt_oci_config_file != nullptr) {
++ if (!oci_iam_plugin) {
++ put_info("Cannot load the authentication_oci_client plugin.", INFO_ERROR);
++ return true;
++ }
++ if (mysql_plugin_options(oci_iam_plugin, "oci-config-file",
++ opt_oci_config_file)) {
++ put_info(
++ "Failed to set config file for authentication_oci_client plugin.",
++ INFO_ERROR);
++ return true;
++ }
++ }
++
++#if defined(_WIN32)
++ char error[256]{0};
++ if (set_authentication_kerberos_client_mode(mysql, error, 255)) {
++ put_info(error, INFO_ERROR);
++ return 1;
++ }
++#endif
++
++ return false;
++}
++
++static int sql_connect(char *host, char *database, char *user, uint silent) {
++ bool message = false;
++ uint count = 0;
++ int error;
++ for (;;) {
++ if ((error = sql_real_connect(host, database, user, nullptr, wait_flag)) >=
++ 0) {
++ if (count) {
++ tee_fputs("\n", stderr);
++ (void)fflush(stderr);
++ }
++ return error;
++ }
++ if (!wait_flag) return ignore_errors ? -1 : 1;
++ if (!message && !silent) {
++ message = true;
++ tee_fputs("Waiting", stderr);
++ (void)fflush(stderr);
++ }
++ (void)sleep(wait_time);
++ if (!silent) {
++ putc('.', stderr);
++ (void)fflush(stderr);
++ count++;
++ }
++ }
++}
++
++static int com_status(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ const char *status_str;
++ char buff[40];
++ ulonglong id;
++ MYSQL_RES *result = nullptr;
++
++ if (mysql_real_query_for_lazy(
++ STRING_WITH_LEN("select DATABASE(), USER() limit 1")))
++ return 0;
++
++ tee_puts("--------------", stdout);
++ usage(1); /* Print version */
++ tee_fprintf(stdout, "\nConnection id:\t\t%lu\n", mysql_thread_id(&mysql));
++ /*
++ Don't remove "limit 1",
++ it is protection against SQL_SELECT_LIMIT=0
++ */
++ if (!mysql_store_result_for_lazy(&result)) {
++ MYSQL_ROW cur = mysql_fetch_row(result);
++ if (cur) {
++ tee_fprintf(stdout, "Current database:\t%s\n", cur[0] ? cur[0] : "");
++ tee_fprintf(stdout, "Current user:\t\t%s\n", cur[1]);
++ }
++ mysql_free_result(result);
++ }
++
++ if ((status_str = mysql_get_ssl_cipher(&mysql)))
++ tee_fprintf(stdout, "SSL:\t\t\tCipher in use is %s\n", status_str);
++ else
++ tee_puts("SSL:\t\t\tNot in use", stdout);
++
++ if (skip_updates) {
++ tee_fprintf(stdout, "\nAll updates ignored to this database\n");
++ }
++#ifdef USE_POPEN
++ tee_fprintf(stdout, "Current pager:\t\t%s\n", pager);
++ tee_fprintf(stdout, "Using outfile:\t\t'%s'\n", opt_outfile ? outfile : "");
++#endif
++ tee_fprintf(stdout, "Using delimiter:\t%s\n", delimiter);
++ tee_fprintf(stdout, "Server version:\t\t%s\n", server_version_string(&mysql));
++ tee_fprintf(stdout, "Protocol version:\t%d\n", mysql_get_proto_info(&mysql));
++ tee_fprintf(stdout, "Connection:\t\t%s\n", mysql_get_host_info(&mysql));
++ if ((id = mysql_insert_id(&mysql)))
++ tee_fprintf(stdout, "Insert id:\t\t%s\n", llstr(id, buff));
++
++ /* "limit 1" is protection against SQL_SELECT_LIMIT=0 */
++ if (mysql_real_query_for_lazy(STRING_WITH_LEN(
++ "select @@character_set_client, @@character_set_connection, "
++ "@@character_set_server, @@character_set_database limit 1"))) {
++ if (mysql_errno(&mysql) == CR_SERVER_GONE_ERROR) return 0;
++ }
++ if (!mysql_store_result_for_lazy(&result)) {
++ MYSQL_ROW cur = mysql_fetch_row(result);
++ if (cur) {
++ tee_fprintf(stdout, "Server characterset:\t%s\n", cur[2] ? cur[2] : "");
++ tee_fprintf(stdout, "Db characterset:\t%s\n", cur[3] ? cur[3] : "");
++ tee_fprintf(stdout, "Client characterset:\t%s\n", cur[0] ? cur[0] : "");
++ tee_fprintf(stdout, "Conn. characterset:\t%s\n", cur[1] ? cur[1] : "");
++ }
++ mysql_free_result(result);
++ } else {
++ /* Probably pre-4.1 server */
++ tee_fprintf(stdout, "Client characterset:\t%s\n", charset_info->csname);
++ tee_fprintf(stdout, "Server characterset:\t%s\n", mysql.charset->csname);
++ }
++
++ if (strstr(mysql_get_host_info(&mysql), "TCP/IP") || !mysql.unix_socket)
++ tee_fprintf(stdout, "TCP port:\t\t%d\n", mysql.port);
++ else
++ tee_fprintf(stdout, "UNIX socket:\t\t%s\n", mysql.unix_socket);
++ if (mysql.net.compress) tee_fprintf(stdout, "Protocol:\t\tCompressed\n");
++ if (opt_binhex) tee_fprintf(stdout, "Binary data as:\t\tHexadecimal\n");
++ if (mysql_get_ssl_session_reused(&mysql))
++ tee_fprintf(stdout, "SSL session reused:\ttrue\n");
++
++ if ((status_str = mysql_stat(&mysql)) && !mysql_error(&mysql)[0]) {
++ ulong sec;
++ const char *pos = strchr(status_str, ' ');
++ /* print label */
++ tee_fprintf(stdout, "%.*s\t\t\t", (int)(pos - status_str), status_str);
++ if ((status_str = str2int(pos, 10, 0, LONG_MAX, (long *)&sec))) {
++ nice_time((double)sec, buff, false);
++ tee_puts(buff, stdout); /* print nice time */
++ while (*status_str == ' ') status_str++; /* to next info */
++ tee_putc('\n', stdout);
++ tee_puts(status_str, stdout);
++ }
++ }
++ if (safe_updates) {
++ tee_fprintf(stdout, "\nNote that you are running in safe_update_mode:\n");
++ tee_fprintf(stdout,
++ "\
++UPDATEs and DELETEs that don't use a key in the WHERE clause are not allowed.\n\
++(One can force an UPDATE/DELETE by adding LIMIT # at the end of the command.)\n\
++SELECT has an automatic 'LIMIT %lu' if LIMIT is not used.\n\
++Max number of examined row combination in a join is set to: %lu\n\n",
++ select_limit, max_join_size);
++ }
++ tee_puts("--------------\n", stdout);
++ return 0;
++}
++
++static const char *server_version_string(MYSQL *con) {
++ /* Only one thread calls this, so no synchronization is needed */
++ if (server_version == nullptr) {
++ MYSQL_RES *result;
++
++ /* "limit 1" is protection against SQL_SELECT_LIMIT=0 */
++ if (!mysql_query(con, "select @@version_comment limit 1") &&
++ (result = mysql_use_result(con))) {
++ MYSQL_ROW cur = mysql_fetch_row(result);
++ if (cur && cur[0]) {
++ /* version, space, comment, \0 */
++ size_t len = strlen(mysql_get_server_info(con)) + strlen(cur[0]) + 2;
++
++ if ((server_version =
++ (char *)my_malloc(PSI_NOT_INSTRUMENTED, len, MYF(MY_WME)))) {
++ char *bufp;
++ bufp = my_stpcpy(server_version, mysql_get_server_info(con));
++ bufp = my_stpcpy(bufp, " ");
++ (void)my_stpcpy(bufp, cur[0]);
++ }
++ }
++ mysql_free_result(result);
++ }
++
++ /*
++ If for some reason we didn't get a version_comment, we'll
++ keep things simple.
++ */
++
++ if (server_version == nullptr)
++ server_version = my_strdup(PSI_NOT_INSTRUMENTED,
++ mysql_get_server_info(con), MYF(MY_WME));
++ }
++
++ return server_version ? server_version : "";
++}
++
++static int put_info(const char *str, INFO_TYPE info_type, uint error,
++ const char *sqlstate) {
++ FILE *file = (info_type == INFO_ERROR ? stderr : stdout);
++ static int inited = 0;
++
++ if (status.batch) {
++ if (info_type == INFO_ERROR) {
++ (void)fflush(stdout); // flush stdout before stderr
++ (void)fflush(file);
++ fprintf(file, "ERROR");
++ if (error) {
++ if (sqlstate)
++ (void)fprintf(file, " %d (%s)", error, sqlstate);
++ else
++ (void)fprintf(file, " %d", error);
++ }
++ if (status.query_start_line && line_numbers) {
++ (void)fprintf(file, " at line %lu", status.query_start_line);
++ if (status.file_name)
++ (void)fprintf(file, " in file: '%s'", status.file_name);
++ }
++ (void)fprintf(file, ": %s\n", str);
++ (void)fflush(file);
++ if (!ignore_errors) return 1;
++ } else if (info_type == INFO_RESULT && verbose > 1)
++ tee_puts(str, file);
++ if (unbuffered) fflush(file);
++ return info_type == INFO_ERROR ? -1 : 0;
++ }
++ if (!opt_silent || info_type == INFO_ERROR) {
++ if (!inited) {
++ inited = 1;
++ }
++ if (info_type == INFO_ERROR) {
++ if (!opt_nobeep) putchar('\a'); /* This should make a bell */
++ if (error) {
++ if (sqlstate)
++ (void)tee_fprintf(file, "ERROR %d (%s): ", error, sqlstate);
++ else
++ (void)tee_fprintf(file, "ERROR %d: ", error);
++ } else
++ tee_puts("ERROR: ", file);
++ }
++ (void)tee_puts(str, file);
++ }
++ if (unbuffered) fflush(file);
++ return info_type == INFO_ERROR ? -1 : 0;
++}
++
++static int put_error(MYSQL *con) {
++ return put_info(mysql_error(con), INFO_ERROR, mysql_errno(con),
++ mysql_sqlstate(con));
++}
++
++/**
++ Prints the SQL error, if any
++
++ Similar to @ref put_error, but prints the error only if there is any.
++
++ @param con the connection to check for errors
++*/
++static void put_error_if_any(MYSQL *con) {
++ const char *err = mysql_error(con);
++ if (err && *err)
++ put_info(err, INFO_ERROR, mysql_errno(con), mysql_sqlstate(con));
++}
++
++static void remove_cntrl(String *buffer) {
++ const char *start = buffer->ptr();
++ const char *end = start + buffer->length();
++ while (start < end && !my_isgraph(charset_info, end[-1])) end--;
++ buffer->length((uint)(end - start));
++}
++
++/**
++ Write data to a stream.
++ Various modes, corresponding to --tab, --xml, --raw parameters,
++ are supported.
++
++ @param file Stream to write to
++ @param s String to write
++ @param slen String length
++ @param flags Flags for --tab, --xml, --raw.
++*/
++void tee_write(FILE *file, const char *s, size_t slen, int flags) {
++#ifdef _WIN32
++ bool is_console = my_win_is_console_cached(file);
++#endif
++ const char *se;
++ for (se = s + slen; s < se; s++) {
++ const char *t;
++
++ if (flags & MY_PRINT_MB) {
++ int mblen;
++ if (use_mb(charset_info) && (mblen = my_ismbchar(charset_info, s, se))) {
++#ifdef _WIN32
++ if (is_console)
++ my_win_console_write(charset_info, s, mblen);
++ else
++#endif
++ if (fwrite(s, 1, mblen, file) != (size_t)mblen) {
++ perror("fwrite");
++ }
++ if (opt_outfile) {
++ if (fwrite(s, 1, mblen, OUTFILE) != (size_t)mblen) {
++ perror("fwrite");
++ }
++ }
++ s += mblen - 1;
++ continue;
++ }
++ }
++
++ if ((flags & MY_PRINT_XML) && (t = array_value(xmlmeta, *s)))
++ tee_fputs(t, file);
++ else if ((flags & MY_PRINT_SPS_0) && *s == '\0')
++ tee_putc((int)' ', file); // This makes everything hard
++ else if ((flags & MY_PRINT_ESC_0) && *s == '\0')
++ tee_fputs("\\0", file); // This makes everything hard
++ else if ((flags & MY_PRINT_CTRL) && *s == '\t')
++ tee_fputs("\\t", file); // This would destroy tab format
++ else if ((flags & MY_PRINT_CTRL) && *s == '\n')
++ tee_fputs("\\n", file); // This too
++ else if ((flags & MY_PRINT_CTRL) && *s == '\\')
++ tee_fputs("\\\\", file);
++ else {
++#ifdef _WIN32
++ if (is_console)
++ my_win_console_putc(charset_info, (int)*s);
++ else
++#endif
++ putc((int)*s, file);
++ if (opt_outfile) putc((int)*s, OUTFILE);
++ }
++ }
++}
++
++void tee_fprintf(FILE *file, const char *fmt, ...) {
++ va_list args;
++
++ va_start(args, fmt);
++#ifdef _WIN32
++ if (my_win_is_console_cached(file))
++ my_win_console_vfprintf(charset_info, fmt, args);
++ else
++#endif
++ (void)vfprintf(file, fmt, args);
++ va_end(args);
++
++ if (opt_outfile) {
++ va_start(args, fmt);
++ (void)vfprintf(OUTFILE, fmt, args);
++ va_end(args);
++ }
++}
++
++/*
++ Write a 0-terminated string to file and OUTFILE.
++ TODO: possibly it's nice to have a version with length some day,
++ e.g. tee_fnputs(s, slen, file),
++ to print numerous ASCII constant strings among mysql.cc
++ code, to avoid strlen(s) in my_win_console_fputs().
++*/
++void tee_fputs(const char *s, FILE *file) {
++#ifdef _WIN32
++ if (my_win_is_console_cached(file))
++ my_win_console_fputs(charset_info, s);
++ else
++#endif
++ fputs(s, file);
++ if (opt_outfile) fputs(s, OUTFILE);
++}
++
++void tee_puts(const char *s, FILE *file) {
++ tee_fputs(s, file);
++ tee_putc('\n', file);
++}
++
++void tee_putc(int c, FILE *file) {
++#ifdef _WIN32
++ if (my_win_is_console_cached(file))
++ my_win_console_putc(charset_info, c);
++ else
++#endif
++ putc(c, file);
++ if (opt_outfile) putc(c, OUTFILE);
++}
++
++#if defined(_WIN32)
++#include <time.h>
++#else
++#include <sys/times.h>
++#ifdef _SC_CLK_TCK // For mit-pthreads
++#undef CLOCKS_PER_SEC
++#define CLOCKS_PER_SEC (sysconf(_SC_CLK_TCK))
++#endif
++#endif
++
++static ulong start_timer(void) {
++#if defined(_WIN32)
++ return clock();
++#else
++ struct tms tms_tmp;
++ return times(&tms_tmp);
++#endif
++}
++
++/**
++ Write as many as 52+1 bytes to buff, in the form of a legible duration of
++ time.
++
++ len("4294967296 days, 23 hours, 59 minutes, 60.00 seconds") -> 52
++*/
++static void nice_time(double sec, char *buff, bool part_second) {
++ ulong tmp;
++ if (sec >= 3600.0 * 24) {
++ tmp = (ulong)floor(sec / (3600.0 * 24));
++ sec -= 3600.0 * 24 * tmp;
++ buff = longlong10_to_str(tmp, buff, 10);
++ buff = my_stpcpy(buff, tmp > 1 ? " days " : " day ");
++ }
++ if (sec >= 3600.0) {
++ tmp = (ulong)floor(sec / 3600.0);
++ sec -= 3600.0 * tmp;
++ buff = longlong10_to_str(tmp, buff, 10);
++ buff = my_stpcpy(buff, tmp > 1 ? " hours " : " hour ");
++ }
++ if (sec >= 60.0) {
++ tmp = (ulong)floor(sec / 60.0);
++ sec -= 60.0 * tmp;
++ buff = longlong10_to_str(tmp, buff, 10);
++ buff = my_stpcpy(buff, " min ");
++ }
++ if (part_second)
++ sprintf(buff, "%.2f sec", sec);
++ else
++ sprintf(buff, "%d sec", (int)sec);
++}
++
++static void end_timer(ulong start_time, char *buff) {
++ nice_time((double)(start_timer() - start_time) / CLOCKS_PER_SEC, buff, true);
++}
++
++static void mysql_end_timer(ulong start_time, char *buff) {
++ buff[0] = ' ';
++ buff[1] = '(';
++ end_timer(start_time, buff + 2);
++ my_stpcpy(strend(buff), ")");
++}
++
++static const char *construct_prompt() {
++ processed_prompt.mem_free(); // Erase the old prompt
++ time_t lclock = time(nullptr); // Get the date struct
++ struct tm *t = localtime(&lclock);
++
++ /* parse thru the settings for the prompt */
++ for (char *c = current_prompt; *c; c++) {
++ if (*c != PROMPT_CHAR)
++ processed_prompt.append(*c);
++ else {
++ switch (*++c) {
++ case '\0':
++ c--; // stop it from going beyond if ends with %
++ break;
++ case 'c':
++ add_int_to_prompt(++prompt_counter);
++ break;
++ case 'C':
++ add_int_to_prompt(mysql_thread_id(&mysql));
++ break;
++ case 'v':
++ if (connected)
++ processed_prompt.append(mysql_get_server_info(&mysql));
++ else
++ processed_prompt.append("not_connected");
++ break;
++ case 'd':
++ processed_prompt.append(current_db ? current_db : "(none)");
++ break;
++ case 'h': {
++ const char *prompt;
++ prompt = connected ? mysql_get_host_info(&mysql) : "not_connected";
++ if (strstr(prompt, "Localhost"))
++ processed_prompt.append("localhost");
++ else {
++ const char *end = strcend(prompt, ' ');
++ processed_prompt.append(prompt, (uint)(end - prompt));
++ }
++ break;
++ }
++ case 'p': {
++ if (!connected) {
++ processed_prompt.append("not_connected");
++ break;
++ }
++
++ const char *host_info = mysql_get_host_info(&mysql);
++ if (strstr(host_info, "memory")) {
++ processed_prompt.append(mysql.host);
++ } else if (strstr(host_info, "TCP/IP") || !mysql.unix_socket)
++ add_int_to_prompt(mysql.port);
++ else {
++ char *pos = strrchr(mysql.unix_socket, '/');
++ processed_prompt.append(pos ? pos + 1 : mysql.unix_socket);
++ }
++ } break;
++ case 'U':
++ if (!full_username) init_username();
++ processed_prompt.append(
++ full_username ? full_username
++ : (current_user ? current_user : "(unknown)"));
++ break;
++ case 'u':
++ if (!full_username) init_username();
++ processed_prompt.append(
++ part_username ? part_username
++ : (current_user ? current_user : "(unknown)"));
++ break;
++ case PROMPT_CHAR:
++ processed_prompt.append(PROMPT_CHAR);
++ break;
++ case 'n':
++ processed_prompt.append('\n');
++ break;
++ case ' ':
++ case '_':
++ processed_prompt.append(' ');
++ break;
++ case 'R':
++ if (t->tm_hour < 10) processed_prompt.append('0');
++ add_int_to_prompt(t->tm_hour);
++ break;
++ case 'r':
++ int getHour;
++ getHour = t->tm_hour % 12;
++ if (getHour == 0) getHour = 12;
++ if (getHour < 10) processed_prompt.append('0');
++ add_int_to_prompt(getHour);
++ break;
++ case 'm':
++ if (t->tm_min < 10) processed_prompt.append('0');
++ add_int_to_prompt(t->tm_min);
++ break;
++ case 'y':
++ int getYear;
++ getYear = t->tm_year % 100;
++ if (getYear < 10) processed_prompt.append('0');
++ add_int_to_prompt(getYear);
++ break;
++ case 'Y':
++ add_int_to_prompt(t->tm_year + 1900);
++ break;
++ case 'D':
++ char *dateTime;
++ dateTime = ctime(&lclock);
++ processed_prompt.append(strtok(dateTime, "\n"));
++ break;
++ case 's':
++ if (t->tm_sec < 10) processed_prompt.append('0');
++ add_int_to_prompt(t->tm_sec);
++ break;
++ case 'w':
++ processed_prompt.append(day_names[t->tm_wday]);
++ break;
++ case 'P':
++ processed_prompt.append(t->tm_hour < 12 ? "am" : "pm");
++ break;
++ case 'o':
++ add_int_to_prompt(t->tm_mon + 1);
++ break;
++ case 'O':
++ processed_prompt.append(month_names[t->tm_mon]);
++ break;
++ case '\'':
++ processed_prompt.append("'");
++ break;
++ case '"':
++ processed_prompt.append('"');
++ break;
++ case 'S':
++ processed_prompt.append(';');
++ break;
++ case 't':
++ processed_prompt.append('\t');
++ break;
++ case 'l':
++ processed_prompt.append(delimiter_str);
++ break;
++ case 'T':
++ if (mysql.server_status & SERVER_STATUS_IN_TRANS)
++ processed_prompt.append("*");
++ break;
++ default:
++ processed_prompt.append(c);
++ }
++ }
++ }
++ processed_prompt.append('\0');
++ return processed_prompt.ptr();
++}
++
++static void add_int_to_prompt(int toadd) {
++ processed_prompt.append_longlong(toadd);
++}
++
++static void init_username() {
++ my_free(full_username);
++ my_free(part_username);
++
++ MYSQL_RES *result = nullptr;
++ if (!mysql_query(&mysql, "select USER()") &&
++ (result = mysql_use_result(&mysql))) {
++ MYSQL_ROW cur = mysql_fetch_row(result);
++ full_username = my_strdup(PSI_NOT_INSTRUMENTED, cur[0], MYF(MY_WME));
++ part_username =
++ my_strdup(PSI_NOT_INSTRUMENTED, strtok(cur[0], "@"), MYF(MY_WME));
++ (void)mysql_fetch_row(result); // Read eof
++ }
++}
++
++// Get the current OS user name.
++static void get_current_os_user() {
++ const char *user;
++
++#ifdef _WIN32
++ char buf[255];
++ WCHAR wbuf[255];
++ DWORD wbuf_len = sizeof(wbuf) / sizeof(WCHAR);
++ size_t len;
++ uint dummy_errors;
++
++ if (GetUserNameW(wbuf, &wbuf_len)) {
++ len = my_convert(buf, sizeof(buf) - 1, charset_info, (char *)wbuf,
++ wbuf_len * sizeof(WCHAR), &my_charset_utf16le_bin,
++ &dummy_errors);
++ buf[len] = 0;
++ user = buf;
++ } else {
++ user = "UNKNOWN USER";
++ }
++#else
++#ifdef HAVE_GETPWUID
++ struct passwd *pw;
++
++ if ((pw = getpwuid(geteuid())) != nullptr)
++ user = pw->pw_name;
++ else
++#endif
++ if (!(user = getenv("USER")) && !(user = getenv("LOGNAME")) &&
++ !(user = getenv("LOGIN")))
++ user = "UNKNOWN USER";
++#endif /* _WIN32 */
++ current_os_user = my_strdup(PSI_NOT_INSTRUMENTED, user, MYF(MY_WME));
++ return;
++}
++
++// Get the current OS sudo user name (only for non-Windows platforms).
++static void get_current_os_sudouser() {
++#ifndef _WIN32
++ if (getenv("SUDO_USER"))
++ current_os_sudouser =
++ my_strdup(PSI_NOT_INSTRUMENTED, getenv("SUDO_USER"), MYF(MY_WME));
++#endif /* !_WIN32 */
++ return;
++}
++
++static int com_prompt(String *buffer [[maybe_unused]], char *line) {
++ char *ptr = strchr(line, ' ');
++ prompt_counter = 0;
++ my_free(current_prompt);
++ current_prompt = my_strdup(PSI_NOT_INSTRUMENTED,
++ ptr ? ptr + 1 : default_prompt, MYF(MY_WME));
++ if (!ptr)
++ tee_fprintf(stdout, "Returning to default PROMPT of %s\n", default_prompt);
++ else
++ tee_fprintf(stdout, "PROMPT set to '%s'\n", current_prompt);
++ return 0;
++}
++
++static int com_resetconnection(String *buffer [[maybe_unused]],
++ char *line [[maybe_unused]]) {
++ int error;
++ global_attrs->clear(connected ? &mysql : nullptr);
++ error = mysql_reset_connection(&mysql);
++ if (error) {
++ if (status.batch) return 0;
++ return put_error(&mysql);
++ }
++ return error;
++}
TLD / packages / mysql.git / commitdiff