« back to all changes in this revision
Viewing changes to client/drizzledump.cc
- browse files at revision 1059.1.1
- compare with another revision
- compare with revision 2465.1.2
- download diff
- download tarball
- view history from revision 1059.1.1
- Committer: patg
- Date: 2009-06-12 01:15:16 UTC
- mto: (1061.1.2 merge-all)
- mto: This revision was merged to the branch mainline in revision 1062.
- Revision ID: patg@hanuman-20090612011516-5nuueh7k9hk30o5i
Removed all master/slave-specific code in drizzledump
- files modified:
- client/drizzledump.cc
added
removed
client/drizzledump.cc
84
84
opt_lock_all_tables= false,
85
85
opt_set_charset= false, opt_dump_date= true,
86
86
opt_autocommit= false, opt_disable_keys= true, opt_xml= false,
87
opt_delete_master_logs= false, tty_password= false,
87
tty_password= false,
88
88
opt_single_transaction= false, opt_comments= false,
89
89
opt_compact= false, opt_hex_blob= false,
90
90
opt_order_by_primary=false, opt_ignore= false,
91
91
opt_complete_insert= false, opt_drop_database= false,
92
92
opt_replace_into= false,
93
93
opt_routines= false,
94
opt_slave_apply= false,
95
opt_include_master_host_port= false,
96
94
opt_alltspcs= false;
97
95
static bool debug_info_flag= false, debug_check_flag= false;
98
96
static uint32_t show_progress_size= 0;
110
108
static char **defaults_argv= NULL;
111
109
static char compatible_mode_normal_str[255];
112
110
static uint32_t opt_compatible_mode= 0;
113
#define DRIZZLE_OPT_MASTER_DATA_EFFECTIVE_SQL 1
114
#define DRIZZLE_OPT_MASTER_DATA_COMMENTED_SQL 2
115
#define DRIZZLE_OPT_SLAVE_DATA_EFFECTIVE_SQL 1
116
#define DRIZZLE_OPT_SLAVE_DATA_COMMENTED_SQL 2
117
111
static uint32_t opt_drizzle_port= 0;
118
static uint32_t opt_master_data;
119
static uint32_t opt_slave_data;
120
112
static uint32_t my_end_arg;
121
113
static int first_error= 0;
122
114
static string extended_row;
176
168
{"allow-keywords", OPT_KEYWORDS,
177
169
"Allow creation of column names that are keywords.", (char**) &opt_keywords,
178
170
(char**) &opt_keywords, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
179
{"apply-slave-statements", OPT_DRIZZLEDUMP_SLAVE_APPLY,
180
"Adds 'STOP SLAVE' prior to 'CHANGE MASTER' and 'START SLAVE' to bottom of dump.",
181
(char**) &opt_slave_apply, (char**) &opt_slave_apply, 0, GET_BOOL, NO_ARG,
182
0, 0, 0, 0, 0, 0},
183
171
{"comments", 'i', "Write additional information.",
184
172
(char**) &opt_comments, (char**) &opt_comments, 0, GET_BOOL, NO_ARG,
185
173
1, 0, 0, 0, 0, 0},
217
205
{"delayed-insert", OPT_DELAYED, "Insert rows with INSERT DELAYED; ",
218
206
(char**) &opt_delayed, (char**) &opt_delayed, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
219
207
0, 0},
220
{"delete-master-logs", OPT_DELETE_MASTER_LOGS,
221
"Delete logs on master after backup. This automatically enables --master-data.",
222
(char**) &opt_delete_master_logs, (char**) &opt_delete_master_logs, 0,
223
GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
224
208
{"disable-keys", 'K',
225
209
"'ALTER TABLE tb_name DISABLE KEYS; and 'ALTER TABLE tb_name ENABLE KEYS; will be put in the output.", (char**) &opt_disable_keys,
226
210
(char**) &opt_disable_keys, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
227
{"dump-slave", OPT_DRIZZLEDUMP_SLAVE_DATA,
228
"This causes the binary log position and filename of the master to be "
229
"appended to the dumped data output. Setting the value to 1, will print"
230
"it as a CHANGE MASTER command in the dumped data output; if equal"
231
" to 2, that command will be prefixed with a comment symbol. "
232
"This option will turn --lock-all-tables on, unless "
233
"--single-transaction is specified too (in which case a "
234
"global read lock is only taken a short time at the beginning of the dump "
235
"- don't forget to read about --single-transaction below). In all cases "
236
"any action on logs will happen at the exact moment of the dump."
237
"Option automatically turns --lock-tables off.",
238
(char**) &opt_slave_data, (char**) &opt_slave_data, 0,
239
GET_UINT, OPT_ARG, 0, 0, DRIZZLE_OPT_SLAVE_DATA_COMMENTED_SQL, 0, 0, 0},
240
211
{"extended-insert", 'e',
241
212
"Allows utilization of the new, much faster INSERT syntax.",
242
213
(char**) &extended_insert, (char**) &extended_insert, 0, GET_BOOL, NO_ARG,
252
223
(char**) &opt_enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0 ,0, 0},
253
224
{"fields-escaped-by", OPT_ESC, "Fields in the i.file are escaped by ...",
254
225
(char**) &escaped, (char**) &escaped, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
255
{"first-slave", 'x', "Deprecated, renamed to --lock-all-tables.",
256
(char**) &opt_lock_all_tables, (char**) &opt_lock_all_tables, 0, GET_BOOL, NO_ARG,
257
0, 0, 0, 0, 0, 0},
258
226
{"flush-logs", 'F', "Flush logs file in server before starting dump. "
259
227
"Note that if you dump many databases at once (using the option "
260
228
"--databases= or --all-databases), the logs will be flushed for "
261
229
"each database dumped. The exception is when using --lock-all-tables "
262
"or --master-data: "
263
230
"in this case the logs will be flushed only once, corresponding "
264
231
"to the moment all tables are locked. So if you want your dump and "
265
232
"the log flush to happen at the same exact moment you should use "
266
"--lock-all-tables or --master-data with --flush-logs",
233
"--lock-all-tables or --flush-logs",
267
234
(char**) &flush_logs, (char**) &flush_logs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
268
235
0, 0},
269
236
{"force", 'f', "Continue even if we get an sql-error.",
281
248
"use the directive multiple times, once for each table. Each table must "
282
249
"be specified with both database and table names, e.g. --ignore-table=database.table",
283
250
0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
284
{"include-master-host-port", OPT_DRIZZLEDUMP_INCLUDE_MASTER_HOST_PORT,
285
"Adds 'MASTER_HOST=<host>, MASTER_PORT=<port>' to 'CHANGE MASTER TO..' in dump produced with --dump-slave.",
286
(char**) &opt_include_master_host_port,
287
(char**) &opt_include_master_host_port,
288
0, GET_BOOL, NO_ARG,
289
0, 0, 0, 0, 0, 0},
290
251
{"insert-ignore", OPT_INSERT_IGNORE, "Insert rows with INSERT IGNORE.",
291
252
(char**) &opt_ignore, (char**) &opt_ignore, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
292
253
0, 0},
298
259
"dump. Automatically turns --single-transaction and --lock-tables off.",
299
260
(char**) &opt_lock_all_tables, (char**) &opt_lock_all_tables, 0, GET_BOOL, NO_ARG,
300
261
0, 0, 0, 0, 0, 0},
301
{"master-data", OPT_MASTER_DATA,
302
"This causes the binary log position and filename to be appended to the "
303
"output. If equal to 1, will print it as a CHANGE MASTER command; if equal"
304
" to 2, that command will be prefixed with a comment symbol. "
305
"This option will turn --lock-all-tables on, unless "
306
"--single-transaction is specified too (in which case a "
307
"global read lock is only taken a short time at the beginning of the dump "
308
"- don't forget to read about --single-transaction below). In all cases "
309
"any action on logs will happen at the exact moment of the dump."
310
"Option automatically turns --lock-tables off.",
311
(char**) &opt_master_data, (char**) &opt_master_data, 0,
312
GET_UINT, OPT_ARG, 0, 0, DRIZZLE_OPT_MASTER_DATA_COMMENTED_SQL, 0, 0, 0},
313
262
{"no-autocommit", OPT_AUTOCOMMIT,
314
263
"Wrap tables with autocommit/commit statements.",
315
264
(char**) &opt_autocommit, (char**) &opt_autocommit, 0, GET_BOOL, NO_ARG,
351
300
{"routines", 'R', "Dump stored routines (functions and procedures).",
352
301
(char**) &opt_routines, (char**) &opt_routines, 0, GET_BOOL,
353
302
NO_ARG, 0, 0, 0, 0, 0, 0},
354
/*
355
Note that the combination --single-transaction --master-data
356
will give bullet-proof binlog position only if server >=4.1.3. That's the
357
old "FLUSH TABLES WITH READ LOCK does not block commit" fixed bug.
358
*/
359
303
{"single-transaction", OPT_TRANSACTION,
360
304
"Creates a consistent snapshot by dumping all tables in a single "
361
305
"transaction. Works ONLY for tables stored in storage engines which "
362
306
"support multiversioning (currently only InnoDB does); the dump is NOT "
363
307
"guaranteed to be consistent for other storage engines. "
364
308
"While a --single-transaction dump is in process, to ensure a valid "
365
"dump file (correct table contents and binary log position), no other "
309
"dump file (correct table contents), no other "
366
310
"connection should use the following statements: ALTER TABLE, DROP "
367
311
"TABLE, RENAME TABLE, TRUNCATE TABLE, as consistent snapshot is not "
368
312
"isolated from them. Option automatically turns off --lock-tables.",
675
619
case '?':
676
620
usage();
677
621
exit(0);
678
case (int) OPT_MASTER_DATA:
679
if (!argument) /* work like in old versions */
680
opt_master_data= DRIZZLE_OPT_MASTER_DATA_EFFECTIVE_SQL;
681
break;
682
case (int) OPT_DRIZZLEDUMP_SLAVE_DATA:
683
if (!argument) /* work like in old versions */
684
opt_slave_data= DRIZZLE_OPT_SLAVE_DATA_EFFECTIVE_SQL;
685
break;
686
622
case (int) OPT_OPTIMIZE:
687
623
extended_insert= opt_drop= quick= create_options=
688
624
opt_disable_keys= opt_set_charset= 1;
785
721
return(EX_USAGE);
786
722
}
787
723
788
/* We don't delete master logs if slave data option */
789
if (opt_slave_data)
790
{
791
opt_lock_all_tables= !opt_single_transaction;
792
opt_master_data= 0;
793
opt_delete_master_logs= 0;
794
}
795
796
/* Ensure consistency of the set of binlog & locking options */
797
if (opt_delete_master_logs && !opt_master_data)
798
opt_master_data= DRIZZLE_OPT_MASTER_DATA_COMMENTED_SQL;
799
724
if (opt_single_transaction && opt_lock_all_tables)
800
725
{
801
726
fprintf(stderr, _("%s: You can't use --single-transaction and "
802
727
"--lock-all-tables at the same time.\n"), my_progname);
803
728
return(EX_USAGE);
804
729
}
805
if (opt_master_data)
806
{
807
opt_lock_all_tables= !opt_single_transaction;
808
opt_slave_data= 0;
809
}
810
730
if (enclosed && opt_enclosed)
811
731
{
812
732
fprintf(stderr, _("%s: You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.\n"), my_progname);
2623
2543
return 0;
2624
2544
} /* dump_selected_tables */
2625
2545
2626
2627
static int do_show_master_status(drizzle_con_st *drizzle_con)
2628
{
2629
drizzle_row_t row;
2630
drizzle_result_st master;
2631
const char *comment_prefix=
2632
(opt_master_data == DRIZZLE_OPT_MASTER_DATA_COMMENTED_SQL) ? "-- " : "";
2633
if (drizzleclient_query_with_error_report(drizzle_con, &master, "SHOW MASTER STATUS", false))
2634
{
2635
return 1;
2636
}
2637
else
2638
{
2639
row= drizzle_row_next(&master);
2640
if (row && row[0] && row[1])
2641
{
2642
/* SHOW MASTER STATUS reports file and position */
2643
if (opt_comments)
2644
fprintf(md_result_file,
2645
"\n--\n-- Position to start replication or point-in-time "
2646
"recovery from\n--\n\n");
2647
fprintf(md_result_file,
2648
"%sCHANGE MASTER TO MASTER_LOG_FILE='%s', MASTER_LOG_POS=%s;\n",
2649
comment_prefix, row[0], row[1]);
2650
check_io(md_result_file);
2651
}
2652
else if (!ignore_errors)
2653
{
2654
/* SHOW MASTER STATUS reports nothing and --force is not enabled */
2655
my_printf_error(0, _("Error: Binlogging on server not active"),
2656
MYF(0));
2657
drizzle_result_free(&master);
2658
maybe_exit(EX_DRIZZLEERR);
2659
return 1;
2660
}
2661
drizzle_result_free(&master);
2662
}
2663
return 0;
2664
}
2665
2666
static int do_stop_slave_sql(drizzle_con_st *drizzle_con)
2667
{
2668
drizzle_result_st slave;
2669
/* We need to check if the slave sql is running in the first place */
2670
if (drizzleclient_query_with_error_report(drizzle_con, &slave, "SHOW SLAVE STATUS", false))
2671
return(1);
2672
else
2673
{
2674
drizzle_row_t row= drizzle_row_next(&slave);
2675
if (row && row[11])
2676
{
2677
/* if SLAVE SQL is not running, we don't stop it */
2678
if (!strcmp(row[11],"No"))
2679
{
2680
drizzle_result_free(&slave);
2681
/* Silently assume that they don't have the slave running */
2682
return(0);
2683
}
2684
}
2685
}
2686
drizzle_result_free(&slave);
2687
2688
/* now, stop slave if running */
2689
if (drizzleclient_query_with_error_report(drizzle_con, &slave, "STOP SLAVE SQL_THREAD", false))
2690
return(1);
2691
drizzle_result_free(&slave);
2692
2693
return(0);
2694
}
2695
2696
static int add_stop_slave(void)
2697
{
2698
if (opt_comments)
2699
fprintf(md_result_file,
2700
"\n--\n-- stop slave statement to make a recovery dump)\n--\n\n");
2701
fprintf(md_result_file, "STOP SLAVE;\n");
2702
return(0);
2703
}
2704
2705
static int add_slave_statements(void)
2706
{
2707
if (opt_comments)
2708
fprintf(md_result_file,
2709
"\n--\n-- start slave statement to make a recovery dump)\n--\n\n");
2710
fprintf(md_result_file, "START SLAVE;\n");
2711
return(0);
2712
}
2713
2714
static int do_show_slave_status(drizzle_con_st *drizzle_con)
2715
{
2716
drizzle_result_st slave;
2717
const char *comment_prefix=
2718
(opt_slave_data == DRIZZLE_OPT_SLAVE_DATA_COMMENTED_SQL) ? "-- " : "";
2719
if (drizzleclient_query_with_error_report(drizzle_con, &slave, "SHOW SLAVE STATUS", false))
2720
{
2721
if (!ignore_errors)
2722
{
2723
/* SHOW SLAVE STATUS reports nothing and --force is not enabled */
2724
my_printf_error(0, _("Error: Slave not set up"), MYF(0));
2725
}
2726
return 1;
2727
}
2728
else
2729
{
2730
drizzle_row_t row= drizzle_row_next(&slave);
2731
if (row && row[9] && row[21])
2732
{
2733
/* SHOW MASTER STATUS reports file and position */
2734
if (opt_comments)
2735
fprintf(md_result_file,
2736
"\n--\n-- Position to start replication or point-in-time "
2737
"recovery from (the master of this slave)\n--\n\n");
2738
2739
fprintf(md_result_file, "%sCHANGE MASTER TO ", comment_prefix);
2740
2741
if (opt_include_master_host_port)
2742
{
2743
if (row[1])
2744
fprintf(md_result_file, "MASTER_HOST='%s', ", row[1]);
2745
if (row[3])
2746
fprintf(md_result_file, "MASTER_PORT='%s', ", row[3]);
2747
}
2748
fprintf(md_result_file,
2749
"MASTER_LOG_FILE='%s', MASTER_LOG_POS=%s;\n", row[9], row[21]);
2750
2751
check_io(md_result_file);
2752
}
2753
drizzle_result_free(&slave);
2754
}
2755
return 0;
2756
}
2757
2758
static int do_start_slave_sql(drizzle_con_st *drizzle_con)
2759
{
2760
drizzle_result_st slave;
2761
/* We need to check if the slave sql is stopped in the first place */
2762
if (drizzleclient_query_with_error_report(drizzle_con, &slave, "SHOW SLAVE STATUS", false))
2763
return(1);
2764
else
2765
{
2766
drizzle_row_t row= drizzle_row_next(&slave);
2767
if (row && row[11])
2768
{
2769
/* if SLAVE SQL is not running, we don't start it */
2770
if (!strcmp(row[11],"Yes"))
2771
{
2772
drizzle_result_free(&slave);
2773
/* Silently assume that they don't have the slave running */
2774
return(0);
2775
}
2776
}
2777
drizzle_result_free(&slave);
2778
}
2779
2780
/* now, start slave if stopped */
2781
if (drizzleclient_query_with_error_report(drizzle_con, &slave, "START SLAVE", false))
2782
{
2783
my_printf_error(0, _("Error: Unable to start slave"), MYF(0));
2784
return 1;
2785
}
2786
drizzle_result_free(&slave);
2787
return(0);
2788
}
2789
2790
2791
2792
2546
static int do_flush_tables_read_lock(drizzle_con_st *drizzle_con)
2793
2547
{
2794
2548
/*
2805
2559
"FLUSH TABLES WITH READ LOCK", false) );
2806
2560
}
2807
2561
2808
2809
2562
static int do_unlock_tables(drizzle_con_st *drizzle_con)
2810
2563
{
2811
2564
return drizzleclient_query_with_error_report(drizzle_con, 0, "UNLOCK TABLES", false);
2812
2565
}
2813
2566
2814
static int get_bin_log_name(drizzle_con_st *drizzle_con,
2815
char* buff_log_name, uint32_t buff_len)
2816
{
2817
drizzle_result_st res;
2818
drizzle_row_t row;
2819
2820
if (drizzleclient_query_with_error_report(drizzle_con, &res, "SHOW MASTER STATUS", false))
2821
return 1;
2822
2823
if (!(row= drizzle_row_next(&res)))
2824
{
2825
drizzle_result_free(&res);
2826
return 1;
2827
}
2828
/*
2829
Only one row is returned, and the first column is the name of the
2830
active log.
2831
*/
2832
strncpy(buff_log_name, row[0], buff_len - 1);
2833
2834
drizzle_result_free(&res);
2835
return 0;
2836
}
2837
2838
static int purge_bin_logs_to(drizzle_con_st *drizzle_con, char* log_name)
2839
{
2840
int err;
2841
string str= "PURGE BINARY LOGS TO '";
2842
str.append(log_name);
2843
str.append("'");
2844
drizzle_result_st res;
2845
err= drizzleclient_query_with_error_report(drizzle_con, &res, str.c_str(),
2846
false);
2847
if (err)
2848
return err;
2849
drizzle_result_free(&res);
2850
return 0;
2851
}
2852
2853
2854
2567
static int start_transaction(drizzle_con_st *drizzle_con)
2855
2568
{
2856
2569
return (drizzleclient_query_with_error_report(drizzle_con, 0,
3140
2853
3141
2854
int main(int argc, char **argv)
3142
2855
{
3143
char bin_log_name[FN_REFLEN];
3144
2856
int exit_code;
3145
2857
MY_INIT("drizzledump");
3146
2858
drizzle_result_st result;
3164
2876
if (!path)
3165
2877
write_header(md_result_file, *argv);
3166
2878
3167
if (opt_slave_data && do_stop_slave_sql(&dcon))
3168
goto err;
3169
3170
if ((opt_lock_all_tables || opt_master_data) &&
3171
do_flush_tables_read_lock(&dcon))
2879
if ((opt_lock_all_tables) && do_flush_tables_read_lock(&dcon))
3172
2880
goto err;
3173
2881
if (opt_single_transaction && start_transaction(&dcon))
3174
2882
goto err;
3175
if (opt_delete_master_logs)
3176
{
3177
if (drizzleclient_query_with_error_report(&dcon, &result, "FLUSH LOGS", false))
3178
goto err;
3179
drizzle_result_free(&result);
3180
if (get_bin_log_name(&dcon, bin_log_name, sizeof(bin_log_name)))
3181
goto err;
3182
flush_logs= 0;
3183
}
3184
if (opt_lock_all_tables || opt_master_data)
2883
if (opt_lock_all_tables)
3185
2884
{
3186
2885
if (drizzleclient_query_with_error_report(&dcon, &result, "FLUSH LOGS", false))
3187
2886
goto err;
3188
2887
drizzle_result_free(&result);
3189
2888
flush_logs= 0; /* not anymore; that would not be sensible */
3190
2889
}
3191
/* Add 'STOP SLAVE to beginning of dump */
3192
if (opt_slave_apply && add_stop_slave())
3193
goto err;
3194
if (opt_master_data && do_show_master_status(&dcon))
3195
goto err;
3196
if (opt_slave_data && do_show_slave_status(&dcon))
3197
goto err;
3198
2890
if (opt_single_transaction && do_unlock_tables(&dcon)) /* unlock but no commit! */
3199
2891
goto err;
3200
2892
3212
2904
dump_databases(argv);
3213
2905
}
3214
2906
3215
/* if --dump-slave , start the slave sql thread */
3216
if (opt_slave_data && do_start_slave_sql(&dcon))
3217
goto err;
3218
3219
/* add 'START SLAVE' to end of dump */
3220
if (opt_slave_apply && add_slave_statements())
3221
goto err;
3222
3223
2907
/* ensure dumped data flushed */
3224
2908
if (md_result_file && fflush(md_result_file))
3225
2909
{
3227
2911
first_error= EX_DRIZZLEERR;
3228
2912
goto err;
3229
2913
}
3230
/* everything successful, purge the old logs files */
3231
if (opt_delete_master_logs && purge_bin_logs_to(&dcon, bin_log_name))
3232
goto err;
3233
2914
3234
2915
/*
3235
2916
No reason to explicitely COMMIT the transaction, neither to explicitely
Loggerhead is a web-based interface for Breezy
Version: 2.0.1