~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzledump.cc

  • Committer: Brian Aker
  • Date: 2010-12-17 00:08:06 UTC
  • mfrom: (2002.1.4 clean)
  • Revision ID: brian@tangent.org-20101217000806-fa6kmggjnhsl4q85
Rollup for field encapsulation, monty fix for bzrignore, and Andrew bug
fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
56
56
 
57
57
#define EX_USAGE 1
58
58
#define EX_DRIZZLEERR 2
 
59
#define EX_CONSCHECK 3
 
60
#define EX_EOM 4
59
61
#define EX_EOF 5 /* ferror for output file was got */
60
 
 
 
62
#define EX_ILLEGAL_TABLE 6
 
63
#define EX_TABLE_STATUS 7
 
64
 
 
65
/* index into 'show fields from table' */
 
66
 
 
67
#define SHOW_FIELDNAME  0
 
68
#define SHOW_TYPE  1
 
69
#define SHOW_NULL  2
 
70
#define SHOW_DEFAULT  4
 
71
#define SHOW_EXTRA  5
 
72
 
 
73
/* Size of buffer for dump's select query */
 
74
#define QUERY_LENGTH 1536
 
75
 
 
76
/* ignore table flags */
 
77
#define IGNORE_NONE 0x00 /* no ignore */
 
78
#define IGNORE_DATA 0x01 /* don't dump data for this table */
 
79
#define IGNORE_INSERT_DELAYED 0x02 /* table doesn't support INSERT DELAYED */
 
80
 
 
81
bool opt_alltspcs= false;
 
82
bool opt_complete_insert= false;
61
83
bool  verbose= false;
62
84
static bool use_drizzle_protocol= false;
63
85
bool ignore_errors= false;
81
103
bool extended_insert= true;
82
104
bool opt_replace_into= false;
83
105
bool opt_drop= true; 
84
 
bool opt_data_is_mangled= false;
85
106
uint32_t show_progress_size= 0;
86
107
static string insert_pat;
87
108
static uint32_t opt_drizzle_port= 0;
118
139
  opt_protocol,
119
140
  where;
120
141
 
 
142
//static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;
 
143
 
121
144
boost::unordered_set<string> ignore_table;
122
145
 
123
146
void maybe_exit(int error);
241
264
    cout << "-- Host: " << current_host << "    Database: " << db_name << endl;
242
265
    cout << "-- ------------------------------------------------------" << endl;
243
266
    cout << "-- Server version\t" << db_connection->getServerVersion();
244
 
    if (db_connection->getServerType() == ServerDetect::SERVER_MYSQL_FOUND)
 
267
    if (db_connection->getServerType() == DrizzleDumpConnection::SERVER_MYSQL_FOUND)
245
268
      cout << " (MySQL server)";
246
 
    else if (db_connection->getServerType() == ServerDetect::SERVER_DRIZZLE_FOUND)
 
269
    else if (db_connection->getServerType() == DrizzleDumpConnection::SERVER_DRIZZLE_FOUND)
247
270
      cout << " (Drizzle server)";
248
271
    cout << endl << endl;
249
272
  }
351
374
    std::cerr << _("-- Retrieving database structures...") << std::endl;
352
375
 
353
376
  /* Blocking the MySQL privilege tables too because we can't import them due to bug#646187 */
354
 
  if (db_connection->getServerType() == ServerDetect::SERVER_MYSQL_FOUND)
 
377
  if (db_connection->getServerType() == DrizzleDumpConnection::SERVER_MYSQL_FOUND)
355
378
    query= "SELECT SCHEMA_NAME, DEFAULT_COLLATION_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME NOT IN ('information_schema', 'performance_schema', 'mysql')";
356
379
  else
357
380
    query= "SELECT SCHEMA_NAME, DEFAULT_COLLATION_NAME FROM DATA_DICTIONARY.SCHEMAS WHERE SCHEMA_NAME NOT IN ('information_schema','data_dictionary')";
360
383
  while ((row= drizzle_row_next(tableres)))
