~drizzle-trunk/drizzle/development

#include <iostream>

#include <fstream>

#include <drizzled/configmake.h>

#include <boost/program_options.hpp>

namespace po= boost::program_options;

                            const string &option_value);

static void field_escape(string &in, const string &from);

static bool opt_no_create_info;

static bool opt_xml;

static bool opt_comments;

static bool opt_compact;

static bool opt_drop_database;

string password,

  opt_compatible_mode_str,

  enclosed,

  escaped,

  current_host,

  opt_enclosed,

  fields_terminated,

  path,

  lines_terminated,

  current_user,

  opt_password,

  where;

 

static int dump_selected_tables(const string &db, const vector<string> &table_names);

static int dump_databases(const vector<string> &db_names);

 

  else if (! opt_compact)

  { 

              ! current_host.empty() ? current_host.c_str() : "localhost", db_name ? db_name :

    if (path.empty())

  else if (! opt_compact)

    if (path.empty())

static int get_options(void)

{

 

  if (path.empty() && (! enclosed.empty() || ! opt_enclosed.empty() || ! escaped.empty() || ! lines_terminated.empty() ||

                ! fields_terminated.empty()))

  if (! enclosed.empty() && ! opt_enclosed.empty())

  if ((opt_databases || opt_alldbs) && ! path.empty())

 

  internal::convert_dirname(tmp_path,(char *)path.c_str(),NULL);

  opt_password.erase();

static int connect_to_db(string host, string user,string passwd)

  verbose_msg(_("-- Connecting to %s...\n"), ! host.empty() ? (char *)host.c_str() : "localhost");

  drizzle_con_set_tcp(&dcon, (char *)host.c_str(), opt_drizzle_port);

  drizzle_con_set_auth(&dcon, (char *)user.c_str(), (char *)passwd.c_str());

static void dbDisconnect(string &host)

  verbose_msg(_("-- Disconnecting from %s...\n"), ! host.empty() ? host.c_str() : "localhost");

  if (! opt_xml)

  { 

    if (! opt_no_create_info)

    { 

      if (! path.empty())

      { 

      if (! path.empty())

    if (! opt_no_create_info)

      if (! path.empty())

        if (! path.empty())

                            const string &option_value)

  if (option_value.empty())

  if (option_value.compare(0, 2, "0x") == 0)

static void field_escape(string &in, const string &from)

  string::const_iterator it= from.begin();

  while (it != from.end())

    in.push_back(*it);

    if (*it == '\\')

      end_backslashes^= 1;    /* find odd number of backslashes */

      if (*it == '\'' && !end_backslashes)

        in.push_back('\'');

    ++it;

  if (! path.empty())

    internal::convert_dirname(tmp_path,(char *)path.c_str(),NULL);

    if (! fields_terminated.empty() || ! enclosed.empty() || ! opt_enclosed.empty() || ! escaped.empty())

    query_string.append(" FROM ");

    query_string.append(result_table);

    if (! where.empty())

      query_string.append(" WHERE ");

      query_string.append(where);

      query_string.append(" ORDER BY ");

      query_string.append(order_by);

 

    if (! where.empty())

        fprintf(md_result_file, "-- WHERE:  %s\n", where.c_str());

      query_string.append( (char *)where.c_str());

    

static int dump_databases(const vector<string> &db_names)

  string temp;

  for (vector<string>::const_iterator it= db_names.begin(); it != db_names.end(); ++it)

    temp= *it;

    if (dump_all_tables_in_db((char *)temp.c_str()))

  if (path.empty() && !opt_xml)

static int dump_selected_tables(const string &db, const vector<string> &table_names)

  if (init_dumping((char *)db.c_str(), init_dumping_tables))

  if (!(dump_tables= pos= (char**) root.alloc_root(table_names.size() * sizeof(char *))))

  for (vector<string>::const_iterator it= table_names.begin(); it != table_names.end(); ++it)

    string temp= *it;

    if ((*pos= get_actual_table_name(temp.c_str(), &root)))

      maybe_die(EX_ILLEGAL_TABLE, _("Couldn't find table: \"%s\""),(char *) temp.c_str());

    print_xml_tag(md_result_file, "", "\n", "database", "name=", (char *)db.c_str(), NULL);

    dump_table(*pos, (char *)db.c_str());

try

{

  po::options_description commandline_options("Options used only in command line");

  commandline_options.add_options()

  ("all-databases,A", po::value<bool>(&opt_alldbs)->default_value(false)->zero_tokens(),

  "Dump all the databases. This will be same as --databases with all databases selected.")

  ("all-tablespaces,Y", po::value<bool>(&opt_alltspcs)->default_value(false)->zero_tokens(),

  "Dump all the tablespaces.")

  ("complete-insert,c", po::value<bool>(&opt_complete_insert)->default_value(false)->zero_tokens(),

  "Use complete insert statements.")

  ("compress,C", po::value<bool>(&opt_compress)->default_value(false)->zero_tokens(),

  "Use compression in server/client protocol.")

  ("flush-logs,F", po::value<bool>(&flush_logs)->default_value(false)->zero_tokens(),

  "Flush logs file in server before starting dump. Note that if you dump many databases at once (using the option --databases= or --all-databases), the logs will be flushed for each database dumped. The exception is when using --lock-all-tables in this case the logs will be flushed only once, corresponding to the moment all tables are locked. So if you want your dump and the log flush to happen at the same exact moment you should use --lock-all-tables or --flush-logs")

  ("force,f", po::value<bool>(&ignore_errors)->default_value(false)->zero_tokens(),

  "Continue even if we get an sql-error.")

  ("help,?", "Display this help message and exit.")

  ("lock-all-tables,x", po::value<bool>(&opt_lock_all_tables)->default_value(false)->zero_tokens(),

  "Locks all tables across all databases. This is achieved by taking a global read lock for the duration of the whole dump. Automatically turns --single-transaction and --lock-tables off.")

  ("order-by-primary", po::value<bool>(&opt_order_by_primary)->default_value(false)->zero_tokens(),

  "Sorts each table's rows by primary key, or first unique key, if such a key exists.  Useful when dumping a MyISAM table to be loaded into an InnoDB table, but will make the dump itself take considerably longer.")

  ("routines,R", po::value<bool>(&opt_routines)->default_value(false)->zero_tokens(),

  "Dump stored routines (functions and procedures).")

  ("single-transaction", po::value<bool>(&opt_single_transaction)->default_value(false)->zero_tokens(),

  "Creates a consistent snapshot by dumping all tables in a single transaction. Works ONLY for tables stored in storage engines which support multiversioning (currently only InnoDB does); the dump is NOT guaranteed to be consistent for other storage engines. While a --single-transaction dump is in process, to ensure a valid dump file (correct table contents), no other connection should use the following statements: ALTER TABLE, DROP TABLE, RENAME TABLE, TRUNCATE TABLE, as consistent snapshot is not isolated from them. Option automatically turns off --lock-tables.")

  ("opt", "Same as --add-drop-table, --add-locks, --create-options, --quick, --extended-insert, --lock-tables, --set-charset, and --disable-keys. Enabled by default, disable with --skip-opt.") 

  ("skip-opt", 

  "Disable --opt. Disables --add-drop-table, --add-locks, --create-options, --quick, --extended-insert, --lock-tables, --set-charset, and --disable-keys.")    

  ("tables", "Overrides option --databases (-B).")

  ("show-progress-size", po::value<uint32_t>(&show_progress_size)->default_value(10000),

  N_("Number of rows before each output progress report (requires --verbose)."))

  ("verbose,v", po::value<bool>(&verbose)->default_value(false)->zero_tokens(),

  "Print info about the various stages.")

  ("version,V", "Output version information and exit.")

  ("xml,X", "Dump a database as well formed XML.")

  ("skip-comments", "Turn off Comments")

  ("skip-create", "Turn off create-options")

  ("skip-extended-insert", "Turn off extended-insert") 

  ("skip-dump-date", "Turn off dump-date")

  ("no-defaults", "Do not read from the configuration files")

  ;

 

  po::options_description dump_options("Options specific to the drizzle client");

  dump_options.add_options()

  ("add-drop-database", po::value<bool>(&opt_drop_database)->default_value(false)->zero_tokens(),

  "Add a 'DROP DATABASE' before each create.")

  ("add-drop-table", po::value<bool>(&opt_drop)->default_value(true)->zero_tokens(),

  "Add a 'drop table' before each create.")

  ("allow-keywords", po::value<bool>(&opt_keywords)->default_value(false)->zero_tokens(),

  "Allow creation of column names that are keywords.")

  ("comments,i", po::value<bool>(&opt_comments)->default_value(true)->zero_tokens(),

  "Write additional information.")

  ("compatible", po::value<string>(&opt_compatible_mode_str)->default_value(""),

  "Change the dump to be compatible with a given mode. By default tables are dumped in a format optimized for MySQL. Legal modes are: ansi, mysql323, mysql40, postgresql, oracle, mssql, db2, maxdb, no_key_options, no_table_options, no_field_options. One can use several modes separated by commas. Note: Requires DRIZZLE server version 4.1.0 or higher. This option is ignored with earlier server versions.")

  ("compact", po::value<bool>(&opt_compact)->default_value(false)->zero_tokens(),

  "Give less verbose output (useful for debugging). Disables structure comments and header/footer constructs.  Enables options --skip-add-drop-table --no-set-names --skip-disable-keys --skip-add-locks")

  ("create-options", po::value<bool>(&create_options)->default_value(true)->zero_tokens(),

  "Include all DRIZZLE specific create options.")

  ("dump-date", po::value<bool>(&opt_dump_date)->default_value(true)->zero_tokens(),

  "Put a dump date to the end of the output.")

  ("databases,B", po::value<bool>(&opt_databases)->default_value(false)->zero_tokens(),

  "To dump several databases. Note the difference in usage; In this case no tables are given. All name arguments are regarded as databasenames. 'USE db_name;' will be included in the output.")

  ("delayed-insert", po::value<bool>(&opt_delayed)->default_value(false)->zero_tokens(),

  "Insert rows with INSERT DELAYED; ")

  ("disable-keys,K", po::value<bool>(&opt_disable_keys)->default_value(true)->zero_tokens(),

  "'ALTER TABLE tb_name DISABLE KEYS; and 'ALTER TABLE tb_name ENABLE KEYS; will be put in the output.")

  ("extended-insert,e", po::value<bool>(&extended_insert)->default_value(true)->zero_tokens(),

  "Allows utilization of the new, much faster INSERT syntax.")

  ("fields-terminated-by", po::value<string>(&fields_terminated)->default_value(""),

  "Fields in the textfile are terminated by ...")

  ("fields-enclosed-by", po::value<string>(&enclosed)->default_value(""),

  "Fields in the importfile are enclosed by ...")

  ("fields-optionally-enclosed-by", po::value<string>(&opt_enclosed)->default_value(""),

  "Fields in the i.file are opt. enclosed by ...")

  ("fields-escaped-by", po::value<string>(&escaped)->default_value(""),

  "Fields in the i.file are escaped by ...")

  ("hex-blob", po::value<bool>(&opt_hex_blob)->default_value(false)->zero_tokens(),

  "Dump binary strings (BINARY, VARBINARY, BLOB) in hexadecimal format.")

  ("ignore-table", po::value<string>(),

  "Do not dump the specified table. To specify more than one table to ignore, use the directive multiple times, once for each table.  Each table must be specified with both database and table names, e.g. --ignore-table=database.table")

  ("insert-ignore", po::value<bool>(&opt_ignore)->default_value(false)->zero_tokens(),

  "Insert rows with INSERT IGNORE.")

  ("lines-terminated-by", po::value<string>(&lines_terminated)->default_value(""),

  "Lines in the i.file are terminated by ...")

  ("no-autocommit", po::value<bool>(&opt_autocommit)->default_value(false)->zero_tokens(),

  "Wrap tables with autocommit/commit statements.")

  ("no-create-db,n", po::value<bool>(&opt_create_db)->default_value(false)->zero_tokens(),

  "'CREATE DATABASE IF NOT EXISTS db_name;' will not be put in the output. The above line will be added otherwise, if --databases or --all-databases option was given.}.")

  ("no-create-info,t", po::value<bool>(&opt_no_create_info)->default_value(false)->zero_tokens(),

  "Don't write table creation info.")

  ("no-data,d", po::value<bool>(&opt_no_data)->default_value(false)->zero_tokens(),

  "No row information.")

  ("no-set-names,N", "Deprecated. Use --skip-set-charset instead.")

  ("set-charset", po::value<bool>(&opt_set_charset)->default_value(false)->zero_tokens(),

  "Enable set-name")

  ("quick,q", po::value<bool>(&quick)->default_value(true)->zero_tokens(),

  "Don't buffer query, dump directly to stdout.")

  ("quote-names,Q", po::value<bool>(&opt_quoted)->default_value(true)->zero_tokens(),

  "Quote table and column names with backticks (`).")

  ("replace", po::value<bool>(&opt_replace_into)->default_value(false)->zero_tokens(),

  "Use REPLACE INTO instead of INSERT INTO.")

  ("result-file,r", po::value<string>(),

  "Direct output to a given file. This option should be used in MSDOS, because it prevents new line '\\n' from being converted to '\\r\\n' (carriage return + line feed).")  

  ("tab,T", po::value<string>(&path)->default_value(""),

  "Creates tab separated textfile for each table to given path. (creates .sql and .txt files). NOTE: This only works if drizzledump is run on the same machine as the drizzled daemon.")

  ("where,w", po::value<string>(&where)->default_value(""),

  "Dump only selected records; QUOTES mandatory!")

  ;

 

  po::options_description client_options("Options specific to the client");

  client_options.add_options()

  ("host,h", po::value<string>(&current_host)->default_value("localhost"),

  "Connect to host.")

  ("mysql,m", po::value<bool>(&opt_mysql)->default_value(true)->zero_tokens(),

  N_("Use MySQL Protocol."))

  ("password,P", po::value<string>(&password)->default_value(PASSWORD_SENTINEL),

  "Password to use when connecting to server. If password is not given it's solicited on the tty.")

  ("port,p", po::value<uint32_t>(&opt_drizzle_port)->default_value(0),

  "Port number to use for connection.")

  ("user,u", po::value<string>(&current_user)->default_value(""),

  "User for login if not current user.")

  ("protocol",po::value<string>(),

  "The protocol of connection (tcp,socket,pipe,memory).")

  ;

 

  po::options_description hidden_options("Hidden Options");

  hidden_options.add_options()

  ("database-used", po::value<vector<string> >(), "Used to select the database")

  ("Table-used", po::value<vector<string> >(), "Used to select the tables")

  ;

 

  po::options_description all_options("Allowed Options + Hidden Options");

  all_options.add(commandline_options).add(dump_options).add(client_options).add(hidden_options);

 

  po::options_description long_options("Allowed Options");

  long_options.add(commandline_options).add(dump_options).add(client_options);

 

  std::string system_config_dir_dump(SYSCONFDIR); 

  system_config_dir_dump.append("/drizzle/drizzledump.cnf");

 

  std::string system_config_dir_client(SYSCONFDIR); 

  system_config_dir_client.append("/drizzle/client.cnf");

 

  po::positional_options_description p;

  p.add("database-used", 1);

  p.add("Table-used",-1);

 

  

  md_result_file= stdout;

 

  po::variables_map vm;

 

  po::store(po::command_line_parser(argc, argv).options(all_options).

            positional(p).extra_parser(parse_password_arg).run(), vm);

 

  if (! vm.count("no-defaults"))

  {

    ifstream user_dump_ifs("~/.drizzle/drizzledump.cnf");

    po::store(parse_config_file(user_dump_ifs, dump_options), vm);

 

    ifstream system_dump_ifs(system_config_dir_dump.c_str());

    store(parse_config_file(system_dump_ifs, dump_options), vm);

 

    ifstream user_client_ifs("~/.drizzle/client.cnf");

    po::store(parse_config_file(user_client_ifs, client_options), vm);

 

    ifstream system_client_ifs(system_config_dir_client.c_str());

    po::store(parse_config_file(system_client_ifs, client_options), vm);

  }

 

  po::notify(vm);  

  

  if ( ! vm.count("database-used") && ! vm.count("Table-used") && ! opt_alldbs && path.empty())

  {

    printf(_("Usage: %s [OPTIONS] database [tables]\n"), internal::my_progname);

    printf(_("OR     %s [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...]\n"),

          internal::my_progname);

    printf(_("OR     %s [OPTIONS] --all-databases [OPTIONS]\n"), internal::my_progname);

    exit(1);

  }

 

  if (vm.count("port"))

  {

    /* If the port number is > 65535 it is not a valid port

     *        This also helps with potential data loss casting unsigned long to a

     *               uint32_t. 

     */

    if (opt_drizzle_port > 65535)

    {

      fprintf(stderr, _("Value supplied for port is not valid.\n"));

      exit(-1);

    }

  }

 

  if(vm.count("password"))

  {

    if (!opt_password.empty())

      opt_password.erase();

    if (password == PASSWORD_SENTINEL)

    {

      opt_password= "";

    }

    else

    {

      opt_password= password;

      tty_password= false;

    }

  }

  else

  {

      tty_password= true;

  }

 

  if (vm.count("result-file"))

  {

    if (!(md_result_file= fopen(vm["result-file"].as<string>().c_str(), "w")))

      exit(1);

  }

 

  if (vm.count("no-set-names"))

  {

    opt_set_charset= 0;

  }

 

  if (! path.empty())

  { 

    opt_disable_keys= 0;

 

    if (vm["tab"].as<string>().length() >= FN_REFLEN)

    {

      /*

        This check is made because the some the file functions below

        have FN_REFLEN sized stack allocated buffers and will cause

        a crash even if the input destination buffer is large enough

        to hold the output.

      */

      fprintf(stderr, _("Input filename too long: %s"), vm["tab"].as<string>().c_str());

      exit(EXIT_ARGUMENT_INVALID);

    }

  }

 

  if (vm.count("version"))

  {

     printf(_("%s  Drizzle %s libdrizzle %s, for %s-%s (%s)\n"), internal::my_progname,

       VERSION, drizzle_version(), HOST_VENDOR, HOST_OS, HOST_CPU);

  }

 

  if (vm.count("xml"))

  { 

    opt_xml= 1;

    extended_insert= opt_drop= opt_disable_keys= opt_autocommit= opt_create_db= 0;

  }

 

  if (vm.count("help"))

  {

    printf(_("%s  Drizzle %s libdrizzle %s, for %s-%s (%s)\n"), internal::my_progname,

      VERSION, drizzle_version(), HOST_VENDOR, HOST_OS, HOST_CPU);

    puts("");

    puts(_("This software comes with ABSOLUTELY NO WARRANTY. This is free software,\nand you are welcome to modify and redistribute it under the GPL license\n"));

    puts(_("Dumps definitions and data from a Drizzle database server"));

    cout << long_options;

    printf(_("Usage: %s [OPTIONS] database [tables]\n"), internal::my_progname);

    printf(_("OR     %s [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...]\n"),

          internal::my_progname);

    printf(_("OR     %s [OPTIONS] --all-databases [OPTIONS]\n"), internal::my_progname);

    exit(1);

  }

  

  if (vm.count("skip-opt"))

  {

    extended_insert= opt_drop= quick= create_options= 0;

    opt_disable_keys= opt_set_charset= 0;

  }

 

  if (opt_compact)

  { 

    opt_comments= opt_drop= opt_disable_keys= 0;

    opt_set_charset= 0;

  }

 

  if (vm.count("opt"))

  {

    extended_insert= opt_drop= quick= create_options= 1;

    opt_disable_keys= opt_set_charset= 1;

  }

 

  if (vm.count("tables"))

  { 

    opt_databases= false;

  }

 

  if (vm.count("ignore-table"))

  {

    if (!strchr(vm["ignore-table"].as<string>().c_str(), '.'))

    {

      fprintf(stderr, _("Illegal use of option --ignore-table=<database>.<table>\n"));

      exit(EXIT_ARGUMENT_INVALID);

    }

    string tmpptr(vm["ignore-table"].as<string>());

    ignore_table.insert(tmpptr); 

  }

  

  if (vm.count("skip-create"))

  {

    opt_create_db= opt_no_create_info= create_options= false;

  }

 

  if (vm.count("skip-comments"))

  {

    opt_comments= false; 

  }

 

  if (vm.count("skip-extended-insert"))

  {

    extended_insert= false; 

  }

 

  if (vm.count("skip-dump-date"))

  {

    opt_dump_date= false; 

  } 

 

  if (! opt_compatible_mode_str.empty())

  {

    char buff[255];

    char *end= compatible_mode_normal_str;

    uint32_t i;

    uint32_t mode;

    uint32_t error_len;

 

    opt_quoted= 1;

    opt_set_charset= 0;

    opt_compatible_mode= find_set(&compatible_mode_typelib,

                                            opt_compatible_mode_str.c_str(), opt_compatible_mode_str.length(),

                                            &err_ptr, &error_len);

    if (error_len)

    {

      strncpy(buff, err_ptr, min((uint32_t)sizeof(buff), error_len+1));

      fprintf(stderr, _("Invalid mode to --compatible: %s\n"), buff);

      exit(EXIT_ARGUMENT_INVALID);

    }

    mode= opt_compatible_mode;

    for (i= 0, mode= opt_compatible_mode; mode; mode>>= 1, i++)

    {

      if (mode & 1)

      {

        uint32_t len = strlen(compatible_mode_names[i]);

        end= strcpy(end, compatible_mode_names[i]) + len;

        end= strcpy(end, ",")+1;

      }

    }

    if (end!=compatible_mode_normal_str)

      end[-1]= 0;

  }

 

 

  exit_code= get_options();

  if (path.empty() && vm.count("database-used"))

  {

    string database_used= *vm["database-used"].as< vector<string> >().begin();

    write_header(md_result_file, (char *)database_used.c_str());

  }

  if (vm.count("database-used") && vm.count("Table-used") && ! opt_databases)

    string database_used= *vm["database-used"].as< vector<string> >().begin();

    dump_selected_tables(database_used, vm["Table-used"].as< vector<string> >());

  }

 

  if (vm.count("Table-used") && opt_databases)

  {

    vector<string> database_used= vm["database-used"].as< vector<string> >();

    vector<string> table_used= vm["Table-used"].as< vector<string> >();

 

    for (vector<string>::iterator it= table_used.begin();

       it != table_used.end();

       ++it)

    {

      database_used.insert(database_used.end(), *it);

    }

    dump_databases(database_used);

  }

  

  if (vm.count("database-used") && ! vm.count("Table-used"))

  {

    dump_databases(vm["database-used"].as< vector<string> >());

  if (path.empty())

}

  catch(exception &err)

  {

    cerr << err.what() << endl;

  }