bool *var; // Actual variable

bool set; // Has been set for ONCE command

bool old; // If set, thus is the old value

bool reverse; // Variable is true if disabled

const char *env_name; // Environment variable name

P_ABORT = 0,

P_CONNECT,

P_INFO,

P_SESSION_TRACK,

P_META,

P_PS,

P_QUERY,

P_RESULT,

P_WARN,

P_ASYNC,

P_MAX

int line; /* Start line of block */

bool ok; /* Should block be executed */

enum block_cmd cmd; /* Command owning the block */

char delim[MAX_DELIMITER_LENGTH]; /* Delimiter before block */

FILE *file;

char *file_name;

uint lineno; /* Current line in file */

MYSQL mysql;

/* Used when creating views and sp, to avoid implicit commit */

MYSQL *util_mysql;

char *name;

size_t name_len;

MYSQL_STMT *stmt;

/* Set after send to disallow other queries before reap */

bool pending;

Q_CONNECTION = 1,

Q_QUERY,

Q_CONNECT,

Q_SLEEP,

Q_INC,

Q_DEC,

Q_SOURCE,

Q_DISCONNECT,

Q_LET,

Q_ECHO,

Q_EXPR,

Q_WHILE,

Q_END_BLOCK,

Q_SAVE_MASTER_POS,

Q_SYNC_WITH_MASTER,

Q_SYNC_SLAVE_WITH_MASTER,

Q_ERROR,

Q_SEND,

Q_REAP,

Q_DIRTY_CLOSE,

Q_REPLACE,

Q_REPLACE_COLUMN,

Q_PING,

Q_EVAL,

Q_ENABLE_QUERY_LOG,

Q_DISABLE_QUERY_LOG,

Q_ENABLE_RESULT_LOG,

Q_DISABLE_RESULT_LOG,

Q_ENABLE_CONNECT_LOG,

Q_DISABLE_CONNECT_LOG,

Q_WAIT_FOR_SLAVE_TO_STOP,

Q_ENABLE_WARNINGS,

Q_DISABLE_WARNINGS,

Q_ENABLE_INFO,

Q_DISABLE_INFO,

Q_ENABLE_SESSION_TRACK_INFO,

Q_DISABLE_SESSION_TRACK_INFO,

Q_ENABLE_METADATA,

Q_DISABLE_METADATA,

Q_ENABLE_ASYNC_CLIENT,

Q_DISABLE_ASYNC_CLIENT,

Q_EXEC,

Q_EXECW,

Q_EXEC_BACKGROUND,

Q_DELIMITER,

Q_DISABLE_ABORT_ON_ERROR,

Q_ENABLE_ABORT_ON_ERROR,

Q_DISPLAY_VERTICAL_RESULTS,

Q_DISPLAY_HORIZONTAL_RESULTS,

Q_QUERY_VERTICAL,

Q_QUERY_HORIZONTAL,

Q_SORTED_RESULT,

Q_PARTIALLY_SORTED_RESULT,

Q_LOWERCASE,

Q_SKIP_IF_HYPERGRAPH,

Q_START_TIMER,

Q_END_TIMER,

Q_CHARACTER_SET,

Q_DISABLE_PS_PROTOCOL,

Q_ENABLE_PS_PROTOCOL,

Q_DISABLE_RECONNECT,

Q_ENABLE_RECONNECT,

Q_IF,

Q_DISABLE_TESTCASE,

Q_ENABLE_TESTCASE,

Q_REPLACE_REGEX,

Q_REPLACE_NUMERIC_ROUND,

Q_REMOVE_FILE,

Q_FILE_EXIST,

Q_WRITE_FILE,

Q_COPY_FILE,

Q_PERL,

Q_DIE,

Q_ASSERT,

Q_EXIT,

Q_SKIP,

Q_CHMOD_FILE,

Q_APPEND_FILE,

Q_CAT_FILE,

Q_DIFF_FILES,

Q_SEND_QUIT,

Q_CHANGE_USER,

Q_MKDIR,

Q_RMDIR,

Q_FORCE_RMDIR,

Q_FORCE_CPDIR,

Q_LIST_FILES,

Q_LIST_FILES_WRITE_FILE,

Q_LIST_FILES_APPEND_FILE,

Q_SEND_SHUTDOWN,

Q_SHUTDOWN_SERVER,

Q_RESULT_FORMAT_VERSION,

Q_MOVE_FILE,

Q_REMOVE_FILES_WILDCARD,

Q_COPY_FILES_WILDCARD,

Q_SEND_EVAL,

Q_OUTPUT, /* redirect output to a file */

Q_RESET_CONNECTION,

Q_QUERY_ATTRIBUTES,

Q_UNKNOWN, /* Unknown command. */

Q_COMMENT, /* Comments, ignored. */

Q_COMMENT_WITH_COMMAND,

Q_EMPTY_LINE

char *query, *query_buf, *first_argument, *last_argument, *end;

DYNAMIC_STRING content;

size_t first_word_len, query_len;

bool abort_on_error, used_replace;

char output_file[FN_REFLEN];

enum enum_commands type;

// Line number of the command

uint lineno;

free_replace();

free_replace_regex();

free_replace_column();

free_replace_numeric_round();

global_attrs->clear();

public:

explicit AsyncTimer(std::string label)

: label_(label), time_(std::chrono::system_clock::now()), start_(time_) {}

~AsyncTimer() {

auto now = std::chrono::system_clock::now();

auto delta = now - start_;

[[maybe_unused]] ulonglong micros =

std::chrono::duration_cast<std::chrono::microseconds>(delta).count();

DBUG_PRINT("async_timing",

("%s total micros: %llu", label_.c_str(), micros));

}