361
384
  {
362
385
    std::string database_name(row[0]);
363
 
    if (db_connection->getServerType() == ServerDetect::SERVER_MYSQL_FOUND)
 
386
    if (db_connection->getServerType() == DrizzleDumpConnection::SERVER_MYSQL_FOUND)
364
387
      database= new DrizzleDumpDatabaseMySQL(database_name, db_connection);
365
388
    else
366
389
      database= new DrizzleDumpDatabaseDrizzle(database_name, db_connection);
383
406
  for (vector<string>::const_iterator it= db_names.begin(); it != db_names.end(); ++it)
384
407
  {
385
408
    temp= *it;
386
 
    if (db_connection->getServerType() == ServerDetect::SERVER_MYSQL_FOUND)
 
409
    if (db_connection->getServerType() == DrizzleDumpConnection::SERVER_MYSQL_FOUND)
387
410
      database= new DrizzleDumpDatabaseMySQL(temp, db_connection);
388
411
    else
389
412
      database= new DrizzleDumpDatabaseDrizzle(temp, db_connection);
396
419
{
397
420
  DrizzleDumpDatabase *database;
398
421
 
399
 
  if (db_connection->getServerType() == ServerDetect::SERVER_MYSQL_FOUND)
 
422
  if (db_connection->getServerType() == DrizzleDumpConnection::SERVER_MYSQL_FOUND)
400
423
    database= new DrizzleDumpDatabaseMySQL(db, db_connection);
401
424
  else
402
425
    database= new DrizzleDumpDatabaseDrizzle(db, db_connection);
449
472
{
450
473
  int exit_code;
451
474
 
452
 
#if defined(ENABLE_NLS)
453
 
# if defined(HAVE_LOCALE_H)
454
 
  setlocale(LC_ALL, "");
455
 
# endif
456
 
  bindtextdomain("drizzle7", LOCALEDIR);
457
 
  textdomain("drizzle7");
458
 
#endif
459
 
 
460
 
  po::options_description commandline_options(_("Options used only in command line"));
 
475
  po::options_description commandline_options(N_("Options used only in command line"));
461
476
  commandline_options.add_options()
462
477
  ("all-databases,A", po::value<bool>(&opt_alldbs)->default_value(false)->zero_tokens(),
463
 
  _("Dump all the databases. This will be same as --databases with all databases selected."))
 
478
  N_("Dump all the databases. This will be same as --databases with all databases selected."))
 
479
  ("all-tablespaces,Y", po::value<bool>(&opt_alltspcs)->default_value(false)->zero_tokens(),
 
480
  N_("Dump all the tablespaces."))
 
481
  ("complete-insert,c", po::value<bool>(&opt_complete_insert)->default_value(false)->zero_tokens(),
 
482
  N_("Use complete insert statements."))
464
483
  ("flush-logs,F", po::value<bool>(&flush_logs)->default_value(false)->zero_tokens(),
465
 
  _("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"))
 
484
  N_("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"))
466
485
  ("force,f", po::value<bool>(&ignore_errors)->default_value(false)->zero_tokens(),
467
 
  _("Continue even if we get an sql-error."))
468
 
  ("help,?", _("Display this help message and exit."))
 
486
  N_("Continue even if we get an sql-error."))
 
487
  ("help,?", N_("Display this help message and exit."))
469
488
  ("lock-all-tables,x", po::value<bool>(&opt_lock_all_tables)->default_value(false)->zero_tokens(),
470
 
  _("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 off."))
 
489
  N_("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 off."))
471
490
  ("single-transaction", po::value<bool>(&opt_single_transaction)->default_value(false)->zero_tokens(),
472
 
  _("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."))
 
491
  N_("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."))
473
492
  ("skip-opt", 
474
 
  _("Disable --opt. Disables --add-drop-table, --add-locks, --create-options, ---extended-insert and --disable-keys."))    
475
 
  ("tables", _("Overrides option --databases (-B)."))
 
493
  N_("Disable --opt. Disables --add-drop-table, --add-locks, --create-options, ---extended-insert and --disable-keys."))    
 
494
  ("tables", N_("Overrides option --databases (-B)."))
476
495
  ("show-progress-size", po::value<uint32_t>(&show_progress_size)->default_value(10000),
477
 
  _("Number of rows before each output progress report (requires --verbose)."))
 
