266 lines
9.5 KiB
C++
266 lines
9.5 KiB
C++
/*
|
|
Copyright (c) 2015, 2017, 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 "mysqldump_tool_chain_maker_options.h"
|
|
#include <boost/algorithm/string.hpp>
|
|
|
|
using namespace Mysql::Tools::Dump;
|
|
|
|
void Mysqldump_tool_chain_maker_options::parallel_schemas_callback(char*)
|
|
{
|
|
std::vector<std::string> schemas;
|
|
boost::split(schemas, m_parallel_schemas_string.value(),
|
|
boost::is_any_of(","), boost::token_compress_on);
|
|
if (schemas.size() == 0)
|
|
return;
|
|
int threads= 0;
|
|
std::string& first_part= schemas[0];
|
|
size_t i;
|
|
for (i=0; i < first_part.size() && first_part[i] >= '0'
|
|
&& first_part[i] <= '9'; ++i)
|
|
{
|
|
threads= threads * 10 + first_part[i] - '0';
|
|
}
|
|
if (i < first_part.size() && first_part[i] == ':')
|
|
{
|
|
first_part= first_part.substr(i + 1);
|
|
}
|
|
else
|
|
{
|
|
threads= 0;
|
|
}
|
|
if (threads)
|
|
m_parallel_thread_count+= threads;
|
|
else
|
|
m_def_thread_count++;
|
|
m_last_parallel_schemas_queue_id++;
|
|
m_object_queue_threads.insert(std::make_pair(
|
|
m_last_parallel_schemas_queue_id, threads));
|
|
|
|
for (std::vector<std::string>::iterator it= schemas.begin();
|
|
it != schemas.end(); ++it)
|
|
{
|
|
m_database_to_object_queue_id.insert(std::make_pair(
|
|
*it, m_last_parallel_schemas_queue_id));
|
|
}
|
|
}
|
|
|
|
bool Mysqldump_tool_chain_maker_options::is_object_included_in_dump(
|
|
Abstract_data_object* object)
|
|
{
|
|
return m_object_filter.is_object_included_in_dump(object);
|
|
}
|
|
|
|
int Mysqldump_tool_chain_maker_options::get_object_queue_threads_count(
|
|
int object_queue_id)
|
|
{
|
|
std::map<int, int>::iterator it=
|
|
m_object_queue_threads.find(object_queue_id);
|
|
if (it != m_object_queue_threads.end() && it->second != 0)
|
|
{
|
|
return it->second;
|
|
}
|
|
return m_default_parallelism;
|
|
}
|
|
|
|
int Mysqldump_tool_chain_maker_options::get_object_queue_id_for_schema(
|
|
const std::string& schema)
|
|
{
|
|
std::map<std::string, int>::iterator it=
|
|
m_database_to_object_queue_id.find(schema);
|
|
if (it != m_database_to_object_queue_id.end())
|
|
{
|
|
return it->second;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void Mysqldump_tool_chain_maker_options::process_positional_options(
|
|
std::vector<std::string> positional_options)
|
|
{
|
|
if ((m_dump_all_databases ? 1 : 0) + (m_dump_selected_databases ? 1 : 0) > 1)
|
|
{
|
|
m_mysql_chain_element_options->get_program()->error(
|
|
Mysql::Tools::Base::Message_data(1, "Usage of --all-databases and "
|
|
"--databases are mutually exclusive.",
|
|
Mysql::Tools::Base::Message_type_error));
|
|
}
|
|
else if (m_dump_all_databases
|
|
|| (!m_dump_selected_databases && positional_options.size() == 0))
|
|
{
|
|
if (positional_options.size() > 0)
|
|
{
|
|
m_mysql_chain_element_options->get_program()->error(
|
|
Mysql::Tools::Base::Message_data(1, "Positional options specified, "
|
|
"while disalowed by usage of --all-databases.",
|
|
Mysql::Tools::Base::Message_type_error));
|
|
}
|
|
}
|
|
else if (m_dump_selected_databases)
|
|
{
|
|
if (positional_options.size() < 1)
|
|
{
|
|
m_mysql_chain_element_options->get_program()->error(
|
|
Mysql::Tools::Base::Message_data(1, "No positional options "
|
|
"specified, while expected by usage of --databases.",
|
|
Mysql::Tools::Base::Message_type_error));
|
|
}
|
|
else
|
|
{
|
|
for (int i= positional_options.size(); --i >= 0;)
|
|
m_object_filter.m_databases_included.push_back(
|
|
std::make_pair("", positional_options[i]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::string db_name= positional_options[0];
|
|
|
|
m_object_filter.m_databases_included.push_back(std::make_pair(
|
|
"", db_name));
|
|
for (int i= positional_options.size(); --i >= 1;)
|
|
m_object_filter.m_tables_included.push_back(std::make_pair(
|
|
db_name, positional_options[i]));
|
|
}
|
|
|
|
/*
|
|
We add standard exclusions only if objects are included by default, i.e.
|
|
there are exclusions or there is no exclusions and inclusions.
|
|
*/
|
|
if (m_object_filter.m_tables_excluded.size() > 0 ||
|
|
m_object_filter.m_tables_included.size() == 0)
|
|
{
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "apply_status"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "schema"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "general_log"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "slow_log"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "slave_master_info"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "slave_relay_log_info"));
|
|
/*
|
|
We filter out all the tables which store account and privilge
|
|
information. ex: mysql.user, mysql.db, mysql.tables_priv,
|
|
mysql.columns_priv, mysql.procs_priv, mysql.proxies_priv
|
|
*/
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "user"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "db"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "tables_priv"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "columns_priv"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "procs_priv"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "proxies_priv"));
|
|
/*
|
|
Since we dump CREATE EVENT/FUNCTION/PROCEDURE statement skip this table.
|
|
*/
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "event"));
|
|
m_object_filter.m_tables_excluded.push_back(std::make_pair(
|
|
"mysql", "proc"));
|
|
}
|
|
if (m_object_filter.m_databases_excluded.size() > 0 ||
|
|
m_object_filter.m_databases_included.size() == 0)
|
|
{
|
|
m_object_filter.m_databases_excluded.push_back(std::make_pair(
|
|
"", INFORMATION_SCHEMA_DB_NAME));
|
|
m_object_filter.m_databases_excluded.push_back(std::make_pair(
|
|
"", PERFORMANCE_SCHEMA_DB_NAME));
|
|
m_object_filter.m_databases_excluded.push_back(std::make_pair(
|
|
"", "ndbinfo"));
|
|
m_object_filter.m_databases_excluded.push_back(std::make_pair(
|
|
"", "sys"));
|
|
}
|
|
}
|
|
|
|
void Mysqldump_tool_chain_maker_options::create_options()
|
|
{
|
|
this->create_new_option(&m_dump_all_databases, "all-databases",
|
|
"Dump all databases. This is default behaviour if no positional options "
|
|
"are specified. Specifying this option is mutually exclusive with "
|
|
"--databases.")
|
|
->set_short_character('A');
|
|
this->create_new_option(&m_dump_selected_databases, "databases",
|
|
"Dump selected databases, specified in positional options. Specifying "
|
|
"this option is mutually exclusive with --all-databases.")
|
|
->set_short_character('B');
|
|
this->create_new_option(&m_parallel_schemas_string, "parallel-schemas",
|
|
"[N:]<list of: schema_name separated with ','>. Process tables in "
|
|
"specified schemas using separate queue handled by "
|
|
"--default-parallelism threads or N threads, if N is specified. Can be "
|
|
"used multiple times to specify more parallel processes.")
|
|
->add_callback(new Mysql::Instance_callback
|
|
<void, char*, Mysqldump_tool_chain_maker_options>(
|
|
this, &Mysqldump_tool_chain_maker_options::parallel_schemas_callback));
|
|
this->create_new_option(&m_default_parallelism, "default-parallelism",
|
|
"Specifies number of threads to process each parallel queue for values "
|
|
"N > 0. if N is 0 then no queue will be used. Default value is 2. "
|
|
"If N > 1 then objects in dump file can have lines intersected. Usage "
|
|
"of values greater than 1 is mutually exclusive with "
|
|
"--single-transaction.")
|
|
->set_value(2);
|
|
this->create_new_option(&m_result_file, "result-file",
|
|
"Direct all output generated for all objects to a given file.");
|
|
this->create_new_option(&m_compress_output_algorithm, "compress-output",
|
|
"Compresses all output files with LZ4 or ZLIB compression algorithm.");
|
|
this->create_new_option(&m_skip_rows_data, "skip-dump-rows",
|
|
"Skip dumping rows of all tables to output.")
|
|
->set_short_character('d');
|
|
}
|
|
|
|
Mysqldump_tool_chain_maker_options::~Mysqldump_tool_chain_maker_options()
|
|
{
|
|
delete m_formatter_options;
|
|
delete m_object_reader_options;
|
|
}
|
|
|
|
Mysqldump_tool_chain_maker_options::Mysqldump_tool_chain_maker_options(
|
|
const Mysql_chain_element_options* mysql_chain_element_options)
|
|
: m_mysql_chain_element_options(mysql_chain_element_options),
|
|
m_formatter_options(
|
|
new Sql_formatter_options(mysql_chain_element_options)),
|
|
m_object_reader_options(
|
|
new Mysql_object_reader_options(mysql_chain_element_options)),
|
|
m_last_parallel_schemas_queue_id(0),
|
|
m_def_thread_count(0),
|
|
m_parallel_thread_count(0),
|
|
m_object_filter(mysql_chain_element_options->get_program())
|
|
{
|
|
this->add_provider(m_formatter_options);
|
|
this->add_provider(m_object_reader_options);
|
|
this->add_provider(&m_object_filter);
|
|
}
|
|
|
|
int Mysqldump_tool_chain_maker_options::
|
|
get_parallel_schemas_with_default_thread_count()
|
|
{
|
|
return m_def_thread_count;
|
|
}
|
|
|
|
int Mysqldump_tool_chain_maker_options::get_parallel_schemas_thread_count()
|
|
{
|
|
return m_parallel_thread_count;
|
|
}
|