/* Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; version 2 of the License. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include #include #include "my_sys.h" // my_write, my_malloc #include #include "mysql_com.h" #include "m_string.h" #include "sql_string.h" /* STRING_PSI_MEMORY_KEY */ static const char *log_filename= "test_sql_complex"; struct st_test_statement { const char *db; bool generates_result_set; const char *query; }; static struct st_test_statement test_query_plan[]= { /* DB RESULT QUERY */ {NULL , true, "SELECT 'first complex command' as a"}, {NULL , false, "CREATE DATABASE test1"}, {NULL , false, "USE test"}, {"test1", false, "CREATE TABLE test_inserts(" " a INT UNSIGNED, b VARCHAR(100), c DOUBLE, d INT, e FLOAT," "f DATETIME, g DATE, h TIME, i TINYINT, k TINYINT UNSIGNED," "l SMALLINT, m SMALLINT UNSIGNED, n MEDIUMINT, o MEDIUMINT UNSIGNED," "p INTEGER, q INTEGER UNSIGNED, r BIGINT, s BIGINT UNSIGNED," "t YEAR, u DECIMAL(5,2) UNSIGNED, v DECIMAL(5,2)," " PRIMARY KEY(a), INDEX(d));" }, {"test1", false, "INSERT INTO test_inserts VALUES (1, 'one', 1.23, -1, 11.2323, '2014-07-06 07:06:05', '1980-02-19', '-830:12:23'," " 127, 255, 32767, 65535, 8388607, 16777215, 2147483647, 4294967295, 9223372036854775807, 18446744073709551615," "1901, 999.99, -999.99)"}, {"test1", false, "INSERT INTO test_inserts VALUES (2, 'two', 2.34, -2, 22.3434, '2015-07-06 21:22:23', '2014-06-05', '356:22:33'," " -128, 0, -32768, 32768, -8388608, 8388607, -2147483648, 0, -9223372036854775808, 18446744073709551615," "2039, 123.45, -543.21)"}, {"test1", false, "INSERT INTO test_inserts VALUES (3, 'three',3.45,-3, 33.4545, '2016-09-12 11:12:13', '2013-05-04', '821:33:44'," " -1, 128, -1, 65534, -1, 16777214, 1, 2, 3, 4," "2155, 222.22, -567.89)"}, {"test1", true, "SELECT * FROM test1.test_inserts ORDER BY a"}, {"test1", false, "DELETE FROM test_inserts WHERE a=2"}, {"test1", true, "SELECT * FROM test_inserts ORDER BY a"}, {"test1", false, "TRUNCATE test_inserts"}, {"test1", true, "SELECT * FROM test_inserts ORDER BY a"}, // prepared statements via SQL {"test1", false, "PREPARE ps1 FROM 'select 1'"}, {"test1", false, "EXECUTE ps1"}, {"test1", false, "DEALLOCATE PREPARE ps1"}, {"test1", false, "CREATE TABLE tbl (a INT)"}, {"test1", false, "PREPARE ps1 FROM 'INSERT INTO tbl VALUES (1), (2), (3)'"}, {"test1", false, "EXECUTE ps1"}, {"test1", false, "DEALLOCATE PREPARE ps1"}, {"test1", false, "SELECT IF(SUM(a)=6, 'OK:)', 'FAIL:(') FROM tbl"}, // statements generating different errors {"test1", true, "DEALLOCATE PREPARE ps1"}, {"test1", true, "garbage"}, {"test1", true, "SELECT b FROM tbl"}, {"test1", true, "ALTER USER bogus@remotehost PASSWORD EXPIRE"}, {"test1", false, "CREATE TABLE tbld (d TIME)"}, {"test1", true, "INSERT INTO tbld VALUES ('43141231')"}, // statements generating warnings {"test1", false, "SELECT 1/0"}, // statements generating info text {"test1", false, "UPDATE tbl SET a=5"}, // transactions {"test1", false, "START TRANSACTION"}, {"test1", false, "UPDATE tbl SET a=4"}, {"test1", false, "ROLLBACK"}, {"test1", false, "SELECT IF(SUM(a) = 15, 'OK', 'FAIL') FROM tbl"}, {"test1", false, "START TRANSACTION"}, {"test1", false, "UPDATE tbl SET a=4"}, {"test1", false, "COMMIT"}, {"test1", false, "SELECT IF(SUM(a) = 12, 'OK', 'FAIL') FROM tbl"}, {"test1", false, "START TRANSACTION READ ONLY"}, {"test1", false, "UPDATE tbl SET a=2"}, {"test1", false, "COMMIT"}, {"test1", false, "SELECT IF(SUM(4) = 12, 'OK', 'FAIL') FROM tbl"}, {"test1", false, "SET autocommit=0"}, {"test1", false, "UPDATE tbl SET a=2"}, {"test1", false, "ROLLBACK"}, {"test1", false, "SELECT IF(SUM(4) = 12, 'OK', 'FAIL') FROM tbl"}, // disabled commands {"test1", false, "INSTALL PLUGIN plugin_name SONAME 'shared_library_name'"}, {"test1", false, "UNINSTALL PLUGIN plugin_name"}, {"test1", false, "START GROUP_REPLICATION"}, {"test1", false, "STOP GROUP_REPLICATION"}, // empty cmd {"test1", true, ""}, {"test1", false, "DROP TABLE tbl"}, {"test1", false, "DROP TABLE tbld"}, {"test1", false, "DROP DATABASE test1"}, }; #define STRING_BUFFER_SIZE 512 #define WRITE_STR(format) \ { \ const size_t blen= my_snprintf(buffer, sizeof(buffer), (format)); \ my_write(outfile, (uchar*) buffer, blen, MYF(0)); \ /*pctx->log.append(buffer, blen); */ \ } #define WRITE_VAL(format,value) \ { \ const size_t blen= my_snprintf(buffer, sizeof(buffer), (format), (value)); \ my_write(outfile,(uchar*)buffer, blen, MYF(0)); \ /* pctx->log.append(buffer, blen); */ \ } #define WRITE_VAL2(format,value1, value2) \ { \ const size_t blen= my_snprintf(buffer, sizeof(buffer), (format), (value1), (value2)); \ my_write(outfile,(uchar*) buffer, blen, MYF(0)); \ /* pctx->log.append(buffer, blen); */ \ } static const char *sep = "========================================================================\n"; #define WRITE_SEP() my_write(outfile, (uchar*)sep, strlen(sep), MYF(0)) static File outfile; struct st_send_field_n { char db_name[256]; char table_name[256]; char org_table_name[256]; char col_name[256]; char org_col_name[256]; unsigned long length; unsigned int charsetnr; unsigned int flags; unsigned int decimals; enum_field_types type; }; #define SIZEOF_SQL_STR_VALUE 256 struct st_plugin_ctx { const CHARSET_INFO *resultcs; uint meta_server_status; uint meta_warn_count; uint current_col; uint num_cols; uint num_rows; st_send_field_n sql_field[64]; char sql_str_value[64][64][SIZEOF_SQL_STR_VALUE]; size_t sql_str_len[64][64]; uint server_status; uint warn_count; uint affected_rows; uint last_insert_id; char message[1024]; uint sql_errno; char err_msg[1024]; char sqlstate[6]; std::string log; st_plugin_ctx() { reset(); } void reset() { resultcs= NULL; meta_server_status = 0; meta_warn_count = 0; server_status= 0; current_col= 0; warn_count= 0; num_cols= 0; num_rows= 0; memset(&sql_field, 0, 64 * sizeof(st_send_field_n)); memset(&sql_str_value, 0, 64 * 64 * SIZEOF_SQL_STR_VALUE * sizeof(char)); memset(&sql_str_len, 0, 64 * 64 * sizeof(size_t)); server_status= 0; warn_count= 0; affected_rows= 0; last_insert_id= 0; memset(&message, 0, sizeof(message)); sql_errno= 0; memset(&err_msg, 0, sizeof(err_msg)); memset(&sqlstate, 0, sizeof(sqlstate)); log.clear(); } }; static int sql_start_result_metadata(void *ctx, uint num_cols, uint flags, const CHARSET_INFO *resultcs) { struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_start_result_metadata\n"); DBUG_ENTER("sql_start_result_metadata"); DBUG_PRINT("info",("resultcs->number: %d", resultcs->number)); DBUG_PRINT("info",("resultcs->csname: %s", resultcs->csname)); DBUG_PRINT("info",("resultcs->name: %s", resultcs->name)); pctx->num_cols= num_cols; pctx->resultcs= resultcs; pctx->current_col= 0; DBUG_RETURN(false); }; static int sql_field_metadata(void *ctx, struct st_send_field *field, const CHARSET_INFO *charset) { struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; st_send_field_n *cfield= &pctx->sql_field[pctx->current_col]; // WRITE_STR("sql_field_metadata\n"); DBUG_ENTER("sql_field_metadata"); DBUG_PRINT("info",("field->db_name: %s", field->db_name)); DBUG_PRINT("info",("field->table_name: %s", field->table_name)); DBUG_PRINT("info",("field->org_table_name: %s", field->org_table_name)); DBUG_PRINT("info",("field->col_name: %s", field->col_name)); DBUG_PRINT("info",("field->org_col_name: %s", field->org_col_name)); DBUG_PRINT("info",("field->length: %d", (int)field->length)); DBUG_PRINT("info",("field->charsetnr: %d", (int)field->charsetnr)); DBUG_PRINT("info",("field->flags: %d", (int)field->flags)); DBUG_PRINT("info",("field->decimals: %d", (int)field->decimals)); DBUG_PRINT("info",("field->type: %d", (int)field->type)); strcpy(cfield->db_name, (char*)field->db_name); strcpy(cfield->table_name, (char*)field->table_name); strcpy(cfield->org_table_name, (char*)field->org_table_name); strcpy(cfield->col_name, (char*)field->col_name); strcpy(cfield->org_col_name, (char*)field->org_col_name); cfield->length= field->length; cfield->charsetnr= field->charsetnr; cfield->flags= field->flags; cfield->decimals= field->decimals; cfield->type= field->type; pctx->current_col++; DBUG_RETURN(false); }; static int sql_end_result_metadata(void *ctx, uint server_status, uint warn_count) { struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_end_result_metadata\n"); DBUG_ENTER("sql_end_result_metadata"); pctx->meta_server_status= server_status; pctx->meta_warn_count= warn_count; pctx->num_rows= 0; DBUG_RETURN(false); }; static int sql_start_row(void *ctx) { struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_start_row\n"); DBUG_ENTER("sql_start_row"); pctx->current_col= 0; DBUG_RETURN(false); }; static int sql_end_row(void *ctx) { struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_end_row\n"); DBUG_ENTER("sql_end_row"); pctx->num_rows++; DBUG_RETURN(false); }; static void sql_abort_row(void *ctx) { DBUG_ENTER("sql_abort_row"); DBUG_VOID_RETURN; }; static ulong sql_get_client_capabilities(void *ctx) { DBUG_ENTER("sql_get_client_capabilities"); DBUG_RETURN(0); }; static int sql_get_null(void *ctx) { struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_get_null\n"); DBUG_ENTER("sql_get_null"); uint row= pctx->num_rows; uint col= pctx->current_col; pctx->current_col++; strcpy(pctx->sql_str_value[row][col], "[NULL]"); pctx->sql_str_len[row][col]= sizeof("[NULL]")-1; DBUG_RETURN(false); }; static int sql_get_integer(void * ctx, longlong value) { char buffer[1024]; struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_get_integer\n"); DBUG_ENTER("sql_get_integer"); uint row= pctx->num_rows; uint col= pctx->current_col; pctx->current_col++; size_t len= my_snprintf(buffer, sizeof(buffer), "%lld", value); strncpy(pctx->sql_str_value[row][col], buffer, len); pctx->sql_str_len[row][col]= len; DBUG_RETURN(false); }; static int sql_get_longlong(void * ctx, longlong value, uint is_unsigned) { char buffer[1024]; struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_get_longlong\n"); DBUG_ENTER("sql_get_longlong"); uint row= pctx->num_rows; uint col= pctx->current_col; pctx->current_col++; size_t len= my_snprintf(buffer, sizeof(buffer), is_unsigned? "%llu":"%lld", value); strncpy(pctx->sql_str_value[row][col], buffer, len); pctx->sql_str_len[row][col]= len; DBUG_RETURN(false); }; static const char *test_decimal_as_string(char *buff, const decimal_t *val, int *length) { if (!val) return "NULL"; (void)decimal2string(val, buff, length, 0,0,0); return buff; } static int sql_get_decimal(void * ctx, const decimal_t * value) { struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_get_decimal\n"); DBUG_ENTER("sql_get_decimal"); uint row= pctx->num_rows; uint col= pctx->current_col; pctx->current_col++; int len= SIZEOF_SQL_STR_VALUE; test_decimal_as_string(pctx->sql_str_value[row][col], value, &len); pctx->sql_str_len[row][col]= len; DBUG_RETURN(false); }; static int sql_get_double(void * ctx, double value, uint32 decimals) { char buffer[1024]; struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_get_double\n"); DBUG_ENTER("sql_get_double"); uint row= pctx->num_rows; uint col= pctx->current_col; pctx->current_col++; size_t len= my_snprintf(buffer, sizeof(buffer), "%3.7g", value); strncpy(pctx->sql_str_value[row][col], buffer, len); pctx->sql_str_len[row][col]= len; DBUG_RETURN(false); }; static int sql_get_date(void * ctx, const MYSQL_TIME * value) { char buffer[1024]; struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_get_date\n"); DBUG_ENTER("sql_get_date"); uint row= pctx->num_rows; uint col= pctx->current_col; pctx->current_col++; size_t len= my_snprintf(buffer, sizeof(buffer), "%s%4d-%02d-%02d", value->neg? "-":"", value->year, value->month, value->day); strncpy(pctx->sql_str_value[row][col], buffer, len); pctx->sql_str_len[row][col]= len; DBUG_RETURN(false); }; static int sql_get_time(void * ctx, const MYSQL_TIME * value, uint decimals) { char buffer[1024]; struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_get_time\n"); DBUG_ENTER("sql_get_time"); uint row= pctx->num_rows; uint col= pctx->current_col; pctx->current_col++; size_t len= my_snprintf(buffer, sizeof(buffer), "%s%02d:%02d:%02d", value->neg? "-":"", value->day? (value->day*24 + value->hour):value->hour, value->minute, value->second); strncpy(pctx->sql_str_value[row][col], buffer, len); pctx->sql_str_len[row][col]= len; DBUG_RETURN(false); }; static int sql_get_datetime(void * ctx, const MYSQL_TIME * value, uint decimals) { char buffer[1024]; struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_get_datetime\n"); DBUG_ENTER("sql_get_datetime"); uint row= pctx->num_rows; uint col= pctx->current_col; pctx->current_col++; size_t len= my_snprintf(buffer, sizeof(buffer), "%s%4d-%02d-%02d %02d:%02d:%02d", value->neg? "-":"", value->year, value->month, value->day, value->hour, value->minute, value->second); strncpy(pctx->sql_str_value[row][col], buffer, len); pctx->sql_str_len[row][col]= len; DBUG_RETURN(false); }; static int sql_get_string(void * ctx, const char * const value, size_t length, const CHARSET_INFO * const valuecs) { struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_get_string\n"); DBUG_ENTER("sql_get_string"); uint row= pctx->num_rows; uint col= pctx->current_col; pctx->current_col++; strncpy(pctx->sql_str_value[row][col], value, length); pctx->sql_str_len[row][col]= length; DBUG_RETURN(false); }; static void sql_handle_ok(void * ctx, uint server_status, uint statement_warn_count, ulonglong affected_rows, ulonglong last_insert_id, const char * const message) { struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_handle_ok\n"); DBUG_ENTER("sql_handle_ok"); /* This could be an EOF */ if (!pctx->num_cols) pctx->num_rows= 0; pctx->server_status= server_status; pctx->warn_count= statement_warn_count; pctx->affected_rows= affected_rows; pctx->last_insert_id= last_insert_id; if (message) strncpy(pctx->message, message, sizeof(pctx->message)); DBUG_VOID_RETURN; }; static void sql_handle_error(void * ctx, uint sql_errno, const char * const err_msg, const char * const sqlstate) { char buffer[1024]; struct st_plugin_ctx *pctx= (struct st_plugin_ctx*) ctx; // WRITE_STR("sql_handle_error\n"); DBUG_ENTER("sql_handle_error"); WRITE_VAL2("[%u][%s]", sql_errno, sqlstate); WRITE_VAL("[%s]", err_msg); pctx->num_rows= 0; DBUG_VOID_RETURN; }; static void sql_shutdown(void *ctx, int shutdown_server) { DBUG_ENTER("sql_shutdown"); DBUG_VOID_RETURN; }; const struct st_command_service_cbs protocol_callbacks= { sql_start_result_metadata, sql_field_metadata, sql_end_result_metadata, sql_start_row, sql_end_row, sql_abort_row, sql_get_client_capabilities, sql_get_null, sql_get_integer, sql_get_longlong, sql_get_decimal, sql_get_double, sql_get_date, sql_get_time, sql_get_datetime, sql_get_string, sql_handle_ok, sql_handle_error, sql_shutdown, }; /****************************************************************************************/ #define WRITE_DASHED_LINE() \ WRITE_STR("------------------------------------------------------------------\n"); static const char *fieldtype2str(enum enum_field_types type) { switch (type) { case MYSQL_TYPE_BIT: return "BIT"; case MYSQL_TYPE_BLOB: return "BLOB"; case MYSQL_TYPE_DATE: return "DATE"; case MYSQL_TYPE_DATETIME: return "DATETIME"; case MYSQL_TYPE_NEWDECIMAL: return "NEWDECIMAL"; case MYSQL_TYPE_DECIMAL: return "DECIMAL"; case MYSQL_TYPE_DOUBLE: return "DOUBLE"; case MYSQL_TYPE_ENUM: return "ENUM"; case MYSQL_TYPE_FLOAT: return "FLOAT"; case MYSQL_TYPE_GEOMETRY: return "GEOMETRY"; case MYSQL_TYPE_INT24: return "INT24"; case MYSQL_TYPE_LONG: return "LONG"; case MYSQL_TYPE_LONGLONG: return "LONGLONG"; case MYSQL_TYPE_LONG_BLOB: return "LONG_BLOB"; case MYSQL_TYPE_MEDIUM_BLOB: return "MEDIUM_BLOB"; case MYSQL_TYPE_NEWDATE: return "NEWDATE"; case MYSQL_TYPE_NULL: return "NULL"; case MYSQL_TYPE_SET: return "SET"; case MYSQL_TYPE_SHORT: return "SHORT"; case MYSQL_TYPE_STRING: return "STRING"; case MYSQL_TYPE_TIME: return "TIME"; case MYSQL_TYPE_TIMESTAMP: return "TIMESTAMP"; case MYSQL_TYPE_TINY: return "TINY"; case MYSQL_TYPE_TINY_BLOB: return "TINY_BLOB"; case MYSQL_TYPE_VARCHAR: return "VARCHAR"; case MYSQL_TYPE_VAR_STRING: return "VAR_STRING"; case MYSQL_TYPE_YEAR: return "YEAR"; default: return "?-unknown-?"; } } 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, " unknown=0x%04x", f); return buf; } static void dump_meta_field(st_send_field_n field) { char buffer[STRING_BUFFER_SIZE]; WRITE_VAL("\t\t\t[meta][field] db name: %s\n", field.db_name); WRITE_VAL("\t\t\t[meta][field] table name: %s\n",field.table_name); WRITE_VAL("\t\t\t[meta][field] org table name: %s\n",field.org_table_name); WRITE_VAL("\t\t\t[meta][field] col name: %s\n", field.col_name); WRITE_VAL("\t\t\t[meta][field] org col name: %s\n",field.org_col_name); WRITE_VAL("\t\t\t[meta][field] length: %u\n",(uint)field.length); WRITE_VAL("\t\t\t[meta][field] charsetnr: %u\n", field.charsetnr); WRITE_VAL("\t\t\t[meta][field] flags: %u", field.flags); if (field.flags) WRITE_VAL(" (%s)", fieldflags2str(field.flags)); WRITE_STR("\n"); WRITE_VAL("\t\t\t[meta][field] decimals: %u\n", field.decimals); WRITE_VAL2("\t\t\t[meta][field] type: %s (%u)\n", fieldtype2str(field.type), field.type); } static void dump_cs_info(const CHARSET_INFO *cs) { char buffer[STRING_BUFFER_SIZE]; if (!cs) { WRITE_STR("\t\t[meta] no charset\n"); return; } WRITE_VAL("\t\t[meta][charset result] number: %d\n", cs->number); WRITE_VAL("\t\t[meta][charset result] name: %s\n", cs->csname); WRITE_VAL("\t\t[meta][charset result] collation: %s\n",cs->name); WRITE_VAL("\t\t[meta][charset result] sort order: %s\n", cs->sort_order); } static void dump_decoded_server_status(const char *prefix, uint server_status) { char buffer[STRING_BUFFER_SIZE]; WRITE_STR(prefix); WRITE_VAL("%u\n", server_status); WRITE_STR(prefix); for (int i= 0; i < 30; i++) { uint flag= 1 << i; if (server_status & flag) { #define FLAG_DELIMITER " " switch (flag) { case SERVER_STATUS_IN_TRANS: WRITE_STR("IN_TRANS" FLAG_DELIMITER);break; case SERVER_STATUS_AUTOCOMMIT: WRITE_STR("AUTOCOMMIT" FLAG_DELIMITER);break; case SERVER_MORE_RESULTS_EXISTS: WRITE_STR("MORE_RESULTS_EXISTS" FLAG_DELIMITER);break; case SERVER_QUERY_NO_GOOD_INDEX_USED: WRITE_STR("QUERY_NO_GOOD_INDEX_USED" FLAG_DELIMITER);break; case SERVER_QUERY_NO_INDEX_USED: WRITE_STR("QUERY_NO_INDEX_USED" FLAG_DELIMITER);break; case SERVER_STATUS_CURSOR_EXISTS: WRITE_STR("CURSOR_EXISTS" FLAG_DELIMITER);break; case SERVER_STATUS_LAST_ROW_SENT: WRITE_STR("LAST_ROW_SENT" FLAG_DELIMITER);break; case SERVER_STATUS_DB_DROPPED: WRITE_STR("DB_DROPPED" FLAG_DELIMITER);break; case SERVER_STATUS_NO_BACKSLASH_ESCAPES:WRITE_STR("NO_BACKSLASH_ESCAPES" FLAG_DELIMITER);break; case SERVER_STATUS_METADATA_CHANGED: WRITE_STR("METADATA_CHANGED" FLAG_DELIMITER);break; case SERVER_QUERY_WAS_SLOW: WRITE_STR("QUERY_WAS_SLOW" FLAG_DELIMITER);break; case SERVER_PS_OUT_PARAMS: WRITE_STR("PS_OUT_PARAMS" FLAG_DELIMITER);break; case SERVER_STATUS_IN_TRANS_READONLY: WRITE_STR("IN_TRANS_READONLY" FLAG_DELIMITER);break; case SERVER_SESSION_STATE_CHANGED: WRITE_STR("STATE_CHANGED" FLAG_DELIMITER);break; default: // Add a new flag defined in mysql_com.h above to fix this WRITE_VAL("UNKNOWN_%u\n", flag); } #undef FLAG_DELIMITER } } WRITE_STR("\n"); } static void dump_meta_info(struct st_plugin_ctx *ctx) { char buffer[STRING_BUFFER_SIZE]; WRITE_VAL("\t\t[meta] rows: %u\n", ctx->num_rows); WRITE_VAL("\t\t[meta] cols: %u\n", ctx->num_cols); dump_decoded_server_status("\t\t[meta] server status: ", ctx->meta_server_status); WRITE_VAL("\t\t[meta] warning count: %u\n", ctx->meta_warn_count); WRITE_STR("\n"); if (!ctx->num_cols) { WRITE_STR("\t\t[meta] no columns\n"); } else for (uint col= 0; col < ctx->num_cols; col++) { dump_meta_field(ctx->sql_field[col]); WRITE_STR("\n"); } WRITE_STR("\n"); dump_cs_info(ctx->resultcs); } static void dump_result_set(struct st_plugin_ctx *ctx) { char buffer[STRING_BUFFER_SIZE]; if (!ctx->num_rows) WRITE_STR("\t\t[data] no rows\n"); for (uint row=0; row < ctx->num_rows; row++) { if (row) WRITE_STR("\n"); for (uint col=0; col < ctx->num_cols; col++) { WRITE_VAL2("\t\t[data][%s.%s]", ctx->sql_field[col].table_name, ctx->sql_field[col].col_name); WRITE_VAL2("[%3u][%s]\n", (uint) ctx->sql_str_len[row][col], ctx->sql_str_value[row][col]); } } } static void dump_closing_ok(struct st_plugin_ctx *ctx) { char buffer[STRING_BUFFER_SIZE]; dump_decoded_server_status("\t\t[end] server status: ", ctx->server_status); WRITE_VAL("\t\t[end] warning count: %u\n", ctx->warn_count); WRITE_VAL("\t\t[end] affected rows: %u\n", ctx->affected_rows); WRITE_VAL("\t\t[end] last insert id: %u\n", ctx->last_insert_id); WRITE_VAL("\t\t[end] message: %s\n", ctx->message); } static void set_query_in_com_data(const char *query, union COM_DATA *cmd) { char buffer[STRING_BUFFER_SIZE]; cmd->com_query.query= (char *) query; cmd->com_query.length= strlen(query); WRITE_VAL2("EXECUTING:[%u][%s]\n", cmd->com_query.length, query);\ } static void run_statement(MYSQL_SESSION session, const char *query, struct st_plugin_ctx *ctx, bool generates_result_set, void *p) { char buffer[STRING_BUFFER_SIZE]; COM_DATA cmd; WRITE_DASHED_LINE(); set_query_in_com_data(query, &cmd); enum cs_text_or_binary txt_or_bin= CS_TEXT_REPRESENTATION; WRITE_STR("[CS_TEXT_REPRESENTATION]\n"); again: ctx->reset(); int fail= command_service_run_command(session, COM_QUERY, &cmd, &my_charset_utf8_general_ci, &protocol_callbacks, txt_or_bin, ctx); if (fail) { my_plugin_log_message(&p, MY_ERROR_LEVEL, "run_statement code: %d\n", fail); return; } dump_meta_info(ctx); WRITE_STR("\n"); dump_result_set(ctx); WRITE_STR("\n"); dump_closing_ok(ctx); if (generates_result_set && txt_or_bin == CS_TEXT_REPRESENTATION) { txt_or_bin= CS_BINARY_REPRESENTATION; WRITE_STR("[CS_BINARY_REPRESENTATION]\n"); goto again; } } void static change_current_db(MYSQL_SESSION session, const char * db, struct st_plugin_ctx *ctx, void *p) { COM_DATA cmd; cmd.com_init_db.db_name= db; cmd.com_init_db.length= strlen(db); ctx->reset(); int fail= command_service_run_command(session, COM_INIT_DB, &cmd, &my_charset_utf8_general_ci, &protocol_callbacks, CS_TEXT_REPRESENTATION, ctx); if (fail) my_plugin_log_message(&p, MY_ERROR_LEVEL, "change db code: %d\n", fail); } void test_selects(MYSQL_SESSION session, void *p) { DBUG_ENTER("test_selects"); char buffer[STRING_BUFFER_SIZE]; struct st_plugin_ctx *plugin_ctx= new st_plugin_ctx(); const char *last_db= NULL; size_t stmt_count= sizeof(test_query_plan) / sizeof(test_query_plan[0]); for (size_t i= 0; i < stmt_count; i++) { /* Change current DB if needed */ if (last_db != test_query_plan[i].db) { last_db= test_query_plan[i].db; change_current_db(session, last_db? last_db:"", plugin_ctx, p); } run_statement(session, test_query_plan[i].query, plugin_ctx, test_query_plan[i].generates_result_set, p); } WRITE_DASHED_LINE(); delete plugin_ctx; DBUG_VOID_RETURN; } static const char *user_localhost = "localhost"; static const char *user_local = "127.0.0.1"; static const char *user_db= ""; static const char *user_privileged= "root"; //static const char *user_ordinary= "ordinary"; static void switch_user(MYSQL_SESSION session, const char *user) { MYSQL_SECURITY_CONTEXT sc; thd_get_security_context(srv_session_info_get_thd(session), &sc); security_context_lookup(sc, user, user_localhost, user_local, user_db); } static void test_sql(void *p) { DBUG_ENTER("test_sql"); char buffer[STRING_BUFFER_SIZE]; /* Session declarations */ MYSQL_SESSION session; /* Open session 1: Must pass */ WRITE_STR("[srv_session_open]\n"); session= srv_session_open(NULL, NULL); if (!session) { my_plugin_log_message(&p, MY_ERROR_LEVEL, "srv_session_open failed"); goto end; } switch_user(session, user_privileged); test_selects(session, p); /* close session 1: Must pass */ WRITE_STR("[srv_session_close]\n"); if (srv_session_close(session)) my_plugin_log_message(&p, MY_ERROR_LEVEL, "srv_session_close failed."); end: DBUG_VOID_RETURN; } struct test_thread_context { my_thread_handle thread; void *p; bool thread_finished; void (*test_function)(void *); }; static void* test_sql_threaded_wrapper(void *param) { char buffer[STRING_BUFFER_SIZE]; struct test_thread_context *context= (struct test_thread_context*) param; WRITE_SEP(); WRITE_STR("init thread\n"); if (srv_session_init_thread(context->p)) my_plugin_log_message(&context->p, MY_ERROR_LEVEL, "srv_session_init_thread failed."); context->test_function(context->p); WRITE_STR("deinit thread\n"); srv_session_deinit_thread(); context->thread_finished= true; return NULL; } static void create_log_file(const char * log_name) { char filename[FN_REFLEN]; fn_format(filename, log_name, "", ".log", MY_REPLACE_EXT | MY_UNPACK_FILENAME); unlink(filename); outfile= my_open(filename, O_CREAT|O_RDWR, MYF(0)); } static void test_in_spawned_thread(void *p, void (*test_function)(void *)) { my_thread_attr_t attr; /* Thread attributes */ my_thread_attr_init(&attr); (void) my_thread_attr_setdetachstate(&attr, MY_THREAD_CREATE_JOINABLE); struct test_thread_context context; context.p= p; context.thread_finished= false; context.test_function= test_function; /* now create the thread and call test_session within the thread. */ if (my_thread_create(&(context.thread), &attr, test_sql_threaded_wrapper, &context) != 0) my_plugin_log_message(&p, MY_ERROR_LEVEL, "Could not create test session thread"); else my_thread_join(&context.thread, NULL); } static int test_sql_service_plugin_init(void *p) { char buffer[STRING_BUFFER_SIZE]; DBUG_ENTER("test_sql_service_plugin_init"); my_plugin_log_message(&p, MY_INFORMATION_LEVEL, "Installation."); create_log_file(log_filename); WRITE_SEP(); WRITE_STR("Test in a server thread\n"); test_sql(p); /* Test in a new thread */ WRITE_STR("Follows threaded run\n"); test_in_spawned_thread(p, test_sql); my_close(outfile, MYF(0)); DBUG_RETURN(0); } static int test_sql_service_plugin_deinit(void *p) { DBUG_ENTER("test_sql_service_plugin_deinit"); my_plugin_log_message(&p, MY_INFORMATION_LEVEL, "Uninstallation."); DBUG_RETURN(0); } static struct st_mysql_daemon test_sql_service_plugin= { MYSQL_DAEMON_INTERFACE_VERSION }; /* Plugin library descriptor */ mysql_declare_plugin(test_daemon) { MYSQL_DAEMON_PLUGIN, &test_sql_service_plugin, "test_sql_complex", "Horst Hunger, Andrey Hristov", "Test sql complex", PLUGIN_LICENSE_GPL, test_sql_service_plugin_init, /* Plugin Init */ test_sql_service_plugin_deinit, /* Plugin Deinit */ 0x0100 /* 1.0 */, NULL, /* status variables */ NULL, /* system variables */ NULL, /* config options */ 0, /* flags */ } mysql_declare_plugin_end;