496
  N_("Number of rows before each output progress report (requires --verbose)."))
478
497
  ("verbose,v", po::value<bool>(&verbose)->default_value(false)->zero_tokens(),
479
 
  _("Print info about the various stages."))
480
 
  ("version,V", _("Output version information and exit."))
481
 
  ("skip-comments", _("Turn off Comments"))
482
 
  ("skip-create", _("Turn off create-options"))
483
 
  ("skip-extended-insert", _("Turn off extended-insert"))
484
 
  ("skip-dump-date", _( "Turn off dump date at the end of the output"))
485
 
  ("no-defaults", _("Do not read from the configuration files"))
 
498
  N_("Print info about the various stages."))
 
499
  ("version,V", N_("Output version information and exit."))
 
500
  ("skip-comments", N_("Turn off Comments"))
 
501
  ("skip-create", N_("Turn off create-options"))
 
502
  ("skip-extended-insert", N_("Turn off extended-insert"))
 
503
  ("skip-dump-date",N_( "Turn off dump date at the end of the output"))
 
504
  ("no-defaults", N_("Do not read from the configuration files"))
486
505
  ;
487
506
 
488
 
  po::options_description dump_options(_("Options specific to the drizzle client"));
 
507
  po::options_description dump_options(N_("Options specific to the drizzle client"));
489
508
  dump_options.add_options()
490
509
  ("add-drop-database", po::value<bool>(&opt_drop_database)->default_value(false)->zero_tokens(),
491
 
  _("Add a 'DROP DATABASE' before each create."))
492
 
  ("skip-drop-table", _("Do not add a 'drop table' before each create."))
 
510
  N_("Add a 'DROP DATABASE' before each create."))
 
511
  ("skip-drop-table", N_("Do not add a 'drop table' before each create."))
493
512
  ("compact", po::value<bool>(&opt_compact)->default_value(false)->zero_tokens(),
494
 
  _("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"))
 
513
  N_("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"))
495
514
  ("databases,B", po::value<bool>(&opt_databases)->default_value(false)->zero_tokens(),
496
 
  _("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."))
 
515
  N_("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."))
497
516
  ("skip-disable-keys,K",
498
 
  _("'ALTER TABLE tb_name DISABLE KEYS;' and 'ALTER TABLE tb_name ENABLE KEYS;' will not be put in the output."))
 
517
  N_("'ALTER TABLE tb_name DISABLE KEYS; and 'ALTER TABLE tb_name ENABLE KEYS; will not be put in the output."))
499
518
  ("ignore-table", po::value<string>(),
500
 
  _("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"))
 
519
  N_("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"))
501
520
  ("insert-ignore", po::value<bool>(&opt_ignore)->default_value(false)->zero_tokens(),
502
 
  _("Insert rows with INSERT IGNORE."))
 
521
  N_("Insert rows with INSERT IGNORE."))
503
522
  ("no-autocommit", po::value<bool>(&opt_autocommit)->default_value(false)->zero_tokens(),
504
 
  _("Wrap a table's data in START TRANSACTION/COMMIT statements."))
 
523
  N_("Wrap a table's data in START TRANSACTION/COMMIT statements."))
505
524
  ("no-create-db,n", po::value<bool>(&opt_create_db)->default_value(false)->zero_tokens(),
506
 
  _("'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."))
 
525
  N_("'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."))
507
526
  ("no-data,d", po::value<bool>(&opt_no_data)->default_value(false)->zero_tokens(),
508
 
  _("No row information."))
 
527
  N_("No row information."))
509
528
  ("replace", po::value<bool>(&opt_replace_into)->default_value(false)->zero_tokens(),
510
 
  _("Use REPLACE INTO instead of INSERT INTO."))
 
529
  N_("Use REPLACE INTO instead of INSERT INTO."))
511
530
  ("destination-type", po::value<string>()->default_value("stdout"),
512
 
  _("Where to send output to (stdout|database"))
 
531
  N_("Where to send output to (stdout|database"))
513
532
  ("destination-host", po::value<string>(&opt_destination_host)->default_value("localhost"),
514
 
  _("Hostname for destination db server (requires --destination-type=database)"))
 
533
  N_("Hostname for destination db server (requires --destination-type=database)"))
