guoxin
/
test-example-projects
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
用于EagleEye3.0 规则集漏报和误报测试的示例项目，项目收集于github和gitee
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
0 Tags
722 MiB
Tag: Branch: Tree: 574f9c1e1d
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '574f9c1e1d'
${ noResults }
test-example-projects/c++_projects/280w-mysql-8.0.18/sql/sql_db.cc

1382 lines
48 KiB
Raw Normal View History Unescape

first commit
5 months ago
/*
Copyright (c) 2000, 2019, 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, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
/* create and drop of databases */
#include "sql/sql_db.h"
#include "my_config.h"
#include <errno.h>
#ifdef _WIN32
#include <direct.h>
#endif
#include <string.h>
#include <sys/types.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <atomic>
#include <set>
#include <vector>
#include "lex_string.h"
#include "m_ctype.h"
#include "m_string.h"
#include "my_command.h"
#include "my_dbug.h"
#include "my_dir.h"
#include "my_inttypes.h"
#include "my_io.h"
#include "my_macros.h"
#include "my_sys.h"
#include "my_thread_local.h"
#include "mysql/components/services/log_builtins.h"
#include "mysql/components/services/log_shared.h"
#include "mysql/psi/mysql_file.h"
#include "mysql/psi/mysql_mutex.h"
#include "mysql/service_mysql_alloc.h"
#include "mysql_com.h"
#include "mysqld_error.h"
#include "mysys_err.h" // EE_*
#include "sql/auth/auth_acls.h"
#include "sql/auth/auth_common.h" // SELECT_ACL
#include "sql/auth/sql_security_ctx.h"
#include "sql/binlog.h" // mysql_bin_log
#include "sql/dd/cache/dictionary_client.h" // Dictionary_client
#include "sql/dd/dd.h" // dd::get_dictionary()
#include "sql/dd/dd_schema.h" // dd::create_schema
#include "sql/dd/dd_table.h" // is_encrypted()
#include "sql/dd/dictionary.h" // dd::Dictionary
#include "sql/dd/string_type.h"
#include "sql/dd/types/abstract_table.h"
#include "sql/dd/types/schema.h"
#include "sql/dd/upgrade_57/upgrade.h" // dd::upgrade::in_progress
#include "sql/debug_sync.h" // DEBUG_SYNC
#include "sql/derror.h" // ER_THD
#include "sql/error_handler.h" // Drop_table_error_handler
#include "sql/events.h" // Events
#include "sql/handler.h"
#include "sql/lock.h" // lock_schema_name
#include "sql/log.h" // log_*()
#include "sql/log_event.h" // Query_log_event
#include "sql/mdl.h"
#include "sql/mysqld.h" // key_file_misc
#include "sql/psi_memory_key.h" // key_memory_THD_db
#include "sql/rpl_gtid.h"
#include "sql/session_tracker.h"
#include "sql/sp.h" // lock_db_routines
#include "sql/sql_base.h" // lock_table_names
#include "sql/sql_class.h" // THD
#include "sql/sql_const.h"
#include "sql/sql_error.h"
#include "sql/sql_handler.h" // mysql_ha_rm_tables
#include "sql/sql_table.h" // build_table_filename
#include "sql/system_variables.h"
#include "sql/table.h" // TABLE_LIST
#include "sql/thd_raii.h"
#include "sql/transaction.h" // trans_rollback_stmt
#include "sql_string.h"
#include "typelib.h"
/*
.frm is left in this list so that any orphan files can be removed on upgrade.
.SDI needs to be there for now... need to investigate why...
*/
const char *del_exts[] = {".frm", ".BAK", ".TMD", ".opt",
".OLD", ".cfg", ".SDI", NullS};
static TYPELIB deletable_extentions = {array_elements(del_exts) - 1, "del_exts",
del_exts, NULL};
static bool find_unknown_and_remove_deletable_files(THD *thd, MY_DIR *dirp,
const char *path);
static bool find_db_tables(THD *thd, const dd::Schema &schema, const char *db,
TABLE_LIST **tables);
static long mysql_rm_arc_files(THD *thd, MY_DIR *dirp, const char *org_path);
static bool rm_dir_w_symlink(const char *org_path, bool send_error);
static void mysql_change_db_impl(THD *thd, const LEX_CSTRING &new_db_name,
ulong new_db_access,
const CHARSET_INFO *new_db_charset);
bool get_default_db_collation(const dd::Schema &schema,
const CHARSET_INFO **collation) {
*collation = get_charset(schema.default_collation_id(), MYF(0));
if (*collation == nullptr) {
char buff[STRING_BUFFER_USUAL_SIZE];
my_error(ER_UNKNOWN_COLLATION, MYF(0),
llstr(schema.default_collation_id(), buff));
return true;
}
return false;
}
/**
Return default database collation.
@param thd Thread context.
@param db_name Database name.
@param [out] collation Charset object pointer if object exists else NULL.
@return false No error.
true Error (thd->is_error is assumed to be set.)
*/
bool get_default_db_collation(THD *thd, const char *db_name,
const CHARSET_INFO **collation) {
// We must make sure the schema is released and unlocked in the right order.
dd::Schema_MDL_locker mdl_handler(thd);
dd::cache::Dictionary_client::Auto_releaser releaser(thd->dd_client());
const dd::Schema *sch_obj = NULL;
if (mdl_handler.ensure_locked(db_name) ||
thd->dd_client()->acquire(db_name, &sch_obj))
return true;
if (sch_obj) return get_default_db_collation(*sch_obj, collation);
return false;
}
/**
Auxiliary function which writes CREATE/ALTER or DROP DATABASE statement
to the binary log overriding connection's current database with one
being dropped.
*/
static bool write_db_cmd_to_binlog(THD *thd, const char *db, bool trx_cache) {
if (mysql_bin_log.is_open()) {
int errcode = query_error_code(thd, true);
Query_log_event qinfo(thd, thd->query().str, thd->query().length, trx_cache,
false,
/* suppress_use */ true, errcode);
/*
Write should use the database being created/altered or dropped
as the "current database" and not the threads current database,
which is the default. If we do not change the "current database"
to the database being created/dropped, the CREATE/DROP statement
will not be replicated when using --binlog-do-db to select
databases to be replicated.
An example (--binlog-do-db=sisyfos):
CREATE DATABASE bob; # Not replicated
USE bob; # 'bob' is the current database
CREATE DATABASE sisyfos; # Not replicated since 'bob' is
# current database.
USE sisyfos; # Will give error on slave since
# database does not exist.
*/
qinfo.db = db;
qinfo.db_len = strlen(db);
thd->add_to_binlog_accessed_dbs(db);
return mysql_bin_log.write_event(&qinfo);
}
return false;
}
static void set_db_default_charset(const THD *thd,
HA_CREATE_INFO *create_info) {
if (create_info->default_table_charset == nullptr) {
create_info->default_table_charset = thd->variables.collation_server;
} else {
if (!(create_info->used_fields & HA_CREATE_USED_DEFAULT_COLLATE) &&
create_info->default_table_charset == &my_charset_utf8mb4_0900_ai_ci)
create_info->default_table_charset =
thd->variables.default_collation_for_utf8mb4;
}
}
/**
Create a database
@param thd Thread handler
@param db Name of database to create
Function assumes that this is already validated.
@param create_info Database create options (like character set)
SIDE-EFFECTS
1. Report back to client that command succeeded (my_ok)
2. Report errors to client
3. Log event to binary log
@retval false ok
@retval true Error
*/
bool mysql_create_db(THD *thd, const char *db, HA_CREATE_INFO *create_info) {
DBUG_TRACE;
/*
Use Auto_releaser to keep uncommitted object for database until
trans_commit() call.
*/
dd::cache::Dictionary_client::Auto_releaser releaser(thd->dd_client());
// Reject creation of the system schema except for system threads.
if (!thd->is_dd_system_thread() &&
dd::get_dictionary()->is_dd_schema_name(db) &&
!(create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)) {
my_error(ER_NO_SYSTEM_SCHEMA_ACCESS, MYF(0), db);
return true;
}
if (ha_check_reserved_db_name(db)) {
my_error(ER_WRONG_DB_NAME, MYF(0), db);
return true;
}
/*
Check if user has permission to alter database, if encryption type
provided differ from global 'default_table_encryption' setting.
We use 'default_table_encryption' value if encryption is not supplied
by user.
*/
bool encrypt_schema = false;
if (create_info->encrypt_type.str) {
encrypt_schema = dd::is_encrypted(create_info->encrypt_type);
} else {
encrypt_schema = thd->variables.default_table_encryption;
}
if (opt_table_encryption_privilege_check &&
encrypt_schema != thd->variables.default_table_encryption &&
check_table_encryption_admin_access(thd)) {
my_error(ER_CANNOT_SET_DATABASE_ENCRYPTION, MYF(0));
return true;
}
/*
When creating the schema, we must lock the schema name without case (for
correct MDL locking) when l_c_t_n == 2.
*/
char name_buf[NAME_LEN + 1];
const char *lock_db_name = db;
if (lower_case_table_names == 2) {
my_stpcpy(name_buf, db);
my_casedn_str(&my_charset_utf8_tolower_ci, name_buf);
lock_db_name = name_buf;
}
if (lock_schema_name(thd, lock_db_name)) return true;
dd::cache::Dictionary_client &dc = *thd->dd_client();
dd::String_type schema_name{db};
const dd::Schema *existing_schema = nullptr;
if (dc.acquire(schema_name, &existing_schema)) {
return true;
}
bool store_in_dd = true;
bool if_not_exists = (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS);
if (existing_schema != nullptr) {
if (if_not_exists == false) {
my_error(ER_DB_CREATE_EXISTS, MYF(0), db);
return true;
}
push_warning_printf(thd, Sql_condition::SL_NOTE, ER_DB_CREATE_EXISTS,
ER_THD(thd, ER_DB_CREATE_EXISTS), db);
store_in_dd = false;
}
/* Check directory */
char path[FN_REFLEN + 16];
bool was_truncated;
size_t path_len = build_table_filename(path, sizeof(path) - 1, db, "", "", 0,
&was_truncated);
if (was_truncated) {
my_error(ER_IDENT_CAUSES_TOO_LONG_PATH, MYF(0), sizeof(path) - 1, path);
return true;
}
path[path_len - 1] = 0; // Remove last '/' from path
// If we are creating the system schema, then we create it physically
// only during first time server initialization. During ordinary restart,
// we still execute the CREATE statement to initialize the meta data, but
// the physical representation of the schema is not re-created since it
// already exists.
MY_STAT stat_info;
bool schema_dir_exists =
(mysql_file_stat(key_file_misc, path, &stat_info, MYF(0)) != NULL);
if (thd->is_dd_system_thread() &&
(!opt_initialize || dd::upgrade_57::in_progress()) &&
dd::get_dictionary()->is_dd_schema_name(db)) {
/*
CREATE SCHEMA statement is being executed from bootstrap thread.
Server should either be in restart mode or upgrade mode to create only
dd::Schema object for the dictionary cache.
*/
if (!schema_dir_exists) {
my_printf_error(ER_BAD_DB_ERROR,
"System schema directory does not exist.", MYF(0));
return true;
}
} else if (store_in_dd) {
if (schema_dir_exists) {
my_error(ER_SCHEMA_DIR_EXISTS, MYF(0), path);
return true;
}
// Don't create folder inside data directory in case we are upgrading.
if (my_errno() != ENOENT) {
char errbuf[MYSYS_STRERROR_SIZE];
my_error(EE_STAT, MYF(0), path, my_errno(),
my_strerror(errbuf, sizeof(errbuf), my_errno()));
return true;
}
if (my_mkdir(path, 0777, MYF(0)) < 0) {
char errbuf[MYSQL_ERRMSG_SIZE];
my_error(ER_SCHEMA_DIR_CREATE_FAILED, MYF(0), db, my_errno(),
my_strerror(errbuf, MYSQL_ERRMSG_SIZE, my_errno()));
return true;
}
}
/*
Create schema in DD. This is done even when initializing the server
and creating the system schema. In that case, the shared cache will
store the object without storing it to disk. When the DD tables have
been created, the cached objects will be stored persistently.
*/
if (store_in_dd) {
set_db_default_charset(thd, create_info);
if (dd::create_schema(thd, db, create_info->default_table_charset,
encrypt_schema)) {
/*
We could be here due an deadlock or some error reported
by DD API framework. We remove the database directory
which we just created above.
It is expected that rm_dir_w_symlink() would not fail as
we already old MDL lock on database and no parallel
thread can remove the table before the current create
database operation. Even if the call fails due to some
other error we ignore the error as we anyway return
failure (true) here.
*/
if (!schema_dir_exists) rm_dir_w_symlink(path, true);
return true;
}
}
// Log the query in the handler's binlog
ha_binlog_log_query(thd, nullptr, LOGCOM_CREATE_DB, thd->query().str,
thd->query().length, db, "");
/*
If we have not added database to the data-dictionary we don't have
active transaction at this point. In this case we can't use
binlog's trx cache, which requires transaction with valid XID.
*/
if (write_db_cmd_to_binlog(thd, db, store_in_dd)) {
if (!schema_dir_exists) rm_dir_w_symlink(path, true);
return true;
}
/*
Do commit locally instead of relying on caller in order to be
able to remove directory in case of failure.
*/
if (trans_commit_stmt(thd) || trans_commit(thd)) {
if (!schema_dir_exists) rm_dir_w_symlink(path, true);
return true;
}
my_ok(thd, 1);
return false;
}
/* db-name is already validated when we come here */
bool mysql_alter_db(THD *thd, const char *db, HA_CREATE_INFO *create_info) {
DBUG_TRACE;
// Reject altering the system schema except for system threads.
if (!thd->is_dd_system_thread() &&
dd::get_dictionary()->is_dd_schema_name(db)) {
my_error(ER_NO_SYSTEM_SCHEMA_ACCESS, MYF(0), db);
return true;
}
/*
Check if user has permission to alter database, if encryption type
provided differ from global 'default_table_encryption' setting.
*/
if (create_info->encrypt_type.str && opt_table_encryption_privilege_check &&
dd::is_encrypted(create_info->encrypt_type) !=
thd->variables.default_table_encryption &&
check_table_encryption_admin_access(thd)) {
my_error(ER_CANNOT_SET_DATABASE_ENCRYPTION, MYF(0));
return true;
}
if (lock_schema_name(thd, db)) return true;
set_db_default_charset(thd, create_info);
dd::cache::Dictionary_client::Auto_releaser releaser(thd->dd_client());
dd::Schema *schema = nullptr;
if (thd->dd_client()->acquire_for_modification(db, &schema)) return true;
if (schema == nullptr) {
my_error(ER_NO_SUCH_DB, MYF(0), db);
return true;
}
// Set new collation ID.
schema->set_default_collation_id(create_info->default_table_charset->number);
// Set encryption type.
if (create_info->encrypt_type.length > 0)
schema->set_default_encryption(dd::is_encrypted(create_info->encrypt_type));
// Update schema.
if (thd->dd_client()->update(schema)) return true;
ha_binlog_log_query(thd, 0, LOGCOM_ALTER_DB, thd->query().str,
thd->query().length, db, "");
if (write_db_cmd_to_binlog(thd, db, true)) return true;
/*
Commit the statement locally instead of relying on caller,
in order to be sure that it is successfull, before changing
options of current database.
*/
if (trans_commit_stmt(thd) || trans_commit(thd)) return true;
/* Change options if current database is being altered. */
if (thd->db().str && !strcmp(thd->db().str, db)) {
thd->db_charset = create_info->default_table_charset
? create_info->default_table_charset
: thd->variables.collation_server;
thd->variables.collation_database = thd->db_charset;
}
my_ok(thd, 1);
return false;
}
/**
Error handler which converts errors during database directory removal
to warnings/messages to error log.
*/
class Rmdir_error_handler : public Internal_error_handler {
public:
Rmdir_error_handler() : m_is_active(false) {}
virtual bool handle_condition(THD *thd, uint, const char *,
Sql_condition::enum_severity_level *,
const char *msg) {
if (!m_is_active) {
/* Disable the handler to avoid infinite recursion. */
m_is_active = true;
push_warning_printf(thd, Sql_condition::SL_WARNING, ER_DB_DROP_RMDIR2,
ER_THD(thd, ER_DB_DROP_RMDIR2), msg);
LogErr(WARNING_LEVEL, ER_DROP_DATABASE_FAILED_RMDIR_MANUALLY, msg);
m_is_active = false;
return true;
}
return false;
}
private:
/**
Indicates that we are already in the process of handling
some error. Allows to re-emit error/warning from the error
handler without falling into infinite recursion.
*/
bool m_is_active;
};
/**
Drop all tables, routines and events in a database and the database itself.
@param thd Thread handle
@param db Database name in the case given by user
It's already validated and set to lower case
(if needed) when we come here
@param if_exists Don't give error if database doesn't exists
@note We do a "best effort" - try to drop as much as possible.
If dropping the database itself fails, we try to binlog
the drop of the tables we managed to do.
@retval false OK (Database dropped)
@retval true Error
*/
bool mysql_rm_db(THD *thd, const LEX_CSTRING &db, bool if_exists) {
ulong deleted_tables = 0;
bool error = false;
char path[2 * FN_REFLEN + 16];
TABLE_LIST *tables = NULL;
TABLE_LIST *table;
Drop_table_error_handler err_handler;
bool dropped_non_atomic = false;
std::set<handlerton *> post_ddl_htons;
Foreign_key_parents_invalidator fk_invalidator;
DBUG_TRACE;
dd::cache::Dictionary_client::Auto_releaser releaser(thd->dd_client());
// Reject dropping the system schema except for system threads.
if (!thd->is_dd_system_thread() &&
dd::get_dictionary()->is_dd_schema_name(dd::String_type(db.str))) {
my_error(ER_NO_SYSTEM_SCHEMA_ACCESS, MYF(0), db.str);
return true;
}
if (lock_schema_name(thd, db.str)) return true;
build_table_filename(path, sizeof(path) - 1, db.str, "", "", 0);
DEBUG_SYNC(thd, "before_acquire_in_drop_schema");
const dd::Schema *schema = nullptr;
if (thd->dd_client()->acquire(db.str, &schema)) return true;
DBUG_EXECUTE_IF("pretend_no_schema_in_drop_schema", { schema = nullptr; });
/* See if the directory exists */
MY_DIR *schema_dirp = my_dir(path, MYF(MY_DONT_SORT));
auto dirender = [](MY_DIR *dirp) { my_dirend(dirp); };
std::unique_ptr<MY_DIR, decltype(dirender)> grd{schema_dirp, dirender};
if (schema == nullptr) // Schema not found in DD
{
if (schema_dirp != nullptr) // Schema directory exists
{
// This is always an error, even when if_exists is true
my_error(ER_SCHEMA_DIR_UNKNOWN, MYF(0), db.str, path);
return true;
}
if (!if_exists) // IF EXISTS not given
{
my_error(ER_DB_DROP_EXISTS, MYF(0), db.str);
return true;
}
push_warning_printf(thd, Sql_condition::SL_NOTE, ER_DB_DROP_EXISTS,
ER_THD(thd, ER_DB_DROP_EXISTS), db.str);
/*
We don't have active transaction at this point so we can't use
binlog's trx cache, which requires transaction with valid XID.
*/
if (write_db_cmd_to_binlog(thd, db.str, false)) return true;
if (trans_commit_stmt(thd) || trans_commit_implicit(thd)) return true;
/* Fall-through to resetting current database in connection. */
} else // Schema found in DD
{
/* Database directory does not exist. */
if (schema_dirp == nullptr) {
if (!if_exists) {
my_error(ER_SCHEMA_DIR_MISSING, MYF(0), path);
return true;
}
push_warning_printf(thd, Sql_condition::SL_NOTE, ER_SCHEMA_DIR_MISSING,
ER_THD(thd, ER_SCHEMA_DIR_MISSING), path);
} else {
if (find_unknown_and_remove_deletable_files(thd, schema_dirp, path)) {
return true;
}
}
if (find_db_tables(thd, *schema, db.str, &tables)) {
return true;
}
/* Lock all tables and stored routines about to be dropped. */
if (lock_table_names(thd, tables, NULL, thd->variables.lock_wait_timeout,
0) ||
rm_table_do_discovery_and_lock_fk_tables(thd, tables) ||
lock_check_constraint_names(thd, tables) ||
Events::lock_schema_events(thd, *schema) ||
lock_db_routines(thd, *schema) || lock_trigger_names(thd, tables))
return true;
/* mysql_ha_rm_tables() requires a non-null TABLE_LIST. */
if (tables) mysql_ha_rm_tables(thd, tables);
for (table = tables; table; table = table->next_local) {
deleted_tables++;
}
if (thd->killed) return true;
thd->push_internal_handler(&err_handler);
if (tables)
error = mysql_rm_table_no_locks(thd, tables, true, false, true,
&dropped_non_atomic, &post_ddl_htons,
&fk_invalidator, nullptr);
DBUG_EXECUTE_IF("rm_db_fail_after_dropping_tables", {
my_error(ER_UNKNOWN_ERROR, MYF(0));
error = true;
});
if (!error) {
/*
We temporarily disable the binary log while dropping SPs
in the database. Since the DROP DATABASE statement is always
replicated as a statement, execution of it will drop all objects
in the database on the slave as well, so there is no need to
replicate the removal of the individual objects in the database
as well.
This is more of a safety precaution, since normally no objects
should be dropped while the database is being cleaned, but in
the event that a change in the code to remove other objects is
made, these drops should still not be logged.
Notice that the binary log have to be enabled over the call to
ha_drop_database(), since NDB otherwise detects the binary log
as disabled and will not log the drop database statement on any
other connected server.
*/
ha_drop_database(path);
thd->clear_error(); /* @todo Do not ignore errors */
Disable_binlog_guard binlog_guard(thd);
error = Events::drop_schema_events(thd, *schema);
error = (error || (sp_drop_db_routines(thd, *schema) != SP_OK));
}
thd->pop_internal_handler();
if (!error) error = thd->dd_client()->drop(schema);
/*
If database exists and there was no error we should
write statement to binary log and remove DD entry.
*/
if (!error) error = write_db_cmd_to_binlog(thd, db.str, true);
if (!error) error = trans_commit_stmt(thd) || trans_commit(thd);
/*
In case of error rollback the transaction in order to revert
changes which are possible to rollback (e.g. removal of tables
in SEs supporting atomic DDL, events and routines).
*/
if (error) {
trans_rollback_stmt(thd);
/*
Play safe to be sure that THD::transaction_rollback_request is
cleared before work-around code below is run. This also necessary
to synchronize state of data-dicitionary on disk and in cache (to
clear cache of uncommitted objects).
*/
trans_rollback_implicit(thd);
}
/*
Call post-DDL handlerton hook. For engines supporting atomic DDL
tables' files are removed from disk on this step.
*/
for (handlerton *hton : post_ddl_htons) hton->post_ddl(thd);
fk_invalidator.invalidate(thd);
/*
Now we can try removing database directory.
If the directory is a symbolic link, remove the link first, then
remove the directory the symbolic link pointed at.
This can happen only after post-DDL handlerton hook removes files
from the directory.
Since the statement is committed already, we do not report unlikely
failure to remove the directory as an error. Instead we report it
as a warning, which is sent to user and written to server error log.
*/
if (!error && schema_dirp != nullptr) {
Rmdir_error_handler rmdir_handler;
thd->push_internal_handler(&rmdir_handler);
(void)rm_dir_w_symlink(path, true);
thd->pop_internal_handler();
}
if (error) {
if (mysql_bin_log.is_open()) {
/*
If GTID_NEXT=='UUID:NUMBER', we must not log an incomplete
statement. However, the incomplete DROP has already 'committed'
(some tables were removed). So we generate an error and let
user fix the situation.
*/
if (thd->variables.gtid_next.type == ASSIGNED_GTID &&
dropped_non_atomic) {
char gtid_buf[Gtid::MAX_TEXT_LENGTH + 1];
thd->variables.gtid_next.gtid.to_string(global_sid_map, gtid_buf,
true);
my_error(ER_CANNOT_LOG_PARTIAL_DROP_DATABASE_WITH_GTID, MYF(0), path,
gtid_buf, db.str);
return true;
}
}
return true;
}
}
/*
If this database was the client's selected database, we silently
change the client's selected database to nothing (to have an empty
SELECT DATABASE() in the future). For this we free() thd->db and set
it to 0.
*/
if (thd->db().str && !strcmp(thd->db().str, db.str)) {
mysql_change_db_impl(thd, NULL_CSTR, 0, thd->variables.collation_server);
/*
Check if current database tracker is enabled. If so, set the 'changed'
flag.
*/
if (thd->session_tracker.get_tracker(CURRENT_SCHEMA_TRACKER)
->is_enabled()) {
LEX_CSTRING dummy = {STRING_WITH_LEN("")};
dummy.length = dummy.length * 1;
thd->session_tracker.get_tracker(CURRENT_SCHEMA_TRACKER)
->mark_as_changed(thd, &dummy);
}
}
thd->server_status |= SERVER_STATUS_DB_DROPPED;
my_ok(thd, deleted_tables);
return false;
}
/**
Auxiliary function which checks if database directory has any
files which won't be deleted automatically - either because
we know that these are temporary/backup files which are safe
for delete or by dropping the tables in the database.
Also deletes various temporary/backup files which are known to
be safe to delete.
*/
static bool find_unknown_and_remove_deletable_files(THD *thd, MY_DIR *dirp,
const char *path) {
char filePath[FN_REFLEN];
DBUG_TRACE;
DBUG_PRINT("enter", ("path: %s", path));
TYPELIB *known_extensions = ha_known_exts();
for (uint idx = 0; idx < dirp->number_off_files && !thd->killed; idx++) {
FILEINFO *file = dirp->dir_entry + idx;
char *extension;
DBUG_PRINT("info", ("Examining: %s", file->name));
/* skiping . and .. */
if (file->name[0] == '.' &&
(!file->name[1] || (file->name[1] == '.' && !file->name[2])))
continue;
if (file->name[0] == 'a' && file->name[1] == 'r' && file->name[2] == 'c' &&
file->name[3] == '\0') {
/* .frm archive:
Those archives are obsolete, but following code should
exist to remove existent "arc" directories.
*/
char newpath[FN_REFLEN];
MY_DIR *new_dirp;
strxmov(newpath, path, "/", "arc", NullS);
(void)unpack_filename(newpath, newpath);
if ((new_dirp = my_dir(newpath, MYF(MY_DONT_SORT)))) {
DBUG_PRINT("my", ("Archive subdir found: %s", newpath));
if ((mysql_rm_arc_files(thd, new_dirp, newpath)) < 0) return true;
continue;
}
goto found_other_files;
}
if (!(extension = strrchr(file->name, '.'))) extension = strend(file->name);
if (find_type(extension, &deletable_extentions, FIND_TYPE_NO_PREFIX) <= 0) {
if (find_type(extension, known_extensions, FIND_TYPE_NO_PREFIX) <= 0)
goto found_other_files;
continue;
}
strxmov(filePath, path, "/", file->name, NullS);
/*
We ignore ENOENT error in order to skip files that was deleted
by concurrently running statement like REAPIR TABLE ...
*/
if (my_delete_with_symlink(filePath, MYF(0)) && my_errno() != ENOENT) {
char errbuf[MYSYS_STRERROR_SIZE];
my_error(EE_DELETE, MYF(0), filePath, my_errno(),
my_strerror(errbuf, sizeof(errbuf), my_errno()));
return true;
}
}
return false;
found_other_files:
char errbuf[MYSQL_ERRMSG_SIZE];
my_error(ER_DB_DROP_RMDIR, MYF(0), path, EEXIST,
my_strerror(errbuf, MYSQL_ERRMSG_SIZE, EEXIST));
return true;
}
/**
Auxiliary function which retrieves list of all tables in the database
from the data-dictionary.
*/
static bool find_db_tables(THD *thd, const dd::Schema &schema, const char *db,
TABLE_LIST **tables) {
TABLE_LIST *tot_list = 0, **tot_list_next_local, **tot_list_next_global;
DBUG_TRACE;
tot_list_next_local = tot_list_next_global = &tot_list;
std::vector<dd::String_type> sch_tables;
/*
Skip tables which are implicitly created and dropped by SE (e.g.
InnoDB's auxiliary tables for FTS). Other hidden tables (e.g.
left-over #sql... tables from crashed non-atomic ALTER TABLEs)
should be dropped by DROP DATABASE.
*/
if (thd->dd_client()->fetch_schema_table_names_not_hidden_by_se(&schema,
&sch_tables))
return true;
for (const dd::String_type table_name : sch_tables) {
TABLE_LIST *table_list = new (thd->mem_root) TABLE_LIST;
if (table_list == nullptr) return true; /* purecov: inspected */
table_list->db = thd->mem_strdup(db);
table_list->db_length = strlen(db);
table_list->table_name = thd->mem_strdup(table_name.c_str());
table_list->table_name_length = table_name.length();
table_list->open_type = OT_BASE_ONLY;
/* To be able to correctly look up the table in the table cache. */
if (lower_case_table_names)
my_casedn_str(files_charset_info,
const_cast<char *>(table_list->table_name));
table_list->alias = table_list->table_name; // If lower_case_table_names=2
table_list->internal_tmp_table =
is_prefix(table_name.c_str(), tmp_file_prefix);
MDL_REQUEST_INIT(&table_list->mdl_request, MDL_key::TABLE, table_list->db,
table_list->table_name, MDL_EXCLUSIVE, MDL_TRANSACTION);
/* Link into list */
(*tot_list_next_local) = table_list;
(*tot_list_next_global) = table_list;
tot_list_next_local = &table_list->next_local;
tot_list_next_global = &table_list->next_global;
}
*tables = tot_list;
return false;
}
/*
Remove directory with symlink
SYNOPSIS
rm_dir_w_symlink()
org_path path of derictory
send_error send errors
RETURN
0 OK
1 ERROR
*/
static bool rm_dir_w_symlink(const char *org_path, bool send_error) {
char tmp_path[FN_REFLEN], *pos;
char *path = tmp_path;
DBUG_TRACE;
unpack_filename(tmp_path, org_path);
#ifndef _WIN32
int error;
char tmp2_path[FN_REFLEN];
/* Remove end FN_LIBCHAR as this causes problem on Linux in readlink */
pos = strend(path);
if (pos > path && pos[-1] == FN_LIBCHAR) *--pos = 0;
if ((error = my_readlink(tmp2_path, path, MYF(MY_WME))) < 0) return 1;
if (!error) {
if (mysql_file_delete(key_file_misc, path, MYF(send_error ? MY_WME : 0))) {
return send_error;
}
/* Delete directory symbolic link pointed at */
path = tmp2_path;
}
#endif
/* Remove last FN_LIBCHAR to not cause a problem on OS/2 */
pos = strend(path);
if (pos > path && pos[-1] == FN_LIBCHAR) *--pos = 0;
if (rmdir(path) < 0 && send_error) {
char errbuf[MYSQL_ERRMSG_SIZE];
my_error(ER_DB_DROP_RMDIR, MYF(0), path, errno,
my_strerror(errbuf, MYSQL_ERRMSG_SIZE, errno));
return 1;
}
return 0;
}
/*
Remove .frm archives from directory
SYNOPSIS
thd thread handler
dirp list of files in archive directory
db data base name
org_path path of archive directory
RETURN
> 0 number of removed files
-1 error
NOTE
A support of "arc" directories is obsolete, however this
function should exist to remove existent "arc" directories.
*/
long mysql_rm_arc_files(THD *thd, MY_DIR *dirp, const char *org_path) {
long deleted = 0;
ulong found_other_files = 0;
char filePath[FN_REFLEN];
DBUG_TRACE;
DBUG_PRINT("enter", ("path: %s", org_path));
for (uint idx = 0; idx < dirp->number_off_files && !thd->killed; idx++) {
FILEINFO *file = dirp->dir_entry + idx;
char *extension, *revision;
DBUG_PRINT("info", ("Examining: %s", file->name));
/* skiping . and .. */
if (file->name[0] == '.' &&
(!file->name[1] || (file->name[1] == '.' && !file->name[2])))
continue;
extension = fn_ext(file->name);
if (extension[0] != '.' || extension[1] != 'f' || extension[2] != 'r' ||
extension[3] != 'm' || extension[4] != '-') {
found_other_files++;
continue;
}
revision = extension + 5;
while (*revision && my_isdigit(system_charset_info, *revision)) revision++;
if (*revision) {
found_other_files++;
continue;
}
strxmov(filePath, org_path, "/", file->name, NullS);
if (mysql_file_delete_with_symlink(key_file_misc, filePath, MYF(MY_WME))) {
goto err;
}
deleted++;
}
if (thd->killed) goto err;
my_dirend(dirp);
/*
If the directory is a symbolic link, remove the link first, then
remove the directory the symbolic link pointed at
*/
if (!found_other_files && rm_dir_w_symlink(org_path, 0)) return -1;
return deleted;
err:
my_dirend(dirp);
return -1;
}
/**
@brief Internal implementation: switch current database to a valid one.
@param thd Thread context.
@param new_db_name Name of the database to switch to. The function will
take ownership of the name (the caller must not free
the allocated memory). If the name is NULL, we're
going to switch to NULL db.
@param new_db_access Privileges of the new database. (with roles)
@param new_db_charset Character set of the new database.
*/
static void mysql_change_db_impl(THD *thd, const LEX_CSTRING &new_db_name,
ulong new_db_access,
const CHARSET_INFO *new_db_charset) {
/* 1. Change current database in THD. */
if (new_db_name.str == NULL) {
/*
THD::set_db() does all the job -- it frees previous database name and
sets the new one.
*/
thd->set_db(NULL_CSTR);
} else if (!strcmp(new_db_name.str, INFORMATION_SCHEMA_NAME.str)) {
/*
Here we must use THD::set_db(), because we want to copy
INFORMATION_SCHEMA_NAME constant.
*/
thd->set_db(INFORMATION_SCHEMA_NAME);
} else {
/*
Here we already have a copy of database name to be used in THD. So,
we just call THD::reset_db(). Since THD::reset_db() does not releases
the previous database name, we should do it explicitly.
*/
mysql_mutex_lock(&thd->LOCK_thd_data);
if (thd->db().str) my_free(const_cast<char *>(thd->db().str));
DEBUG_SYNC(thd, "after_freeing_thd_db");
thd->reset_db(new_db_name);
mysql_mutex_unlock(&thd->LOCK_thd_data);
}
/* 2. Update security context. */
/* Cache the effective schema level privilege with roles applied */
thd->security_context()->cache_current_db_access(new_db_access);
/* 3. Update db-charset environment variables. */
thd->db_charset = new_db_charset;
thd->variables.collation_database = new_db_charset;
}
/**
Backup the current database name before switch.
@param[in] thd thread handle
@param[in, out] saved_db_name IN: "str" points to a buffer where to store
the old database name, "length" contains the
buffer size
OUT: if the current (default) database is
not NULL, its name is copied to the
buffer pointed at by "str"
and "length" is updated accordingly.
Otherwise "str" is set to NULL and
"length" is set to 0.
*/
static void backup_current_db_name(THD *thd, LEX_STRING *saved_db_name) {
if (!thd->db().str) {
/* No current (default) database selected. */
saved_db_name->str = NULL;
saved_db_name->length = 0;
} else {
strmake(saved_db_name->str, thd->db().str, saved_db_name->length - 1);
saved_db_name->length = thd->db().length;
}
}
/**
Return true if db1_name is equal to db2_name, false otherwise.
The function allows to compare database names according to the MySQL
rules. The database names db1 and db2 are equal if:
- db1 is NULL and db2 is NULL;
or
- db1 is not-NULL, db2 is not-NULL, db1 is equal (ignoring case) to
db2 in system character set (UTF8).
*/
static inline bool cmp_db_names(const char *db1_name, const char *db2_name) {
return
/* db1 is NULL and db2 is NULL */
(!db1_name && !db2_name) ||
/* db1 is not-NULL, db2 is not-NULL, db1 == db2. */
(db1_name && db2_name &&
my_strcasecmp(system_charset_info, db1_name, db2_name) == 0);
}
/**
@brief Change the current database and its attributes unconditionally.
@param thd thread handle
@param new_db_name database name
@param force_switch if force_switch is false, then the operation will fail if
- new_db_name is NULL or empty;
- OR new database name is invalid
(check_db_name() failed);
- OR user has no privilege on the new database;
- OR new database does not exist;
if force_switch is true, then
- if new_db_name is NULL or empty, the current
database will be NULL, @@collation_database will
be set to @@collation_server, the operation will
succeed.
- if new database name is invalid
(check_db_name() failed), the current database
will be NULL, @@collation_database will be set to
@@collation_server, but the operation will fail;
- user privileges will not be checked
(THD::db_access however is updated);
TODO: is this really the intention?
(see sp-security.test).
- if new database does not exist,the current database
will be NULL, @@collation_database will be set to
@@collation_server, a warning will be thrown, the
operation will succeed.
@details The function checks that the database name corresponds to a
valid and existent database, checks access rights and changes the current
database with database attributes (@@collation_database session variable,
THD::db_access).
This function is not the only way to switch the database that is
currently employed. When the replication slave thread switches the
database before executing a query, it calls thd->set_db directly.
However, if the query, in turn, uses a stored routine, the stored routine
will use this function, even if it's run on the slave.
This function allocates the name of the database on the system heap: this
is necessary to be able to uniformly change the database from any module
of the server. Up to 5.0 different modules were using different memory to
store the name of the database, and this led to memory corruption:
a stack pointer set by Stored Procedures was used by replication after
the stack address was long gone.
@return Operation status
@retval false Success
@retval true Error
*/
bool mysql_change_db(THD *thd, const LEX_CSTRING &new_db_name,
bool force_switch) {
LEX_STRING new_db_file_name;
LEX_CSTRING new_db_file_name_cstr;
Security_context *sctx = thd->security_context();
ulong db_access = sctx->current_db_access();
const CHARSET_INFO *db_default_cl = NULL;
// We must make sure the schema is released and unlocked in the right order.
dd::Schema_MDL_locker mdl_handler(thd);
dd::cache::Dictionary_client::Auto_releaser releaser(thd->dd_client());
const dd::Schema *schema = nullptr;
DBUG_TRACE;
DBUG_PRINT("enter", ("name: '%s'", new_db_name.str));
if (new_db_name.str == NULL || new_db_name.length == 0) {
if (force_switch) {
/*
This can happen only if we're switching the current database back
after loading stored program. The thing is that loading of stored
program can happen when there is no current database.
TODO: actually, new_db_name and new_db_name->str seem to be always
non-NULL. In case of stored program, new_db_name->str == "" and
new_db_name->length == 0.
*/
mysql_change_db_impl(thd, NULL_CSTR, 0, thd->variables.collation_server);
goto done;
} else {
my_error(ER_NO_DB_ERROR, MYF(0));
return true;
}
}
if (is_infoschema_db(new_db_name.str, new_db_name.length)) {
/* Switch the current database to INFORMATION_SCHEMA. */
mysql_change_db_impl(thd, INFORMATION_SCHEMA_NAME, SELECT_ACL,
system_charset_info);
goto done;
}
/*
Now we need to make a copy because check_db_name requires a
non-constant argument. Actually, it takes database file name.
TODO: fix check_db_name().
*/
new_db_file_name.str = my_strndup(key_memory_THD_db, new_db_name.str,
new_db_name.length, MYF(MY_WME));
new_db_file_name.length = new_db_name.length;
if (new_db_file_name.str == NULL) return true; /* the error is set */
/*
NOTE: if check_db_name() fails, we should throw an error in any case,
even if we are called from sp_head::execute().
It's next to impossible however to get this error when we are called
from sp_head::execute(). But let's switch the current database to NULL
in this case to be sure.
*/
if (check_and_convert_db_name(&new_db_file_name, false) !=
Ident_name_check::OK) {
my_free(new_db_file_name.str);
if (force_switch)
mysql_change_db_impl(thd, NULL_CSTR, 0, thd->variables.collation_server);
return true;
}
new_db_file_name_cstr.str = new_db_file_name.str;
new_db_file_name_cstr.length = new_db_file_name.length;
DBUG_PRINT("info", ("Use database: %s", new_db_file_name.str));
if (sctx->get_active_roles()->size() == 0) {
db_access =
sctx->check_access(DB_OP_ACLS, new_db_file_name.str)
? DB_OP_ACLS
: acl_get(thd, sctx->host().str, sctx->ip().str,
sctx->priv_user().str, new_db_file_name.str, false) |
sctx->master_access(new_db_file_name.str);
} else {
db_access = sctx->db_acl(new_db_file_name_cstr) |
sctx->master_access(new_db_file_name.str);
}
if (!force_switch && !(db_access & DB_OP_ACLS) &&
check_grant_db(thd, new_db_file_name.str)) {
my_error(ER_DBACCESS_DENIED_ERROR, MYF(0), sctx->priv_user().str,
sctx->priv_host().str, new_db_file_name.str);
query_logger.general_log_print(
thd, COM_INIT_DB, ER_DEFAULT(ER_DBACCESS_DENIED_ERROR),
sctx->priv_user().str, sctx->priv_host().str, new_db_file_name.str);
my_free(new_db_file_name.str);
return true;
}
if (mdl_handler.ensure_locked(new_db_file_name.str) ||
thd->dd_client()->acquire(new_db_file_name.str, &schema)) {
my_free(new_db_file_name.str);
return true;
}
DEBUG_SYNC(thd, "acquired_schema_while_getting_collation");
if (schema == nullptr) {
if (force_switch) {
/* Throw a warning and free new_db_file_name. */
push_warning_printf(thd, Sql_condition::SL_NOTE, ER_BAD_DB_ERROR,
ER_THD(thd, ER_BAD_DB_ERROR), new_db_file_name.str);
my_free(new_db_file_name.str);
/* Change db to NULL. */
mysql_change_db_impl(thd, NULL_CSTR, 0, thd->variables.collation_server);
/* The operation succeed. */
goto done;
} else {
/* Report an error and free new_db_file_name. */
my_error(ER_BAD_DB_ERROR, MYF(0), new_db_file_name.str);
my_free(new_db_file_name.str);
/* The operation failed. */
return true;
}
}
if (get_default_db_collation(*schema, &db_default_cl)) {
my_free(new_db_file_name.str);
DBUG_ASSERT(thd->is_error() || thd->killed);
return true;
}
db_default_cl = db_default_cl ? db_default_cl : thd->collation();
/*
NOTE: in mysql_change_db_impl() new_db_file_name is assigned to THD
attributes and will be freed in THD::~THD().
*/
mysql_change_db_impl(thd, new_db_file_name_cstr, db_access, db_default_cl);
done:
/*
Check if current database tracker is enabled. If so, set the 'changed' flag.
*/
if (thd->session_tracker.get_tracker(CURRENT_SCHEMA_TRACKER)->is_enabled()) {
LEX_CSTRING dummy = {STRING_WITH_LEN("")};
dummy.length = dummy.length * 1;
thd->session_tracker.get_tracker(CURRENT_SCHEMA_TRACKER)
->mark_as_changed(thd, &dummy);
}
if (thd->session_tracker.get_tracker(SESSION_STATE_CHANGE_TRACKER)
->is_enabled())
thd->session_tracker.get_tracker(SESSION_STATE_CHANGE_TRACKER)
->mark_as_changed(thd, NULL);
return false;
}
/**
Change the current database and its attributes if needed.
@param thd thread handle
@param new_db_name database name
@param[in, out] saved_db_name IN: "str" points to a buffer where to store
the old database name, "length" contains the
buffer size
OUT: if the current (default) database is
not NULL, its name is copied to the
buffer pointed at by "str"
and "length" is updated accordingly.
Otherwise "str" is set to NULL and
"length" is set to 0.
@param force_switch @see mysql_change_db()
@param[out] cur_db_changed out-flag to indicate whether the current
database has been changed (valid only if
the function suceeded)
*/
bool mysql_opt_change_db(THD *thd, const LEX_CSTRING &new_db_name,
LEX_STRING *saved_db_name, bool force_switch,
bool *cur_db_changed) {
*cur_db_changed = !cmp_db_names(thd->db().str, new_db_name.str);
if (!*cur_db_changed) return false;
backup_current_db_name(thd, saved_db_name);
return mysql_change_db(thd, new_db_name, force_switch);
}