void check() {

auto now = std::chrono::system_clock::now();

auto delta = now - time_;

time_ = now;

[[maybe_unused]] ulonglong micros =

std::chrono::duration_cast<std::chrono::microseconds>(delta).count();

DBUG_PRINT("async_timing", ("%s op micros: %llu", label_.c_str(), micros));

}

private:

std::string label_;

std::chrono::system_clock::time_point time_;

std::chrono::system_clock::time_point start_;

int result;

fd_set readfds, writefds, exceptfds;

FD_ZERO(&readfds);

FD_ZERO(&writefds);

FD_ZERO(&exceptfds);

FD_SET(fd, &exceptfds);

FD_SET(fd, &readfds);

FD_SET(fd, &writefds);

result = select((int)(fd + 1), &readfds, &writefds, &exceptfds, nullptr);

if (result < 0) {

DWORD error_code = WSAGetLastError();

verbose_msg("Cannot determine the status due to error :%lu\n", error_code);

}

return result;

int result;

pollfd pfd;

pfd.fd = fd;

/*

pfd.events = POLLIN | POLLOUT;

result = poll(&pfd, 1, -1);

if (result < 0) {

perror("poll");

}

return result;

MYSQL_ROW row;

MYSQL *mysql = res->handle;

AsyncTimer t(__func__);

while (mysql_fetch_row_nonblocking(res, &row) == NET_ASYNC_NOT_READY) {

t.check();

int result = socket_event_listen(mysql_get_socket_descriptor(mysql));

if (result == -1) return nullptr;

}

return row;

ulong length) {

net_async_status status;

AsyncTimer t(__func__);

while ((status = mysql_real_query_nonblocking(mysql, query, length)) ==

NET_ASYNC_NOT_READY) {

t.check();

int result = socket_event_listen(mysql_get_socket_descriptor(mysql));

if (result == -1) return 1;

}

if (status == NET_ASYNC_ERROR) {

return 1;

}

return 0;

ulong length) {

net_async_status status;

AsyncTimer t(__func__);

while ((status = mysql_send_query_nonblocking(mysql, query, length)) ==

NET_ASYNC_NOT_READY) {

t.check();

int result = socket_event_listen(mysql_get_socket_descriptor(mysql));

if (result == -1) return 1;

}

if (status == NET_ASYNC_ERROR) {

return 1;

}

return 0;

net_async_status status;

AsyncTimer t(__func__);

while ((status = (*mysql->methods->read_query_result_nonblocking)(mysql)) ==

NET_ASYNC_NOT_READY) {

t.check();

int result = socket_event_listen(mysql_get_socket_descriptor(mysql));

if (result == -1) return true;

}

if (status == NET_ASYNC_ERROR) {

return true;

}

return false;

net_async_status status;

AsyncTimer t(__func__);

while ((status = mysql_next_result_nonblocking(mysql)) ==

NET_ASYNC_NOT_READY) {

t.check();

int result = socket_event_listen(mysql_get_socket_descriptor(mysql));

if (result == -1) return 1;

}

if (status == NET_ASYNC_ERROR)

return 1;

else if (status == NET_ASYNC_COMPLETE_NO_MORE_RESULTS)

return -1;

else

return 0;

net_async_status status;

AsyncTimer t(__func__);

while ((status = mysql_real_query_nonblocking(mysql, query, strlen(query))) ==

NET_ASYNC_NOT_READY) {

t.check();

int result = socket_event_listen(mysql_get_socket_descriptor(mysql));

if (result == -1) return 1;

}

if (status == NET_ASYNC_ERROR) {

return 1;

}

return 0;

AsyncTimer t(__func__);

while (mysql_free_result_nonblocking(result) == NET_ASYNC_NOT_READY) {

t.check();

MYSQL *mysql = result->handle;

int listen_result = socket_event_listen(mysql_get_socket_descriptor(mysql));

if (listen_result == -1) return;

}

return;

if (enable_async_client)

return async_mysql_fetch_row_wrapper(res);

else

return mysql_fetch_row(res);

ulong length) {

int rc;

if (0 != (rc = global_attrs->set_params(mysql))) return rc;

if (enable_async_client)

return async_mysql_real_query_wrapper(mysql, query, length);

else

return mysql_real_query(mysql, query, length);

ulong length) {

int rc;

if (0 != (rc = global_attrs->set_params(mysql))) return rc;

if (enable_async_client)

return async_mysql_send_query_wrapper(mysql, query, length);

else

return mysql_send_query(mysql, query, length);

bool ret;

if (enable_async_client)

ret = async_mysql_read_query_result_wrapper(mysql);

else

ret = mysql_read_query_result(mysql);

return ret;

int rc;

if (0 != (rc = global_attrs->set_params(mysql))) return rc;

if (enable_async_client)

return async_mysql_query_wrapper(mysql, query);

else

return mysql_query(mysql, query);

if (enable_async_client)

return async_mysql_next_result_wrapper(mysql);

else

return mysql_next_result(mysql);

if (enable_async_client)

return async_mysql_free_result_wrapper(result);

else

return mysql_free_result(result);

const char *query_end, bool pass_through_escape_chars) {

const char *p;

char c, next_c;

int escaped = 0;

VAR *v;

DBUG_TRACE;

for (p = query; (c = *p) && p < query_end; ++p) {

next_c = *(p + 1);

switch (c) {

case '$':

if (escaped ||

// a JSON path expression

next_c == '.' || next_c == '[' || next_c == '\'' || next_c == '"') {

escaped = 0;

dynstr_append_mem(query_eval, p, 1);

} else {

if (!(v = var_get(p, &p, false, false))) die("Bad variable in eval");

dynstr_append_mem(query_eval, v->str_val, v->str_val_len);

}

break;