515
534
  ("destination-port", po::value<uint16_t>(&opt_destination_port)->default_value(4427),
516
 
  _("Port number for destination db server (requires --destination-type=database)"))
 
535
  N_("Port number for destination db server (requires --destination-type=database)"))
517
536
  ("destination-user", po::value<string>(&opt_destination_user),
518
 
  _("User name for destination db server (resquires --destination-type=database)"))
 
537
  N_("User name for destination db server (resquires --destination-type=database)"))
519
538
  ("destination-password", po::value<string>(&opt_destination_password),
520
 
  _("Password for destination db server (requires --destination-type=database)"))
 
539
  N_("Password for destination db server (requires --destination-type=database)"))
521
540
  ("destination-database", po::value<string>(&opt_destination_database),
522
 
  _("The database in the destination db server (requires --destination-type=database, not for use with --all-databases)"))
523
 
  ("my-data-is-mangled", po::value<bool>(&opt_data_is_mangled)->default_value(false)->zero_tokens(),
524
 
  _("Do not make a UTF8 connection to MySQL, use if you have UTF8 data in a non-UTF8 table"))
 
541
  N_("The database in the destination db server (requires --destination-type=database, not for use with --all-databases)"))
525
542
  ;
526
543
 
527
 
  po::options_description client_options(_("Options specific to the client"));
 
544
  po::options_description client_options(N_("Options specific to the client"));
528
545
  client_options.add_options()
529
546
  ("host,h", po::value<string>(&current_host)->default_value("localhost"),
530
 
  _("Connect to host."))
 
547
  N_("Connect to host."))
531
548
  ("password,P", po::value<string>(&password)->default_value(PASSWORD_SENTINEL),
532
 
  _("Password to use when connecting to server. If password is not given it's solicited on the tty."))
 
549
  N_("Password to use when connecting to server. If password is not given it's solicited on the tty."))
533
550
  ("port,p", po::value<uint32_t>(&opt_drizzle_port)->default_value(0),
534
 
  _("Port number to use for connection."))
 
551
  N_("Port number to use for connection."))
535
552
  ("user,u", po::value<string>(&current_user)->default_value(""),
536
 
  _("User for login if not current user."))
 
553
  N_("User for login if not current user."))
537
554
  ("protocol",po::value<string>(&opt_protocol)->default_value("mysql"),
538
 
  _("The protocol of connection (mysql or drizzle)."))
 
555
  N_("The protocol of connection (mysql or drizzle)."))
539
556
  ;
540
557
 
541
 
  po::options_description hidden_options(_("Hidden Options"));
 
558
  po::options_description hidden_options(N_("Hidden Options"));
542
559
  hidden_options.add_options()
543
 
  ("database-used", po::value<vector<string> >(), _("Used to select the database"))
544
 
  ("Table-used", po::value<vector<string> >(), _("Used to select the tables"))
 
560
  ("database-used", po::value<vector<string> >(), N_("Used to select the database"))
 
561
  ("Table-used", po::value<vector<string> >(), N_("Used to select the tables"))
545
562
  ;
546
563
 
547
 
  po::options_description all_options(_("Allowed Options + Hidden Options"));
 
564
  po::options_description all_options(N_("Allowed Options + Hidden Options"));
548
565
  all_options.add(commandline_options).add(dump_options).add(client_options).add(hidden_options);
549
566
 
550
 
  po::options_description long_options(_("Allowed Options"));
 
567
  po::options_description long_options(N_("Allowed Options"));
551
568
  long_options.add(commandline_options).add(dump_options).add(client_options);
552
569
 
553
570
  std::string system_config_dir_dump(SYSCONFDIR); 
742
759
    maybe_exit(EX_DRIZZLEERR);
743
760
  }
744
761
 
745
 
  if ((db_connection->getServerType() == ServerDetect::SERVER_MYSQL_FOUND) and (not opt_data_is_mangled))
 
762
  if (db_connection->getServerType() == DrizzleDumpConnection::SERVER_MYSQL_FOUND)
746
763
    db_connection->queryNoResult("SET NAMES 'utf8'");
747
764
 
748
765
  if (vm.count("destination-type"))