22
22
** WARRANTY: None, expressed, impressed, implied
24
24
** STATUS: Public domain
25
** Adapted and optimized for MySQL by
26
** Michael Widenius, Sinisa Milivojevic, Jani Tolonen
27
** -w --where added 9/10/98 by Jim Faucette
28
** slave code by David Saez Padros <david@ols.es>
29
** master/autocommit code by Brian Aker <brian@tangent.org>
31
** Andrei Errapart <andreie@no.spam.ee>
32
** Tõnu Samuel <tonu@please.do.not.remove.this.spam.ee>
33
** XML by Gary Huntress <ghuntress@mediaone.net> 10/10/01, cleaned up
34
** and adapted to mysqldump 05/11/01 by Jani Tolonen
35
** Added --single-transaction option 06/06/2002 by Peter Zaitsev
36
** 10 Jun 2003: SET NAMES and --no-set-names by Alexander Barkov
27
39
#define DUMP_VERSION "10.13"
41
#include <my_global.h>
31
48
#include "client_priv.h"
33
#include <mysys/my_sys.h>
34
#include <mystrings/m_string.h>
35
#include <mystrings/m_ctype.h>
36
#include <mysys/hash.h>
39
#include <drizzled/error.h>
49
#include "drizzle_version.h"
50
#include "mysqld_error.h"
45
#define EX_DRIZZLEERR 2
46
56
#define EX_CONSCHECK 3
48
58
#define EX_EOF 5 /* ferror for output file was got */
64
74
#define IGNORE_DATA 0x01 /* don't dump data for this table */
65
75
#define IGNORE_INSERT_DELAYED 0x02 /* table doesn't support INSERT DELAYED */
67
static void add_load_option(string &str, const char *option,
68
const char *option_value);
69
static uint32_t find_set(TYPELIB *lib, const char *x, uint length,
77
static void add_load_option(DYNAMIC_STRING *str, const char *option,
78
const char *option_value);
79
static ulong find_set(TYPELIB *lib, const char *x, uint length,
70
80
char **err_pos, uint *err_len);
72
static void field_escape(string &in, const char *from);
82
static void field_escape(DYNAMIC_STRING* in, const char *from);
73
83
static bool verbose= 0, opt_no_create_info= 0, opt_no_data= 0,
74
84
quick= 1, extended_insert= 1,
75
85
lock_tables=1,ignore_errors=0,flush_logs=0,flush_privileges=0,
88
98
opt_include_master_host_port= 0,
90
100
opt_alltspcs=0, opt_notspcs= 0;
91
static bool debug_info_flag= 0, debug_check_flag= 0;
92
static uint32_t opt_max_allowed_packet, opt_net_buffer_length;
93
static DRIZZLE drizzle_connection,*drizzle=0;
94
static string insert_pat;
101
static bool insert_pat_inited= 0, debug_info_flag= 0, debug_check_flag= 0;
102
static ulong opt_max_allowed_packet, opt_net_buffer_length;
103
static MYSQL mysql_connection,*mysql=0;
104
static DYNAMIC_STRING insert_pat;
95
105
static char *opt_password=0,*current_user=0,
96
106
*current_host=0,*path=0,*fields_terminated=0,
97
107
*lines_terminated=0, *enclosed=0, *opt_enclosed=0, *escaped=0,
102
112
static char **defaults_argv= 0;
103
113
static char compatible_mode_normal_str[255];
104
114
/* Server supports character_set_results session variable? */
105
static bool server_supports_switching_charsets= true;
106
static uint32_t opt_compatible_mode= 0;
107
#define DRIZZLE_OPT_MASTER_DATA_EFFECTIVE_SQL 1
108
#define DRIZZLE_OPT_MASTER_DATA_COMMENTED_SQL 2
109
#define DRIZZLE_OPT_SLAVE_DATA_EFFECTIVE_SQL 1
110
#define DRIZZLE_OPT_SLAVE_DATA_COMMENTED_SQL 2
111
static uint opt_drizzle_port= 0, opt_master_data;
115
static bool server_supports_switching_charsets= TRUE;
116
static ulong opt_compatible_mode= 0;
117
#define MYSQL_OPT_MASTER_DATA_EFFECTIVE_SQL 1
118
#define MYSQL_OPT_MASTER_DATA_COMMENTED_SQL 2
119
#define MYSQL_OPT_SLAVE_DATA_EFFECTIVE_SQL 1
120
#define MYSQL_OPT_SLAVE_DATA_COMMENTED_SQL 2
121
static uint opt_mysql_port= 0, opt_master_data;
112
122
static uint opt_slave_data;
113
123
static uint my_end_arg;
114
124
static int first_error=0;
115
static string extended_row;
125
static DYNAMIC_STRING extended_row;
116
126
FILE *md_result_file= 0;
117
127
FILE *stderror_file=0;
130
static char *shared_memory_base_name=0;
132
static uint opt_protocol= MYSQL_PROTOCOL_TCP;
135
Dynamic_string wrapper functions. In this file use these
136
wrappers, they will terminate the process if there is
137
an allocation failure.
139
static void init_dynamic_string_checked(DYNAMIC_STRING *str, const char *init_str,
140
uint init_alloc, uint alloc_increment);
141
static void dynstr_append_checked(DYNAMIC_STRING* dest, const char* src);
142
static void dynstr_set_checked(DYNAMIC_STRING *str, const char *init_str);
143
static void dynstr_append_mem_checked(DYNAMIC_STRING *str, const char *append,
145
static void dynstr_realloc_checked(DYNAMIC_STRING *str, ulong additional_size);
120
147
Constant for detection of default value of default_charset.
121
If default_charset is equal to drizzle_universal_client_charset, then
148
If default_charset is equal to mysql_universal_client_charset, then
122
149
it is the default value which assigned at the very beginning of main().
124
static const char *drizzle_universal_client_charset=
125
DRIZZLE_UNIVERSAL_CLIENT_CHARSET;
151
static const char *mysql_universal_client_charset=
152
MYSQL_UNIVERSAL_CLIENT_CHARSET;
126
153
static char *default_charset;
127
static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;
128
const char *default_dbug_option="d:t:o,/tmp/drizzledump.trace";
154
static CHARSET_INFO *charset_info= &my_charset_latin1;
155
const char *default_dbug_option="d:t:o,/tmp/mysqldump.trace";
129
156
/* have we seen any VIEWs during table scanning? */
130
157
bool seen_views= 0;
131
158
const char *compatible_mode_names[]=
178
205
{"allow-keywords", OPT_KEYWORDS,
179
206
"Allow creation of column names that are keywords.", (char**) &opt_keywords,
180
207
(char**) &opt_keywords, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
181
{"apply-slave-statements", OPT_DRIZZLEDUMP_SLAVE_APPLY,
208
{"apply-slave-statements", OPT_MYSQLDUMP_SLAVE_APPLY,
182
209
"Adds 'STOP SLAVE' prior to 'CHANGE MASTER' and 'START SLAVE' to bottom of dump.",
183
210
(char**) &opt_slave_apply, (char**) &opt_slave_apply, 0, GET_BOOL, NO_ARG,
184
211
0, 0, 0, 0, 0, 0},
189
216
(char**) &opt_comments, (char**) &opt_comments, 0, GET_BOOL, NO_ARG,
190
217
1, 0, 0, 0, 0, 0},
191
218
{"compatible", OPT_COMPATIBLE,
192
"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.",
219
"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 MySQL server version 4.1.0 or higher. This option is ignored with earlier server versions.",
193
220
(char**) &opt_compatible_mode_str, (char**) &opt_compatible_mode_str, 0,
194
221
GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
195
222
{"compact", OPT_COMPACT,
203
230
(char**) &opt_compress, (char**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
205
232
{"create-options", OPT_CREATE_OPTIONS,
206
"Include all DRIZZLE specific create options.",
233
"Include all MySQL specific create options.",
207
234
(char**) &create_options, (char**) &create_options, 0, GET_BOOL, NO_ARG, 1,
209
236
{"databases", 'B',
229
256
{"disable-keys", 'K',
230
257
"'/*!40000 ALTER TABLE tb_name DISABLE KEYS */; and '/*!40000 ALTER TABLE tb_name ENABLE KEYS */; will be put in the output.", (char**) &opt_disable_keys,
231
258
(char**) &opt_disable_keys, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
232
{"dump-slave", OPT_DRIZZLEDUMP_SLAVE_DATA,
259
{"dump-slave", OPT_MYSQLDUMP_SLAVE_DATA,
233
260
"This causes the binary log position and filename of the master to be "
234
261
"appended to the dumped data output. Setting the value to 1, will print"
235
262
"it as a CHANGE MASTER command in the dumped data output; if equal"
241
268
"any action on logs will happen at the exact moment of the dump."
242
269
"Option automatically turns --lock-tables off.",
243
270
(char**) &opt_slave_data, (char**) &opt_slave_data, 0,
244
GET_UINT, OPT_ARG, 0, 0, DRIZZLE_OPT_SLAVE_DATA_COMMENTED_SQL, 0, 0, 0},
271
GET_UINT, OPT_ARG, 0, 0, MYSQL_OPT_SLAVE_DATA_COMMENTED_SQL, 0, 0, 0},
245
272
{"events", 'E', "Dump events.",
246
273
(char**) &opt_events, (char**) &opt_events, 0, GET_BOOL,
247
274
NO_ARG, 0, 0, 0, 0, 0, 0},
275
302
(char**) &flush_logs, (char**) &flush_logs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
277
304
{"flush-privileges", OPT_ESC, "Emit a FLUSH PRIVILEGES statement "
278
"after dumping the DRIZZLE database. This option should be used any "
279
"time the dump contains the DRIZZLE database and any other database "
280
"that depends on the data in the DRIZZLE database for proper restore. ",
305
"after dumping the mysql database. This option should be used any "
306
"time the dump contains the mysql database and any other database "
307
"that depends on the data in the mysql database for proper restore. ",
281
308
(char**) &flush_privileges, (char**) &flush_privileges, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
283
310
{"force", 'f', "Continue even if we get an sql-error.",
295
322
"use the directive multiple times, once for each table. Each table must "
296
323
"be specified with both database and table names, e.g. --ignore-table=database.table",
297
324
0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
298
{"include-master-host-port", OPT_DRIZZLEDUMP_INCLUDE_MASTER_HOST_PORT,
325
{"include-master-host-port", OPT_MYSQLDUMP_INCLUDE_MASTER_HOST_PORT,
299
326
"Adds 'MASTER_HOST=<host>, MASTER_PORT=<port>' to 'CHANGE MASTER TO..' in dump produced with --dump-slave.",
300
327
(char**) &opt_include_master_host_port,
301
328
(char**) &opt_include_master_host_port,
328
355
"any action on logs will happen at the exact moment of the dump."
329
356
"Option automatically turns --lock-tables off.",
330
357
(char**) &opt_master_data, (char**) &opt_master_data, 0,
331
GET_UINT, OPT_ARG, 0, 0, DRIZZLE_OPT_MASTER_DATA_COMMENTED_SQL, 0, 0, 0},
358
GET_UINT, OPT_ARG, 0, 0, MYSQL_OPT_MASTER_DATA_COMMENTED_SQL, 0, 0, 0},
332
359
{"max_allowed_packet", OPT_MAX_ALLOWED_PACKET, "",
333
360
(char**) &opt_max_allowed_packet, (char**) &opt_max_allowed_packet, 0,
334
361
GET_ULONG, REQUIRED_ARG, 24*1024*1024, 4096,
362
389
{"password", 'p',
363
390
"Password to use when connecting to server. If password is not given it's solicited on the tty.",
364
391
0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
365
{"port", 'P', "Port number to use for connection.", (char**) &opt_drizzle_port,
366
(char**) &opt_drizzle_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0,
392
{"port", 'P', "Port number to use for connection.", (char**) &opt_mysql_port,
393
(char**) &opt_mysql_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0,
368
395
{"quick", 'q', "Don't buffer query, dump directly to stdout.",
369
396
(char**) &quick, (char**) &quick, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
370
397
{"quote-names",'Q', "Quote table and column names with backticks (`).",
371
398
(char**) &opt_quoted, (char**) &opt_quoted, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0,
373
{"replace", OPT_DRIZZLE_REPLACE_INTO, "Use REPLACE INTO instead of INSERT INTO.",
400
{"replace", OPT_MYSQL_REPLACE_INTO, "Use REPLACE INTO instead of INSERT INTO.",
374
401
(char**) &opt_replace_into, (char**) &opt_replace_into, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
376
403
{"result-file", 'r',
386
413
{"set-variable", 'O',
387
414
"Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value.",
388
415
0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
417
{"shared-memory-base-name", OPT_SHARED_MEMORY_BASE_NAME,
418
"Base name of shared memory.", (char**) &shared_memory_base_name, (char**) &shared_memory_base_name,
419
0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
390
422
Note that the combination --single-transaction --master-data
391
423
will give bullet-proof binlog position only if server >=4.1.3. That's the
433
465
{0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
436
static const char *load_default_groups[]= { "drizzledump","client",0 };
468
static const char *load_default_groups[]= { "mysqldump","client",0 };
438
470
static void maybe_exit(int error);
439
471
static void die(int error, const char* reason, ...);
440
472
static void maybe_die(int error, const char* reason, ...);
441
473
static void write_header(FILE *sql_file, char *db_name);
442
static void print_value(FILE *file, DRIZZLE_RES *result, DRIZZLE_ROW row,
474
static void print_value(FILE *file, MYSQL_RES *result, MYSQL_ROW row,
443
475
const char *prefix,const char *name,
444
476
int string_value);
445
477
static int dump_selected_tables(char *db, char **table_names, int tables);
544
582
if (opt_comments)
546
584
fprintf(sql_file,
547
"-- DRIZZLE dump %s Distrib %s, for %s (%s)\n--\n",
548
DUMP_VERSION, drizzle_get_client_info(),
549
SYSTEM_TYPE, MACHINE_TYPE);
585
"-- MySQL dump %s Distrib %s, for %s (%s)\n--\n",
586
DUMP_VERSION, MYSQL_SERVER_VERSION, SYSTEM_TYPE, MACHINE_TYPE);
550
587
fprintf(sql_file, "-- Host: %s Database: %s\n",
551
588
current_host ? current_host : "localhost", db_name ? db_name :
553
590
fputs("-- ------------------------------------------------------\n",
555
592
fprintf(sql_file, "-- Server version\t%s\n",
556
drizzle_get_server_info(&drizzle_connection));
593
mysql_get_server_info(&mysql_connection));
558
595
if (opt_set_charset)
559
596
fprintf(sql_file,
597
"\n/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;"
598
"\n/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;"
560
599
"\n/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;"
561
600
"\n/*!40101 SET NAMES %s */;\n",default_charset);
688
729
case (int) OPT_MASTER_DATA:
689
730
if (!argument) /* work like in old versions */
690
opt_master_data= DRIZZLE_OPT_MASTER_DATA_EFFECTIVE_SQL;
731
opt_master_data= MYSQL_OPT_MASTER_DATA_EFFECTIVE_SQL;
692
case (int) OPT_DRIZZLEDUMP_SLAVE_DATA:
733
case (int) OPT_MYSQLDUMP_SLAVE_DATA:
693
734
if (!argument) /* work like in old versions */
694
opt_slave_data= DRIZZLE_OPT_SLAVE_DATA_EFFECTIVE_SQL;
735
opt_slave_data= MYSQL_OPT_SLAVE_DATA_EFFECTIVE_SQL;
696
737
case (int) OPT_OPTIMIZE:
697
738
extended_insert= opt_drop= opt_lock= quick= create_options=
727
768
char *end= compatible_mode_normal_str;
733
774
opt_set_charset= 0;
734
775
opt_compatible_mode_str= argument;
735
776
opt_compatible_mode= find_set(&compatible_mode_typelib,
736
777
argument, strlen(argument),
737
&err_ptr, &error_len);
740
strmake(buff, err_ptr, min((uint32_t)sizeof(buff), error_len));
781
strmake(buff, err_ptr, min(sizeof(buff), err_len));
741
782
fprintf(stderr, "Invalid mode to --compatible: %s\n", buff);
767
808
static int get_options(int *argc, char ***argv)
770
const DRIZZLE_PARAMETERS *drizzle_params= drizzle_get_parameters();
811
MYSQL_PARAMETERS *mysql_params= mysql_get_parameters();
772
opt_max_allowed_packet= *drizzle_params->p_max_allowed_packet;
773
opt_net_buffer_length= *drizzle_params->p_net_buffer_length;
813
opt_max_allowed_packet= *mysql_params->p_max_allowed_packet;
814
opt_net_buffer_length= *mysql_params->p_net_buffer_length;
775
816
md_result_file= stdout;
776
817
load_defaults("my",load_default_groups,argc,argv);
783
824
/* Don't copy internal log tables */
784
825
if (my_hash_insert(&ignore_table,
785
(unsigned char*) my_strdup("mysql.apply_status", MYF(MY_WME))) ||
786
my_hash_insert(&ignore_table,
787
(unsigned char*) my_strdup("mysql.schema", MYF(MY_WME))) ||
788
my_hash_insert(&ignore_table,
789
(unsigned char*) my_strdup("mysql.general_log", MYF(MY_WME))) ||
790
my_hash_insert(&ignore_table,
791
(unsigned char*) my_strdup("mysql.slow_log", MYF(MY_WME))) ||
792
my_hash_insert(&ignore_table,
793
(unsigned char*) my_strdup("mysql.online_backup", MYF(MY_WME))) ||
794
my_hash_insert(&ignore_table,
795
(unsigned char*) my_strdup("mysql.online_backup_progress", MYF(MY_WME))))
826
(uchar*) my_strdup("mysql.apply_status", MYF(MY_WME))) ||
827
my_hash_insert(&ignore_table,
828
(uchar*) my_strdup("mysql.schema", MYF(MY_WME))) ||
829
my_hash_insert(&ignore_table,
830
(uchar*) my_strdup("mysql.general_log", MYF(MY_WME))) ||
831
my_hash_insert(&ignore_table,
832
(uchar*) my_strdup("mysql.slow_log", MYF(MY_WME))) ||
833
my_hash_insert(&ignore_table,
834
(uchar*) my_strdup("mysql.online_backup", MYF(MY_WME))) ||
835
my_hash_insert(&ignore_table,
836
(uchar*) my_strdup("mysql.online_backup_progress", MYF(MY_WME))))
798
839
if ((ho_error= handle_options(argc, argv, my_long_options, get_one_option)))
799
840
return(ho_error);
801
*drizzle_params->p_max_allowed_packet= opt_max_allowed_packet;
802
*drizzle_params->p_net_buffer_length= opt_net_buffer_length;
842
*mysql_params->p_max_allowed_packet= opt_max_allowed_packet;
843
*mysql_params->p_net_buffer_length= opt_net_buffer_length;
803
844
if (debug_info_flag)
804
845
my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;
805
846
if (debug_check_flag)
863
904
if (tty_password)
864
opt_password=get_tty_password(NULL);
905
opt_password=get_tty_password(NullS);
866
907
} /* get_options */
870
** DB_error -- prints DRIZZLE error message and exits the program.
911
** DB_error -- prints mysql error message and exits the program.
872
static void DB_error(DRIZZLE *drizzle_arg, const char *when)
913
static void DB_error(MYSQL *mysql_arg, const char *when)
875
maybe_die(EX_DRIZZLEERR, "Got error: %d: %s %s",
876
drizzle_errno(drizzle_arg), drizzle_error(drizzle_arg), when);
916
maybe_die(EX_MYSQLERR, "Got error: %d: %s %s",
917
mysql_errno(mysql_arg), mysql_error(mysql_arg), when);
961
static int drizzle_query_with_error_report(DRIZZLE *drizzle_con, DRIZZLE_RES **res,
1002
static int mysql_query_with_error_report(MYSQL *mysql_con, MYSQL_RES **res,
962
1003
const char *query)
964
if (drizzle_query(drizzle_con, query) ||
965
(res && !((*res)= drizzle_store_result(drizzle_con))))
1005
if (mysql_query(mysql_con, query) ||
1006
(res && !((*res)= mysql_store_result(mysql_con))))
967
maybe_die(EX_DRIZZLEERR, "Couldn't execute '%s': %s (%d)",
968
query, drizzle_error(drizzle_con), drizzle_errno(drizzle_con));
1008
maybe_die(EX_MYSQLERR, "Couldn't execute '%s': %s (%d)",
1009
query, mysql_error(mysql_con), mysql_errno(mysql_con));
985
1026
@returns whether there was an error or not
987
static int switch_character_set_results(DRIZZLE *drizzle, const char *cs_name)
1028
static int switch_character_set_results(MYSQL *mysql, const char *cs_name)
989
1030
char query_buffer[QUERY_LENGTH];
990
1031
size_t query_length;
992
1033
/* Server lacks facility. This is not an error, by arbitrary decision . */
993
1034
if (!server_supports_switching_charsets)
996
1037
query_length= snprintf(query_buffer,
997
1038
sizeof (query_buffer),
998
1039
"SET SESSION character_set_results = '%s'",
999
1040
(const char *) cs_name);
1001
return drizzle_real_query(drizzle, query_buffer, query_length);
1042
return mysql_real_query(mysql, query_buffer, query_length);
1028
1069
if (md_result_file && md_result_file != stdout)
1029
1070
my_fclose(md_result_file, MYF(0));
1071
my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));
1031
1072
if (hash_inited(&ignore_table))
1032
1073
hash_free(&ignore_table);
1074
if (extended_insert)
1075
dynstr_free(&extended_row);
1076
if (insert_pat_inited)
1077
dynstr_free(&insert_pat);
1033
1078
if (defaults_argv)
1034
1079
free_defaults(defaults_argv);
1035
1080
my_end(my_end_arg);
1061
1106
verbose_msg("-- Connecting to %s...\n", host ? host : "localhost");
1062
drizzle_create(&drizzle_connection);
1107
mysql_init(&mysql_connection);
1063
1108
if (opt_compress)
1064
drizzle_options(&drizzle_connection,DRIZZLE_OPT_COMPRESS,NULL);
1065
if (!(drizzle= drizzle_connect(&drizzle_connection,host,user,passwd,
1066
NULL,opt_drizzle_port, NULL,
1109
mysql_options(&mysql_connection,MYSQL_OPT_COMPRESS,NullS);
1111
mysql_options(&mysql_connection,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
1113
if (shared_memory_base_name)
1114
mysql_options(&mysql_connection,MYSQL_SHARED_MEMORY_BASE_NAME,shared_memory_base_name);
1116
mysql_options(&mysql_connection, MYSQL_SET_CHARSET_NAME, default_charset);
1117
if (!(mysql= mysql_real_connect(&mysql_connection,host,user,passwd,
1118
NULL,opt_mysql_port, NULL,
1069
DB_error(&drizzle_connection, "when trying to connect");
1121
DB_error(&mysql_connection, "when trying to connect");
1072
if (drizzle_get_server_version(&drizzle_connection) < 40100)
1124
if (mysql_get_server_version(&mysql_connection) < 40100)
1074
1126
/* Don't dump SET NAMES with a pre-4.1 server (bug#7997). */
1075
1127
opt_set_charset= 0;
1077
1129
/* Don't switch charsets for 4.1 and earlier. (bug#34192). */
1078
server_supports_switching_charsets= false;
1130
server_supports_switching_charsets= FALSE;
1081
1133
set time_zone to UTC to allow dumping date types between servers with
1108
1160
if (!(tmp=(char*) my_malloc(length*2+1, MYF(MY_WME))))
1109
die(EX_DRIZZLEERR, "Couldn't allocate memory");
1161
die(EX_MYSQLERR, "Couldn't allocate memory");
1111
drizzle_escape_string(tmp, pos, length);
1163
mysql_real_escape_string(&mysql_connection, tmp, pos, length);
1112
1164
fputc('\'', file);
1113
1165
fputs(tmp, file);
1114
1166
fputc('\'', file);
1115
1167
check_io(file);
1168
my_free(tmp, MYF(MY_WME));
1118
1170
} /* unescape */
1121
1173
static bool test_if_special_chars(const char *str)
1175
#if MYSQL_VERSION_ID >= 32300
1123
1176
for ( ; *str ; str++)
1124
1177
if (!my_isvar(charset_info,*str) && *str != '$')
1127
1181
} /* test_if_special_chars */
1176
1230
Quote \, _, ' and % characters
1178
Note: Because DRIZZLE uses the C escape syntax in strings
1232
Note: Because MySQL uses the C escape syntax in strings
1179
1233
(for example, '\n' to represent newline), you must double
1180
1234
any '\' that you use in your LIKE strings. For example, to
1181
1235
search for '\n', specify it as '\\n'. To search for '\', specify
1292
1346
va_start(arg_list, first_attribute_name);
1293
1347
attribute_name= first_attribute_name;
1294
while (attribute_name != NULL)
1348
while (attribute_name != NullS)
1296
1350
attribute_value= va_arg(arg_list, char *);
1297
assert(attribute_value != NULL);
1351
assert(attribute_value != NullS);
1299
1353
fputc(' ', xml_file);
1300
1354
fputs(attribute_name, xml_file);
1367
1421
static void print_xml_row(FILE *xml_file, const char *row_name,
1368
DRIZZLE_RES *tableRes, DRIZZLE_ROW *row)
1422
MYSQL_RES *tableRes, MYSQL_ROW *row)
1371
DRIZZLE_FIELD *field;
1372
uint32_t *lengths= drizzle_fetch_lengths(tableRes);
1426
ulong *lengths= mysql_fetch_lengths(tableRes);
1374
1428
fprintf(xml_file, "\t\t<%s", row_name);
1375
1429
check_io(xml_file);
1376
drizzle_field_seek(tableRes, 0);
1377
for (i= 0; (field= drizzle_fetch_field(tableRes)); i++)
1430
mysql_field_seek(tableRes, 0);
1431
for (i= 0; (field= mysql_fetch_field(tableRes)); i++)
1404
1458
Print hex value for blob data.
1407
static void print_blob_as_hex(FILE *output_file, const char *str, uint32_t len)
1461
static void print_blob_as_hex(FILE *output_file, const char *str, ulong len)
1409
1463
/* sakaik got the idea to to provide blob's in hex notation. */
1410
1464
const char *ptr= str, *end= ptr + len;
1411
1465
for (; ptr < end ; ptr++)
1412
fprintf(output_file, "%02X", *((unsigned char *)ptr));
1466
fprintf(output_file, "%02X", *((uchar *)ptr));
1413
1467
check_io(output_file);
1432
1486
char *ignore_flag)
1434
1488
bool init=0, delayed, write_data, complete_insert;
1435
uint64_t num_fields;
1489
my_uint64_t num_fields;
1436
1490
char *result_table, *opt_quoted_table;
1437
1491
const char *insert_option;
1438
1492
char name_buff[NAME_LEN+3],table_buff[NAME_LEN*2+3];
1439
1493
char table_buff2[NAME_LEN*2+3], query_buff[QUERY_LENGTH];
1440
1494
FILE *sql_file= md_result_file;
1442
DRIZZLE_RES *result;
1445
1499
*ignore_flag= check_if_ignore_table(table, table_type);
1474
1534
if (opt_order_by_primary)
1536
my_free(order_by, MYF(MY_ALLOW_ZERO_PTR));
1477
1537
order_by= primary_key_fields(result_table);
1480
if (!opt_xml && !drizzle_query_with_error_report(drizzle, 0, query_buff))
1540
if (!opt_xml && !mysql_query_with_error_report(mysql, 0, query_buff))
1482
1542
/* using SHOW CREATE statement */
1483
1543
if (!opt_no_create_info)
1485
1545
/* Make an sql-file, if path was given iow. option -T was given */
1486
1546
char buff[20+FN_REFLEN];
1487
const DRIZZLE_FIELD *field;
1489
1549
snprintf(buff, sizeof(buff), "show create table %s", result_table);
1491
if (switch_character_set_results(drizzle, "binary") ||
1492
drizzle_query_with_error_report(drizzle, &result, buff) ||
1493
switch_character_set_results(drizzle, default_charset))
1551
if (switch_character_set_results(mysql, "binary") ||
1552
mysql_query_with_error_report(mysql, &result, buff) ||
1553
switch_character_set_results(mysql, default_charset))
1529
1589
verbose_msg("-- It's a view, create dummy table for view\n");
1531
1591
/* save "show create" statement for later */
1532
if ((row= drizzle_fetch_row(result)) && (scv_buff=row[1]))
1592
if ((row= mysql_fetch_row(result)) && (scv_buff=row[1]))
1533
1593
scv_buff= my_strdup(scv_buff, MYF(0));
1535
drizzle_free_result(result);
1595
mysql_free_result(result);
1538
1598
Create a table with the same name as the view and with columns of
1548
1608
snprintf(query_buff, sizeof(query_buff),
1549
1609
"SHOW FIELDS FROM %s", result_table);
1550
if (switch_character_set_results(drizzle, "binary") ||
1551
drizzle_query_with_error_report(drizzle, &result, query_buff) ||
1552
switch_character_set_results(drizzle, default_charset))
1610
if (switch_character_set_results(mysql, "binary") ||
1611
mysql_query_with_error_report(mysql, &result, query_buff) ||
1612
switch_character_set_results(mysql, default_charset))
1555
1615
View references invalid or privileged table/col/fun (err 1356),
1557
1617
a comment with the view's 'show create' statement. (Bug #17371)
1560
if (drizzle_errno(drizzle) == ER_VIEW_INVALID)
1620
if (mysql_errno(mysql) == ER_VIEW_INVALID)
1561
1621
fprintf(sql_file, "\n-- failed on view %s: %s\n\n", result_table, scv_buff ? scv_buff : "");
1623
my_free(scv_buff, MYF(MY_ALLOW_ZERO_PTR));
1628
my_free(scv_buff, MYF(MY_ALLOW_ZERO_PTR));
1570
if (drizzle_num_rows(result))
1630
if (mysql_num_rows(result))
1591
1653
there should be a _trailing_ comma.
1594
row= drizzle_fetch_row(result);
1656
row= mysql_fetch_row(result);
1596
1658
fprintf(sql_file, " %s %s", quote_name(row[0], name_buff, 0),
1599
while((row= drizzle_fetch_row(result)))
1661
while((row= mysql_fetch_row(result)))
1601
1663
/* col name, col type */
1602
1664
fprintf(sql_file, ",\n %s %s",
1603
1665
quote_name(row[0], name_buff, 0), row[1]);
1605
fprintf(sql_file, "\n) */;\n");
1669
"SET character_set_client = @saved_cs_client;\n");
1606
1671
check_io(sql_file);
1609
drizzle_free_result(result);
1674
mysql_free_result(result);
1612
1677
my_fclose(sql_file, MYF(MY_WME));
1618
row= drizzle_fetch_row(result);
1683
row= mysql_fetch_row(result);
1620
fprintf(sql_file, "%s;\n", row[1]);
1686
"SET @saved_cs_client = @@character_set_client;\n"
1687
"SET character_set_client = utf8;\n"
1689
"SET character_set_client = @saved_cs_client;\n",
1622
1692
check_io(sql_file);
1623
drizzle_free_result(result);
1693
mysql_free_result(result);
1625
1695
snprintf(query_buff, sizeof(query_buff), "show fields from %s",
1627
if (drizzle_query_with_error_report(drizzle, &result, query_buff))
1697
if (mysql_query_with_error_report(mysql, &result, query_buff))
1630
1700
my_fclose(sql_file, MYF(MY_WME));
1640
1710
if (write_data)
1642
1712
if (opt_replace_into)
1643
insert_pat.append("REPLACE ");
1713
dynstr_append_checked(&insert_pat, "REPLACE ");
1645
insert_pat.append("INSERT ");
1646
insert_pat.append(insert_option);
1647
insert_pat.append("INTO ");
1648
insert_pat.append(opt_quoted_table);
1715
dynstr_append_checked(&insert_pat, "INSERT ");
1716
dynstr_append_checked(&insert_pat, insert_option);
1717
dynstr_append_checked(&insert_pat, "INTO ");
1718
dynstr_append_checked(&insert_pat, opt_quoted_table);
1649
1719
if (complete_insert)
1651
insert_pat.append(" (");
1721
dynstr_append_checked(&insert_pat, " (");
1655
insert_pat.append(" VALUES ");
1725
dynstr_append_checked(&insert_pat, " VALUES ");
1656
1726
if (!extended_insert)
1657
insert_pat.append("(");
1727
dynstr_append_checked(&insert_pat, "(");
1661
while ((row= drizzle_fetch_row(result)))
1731
while ((row= mysql_fetch_row(result)))
1663
1733
if (complete_insert)
1667
insert_pat.append(", ");
1737
dynstr_append_checked(&insert_pat, ", ");
1670
insert_pat.append(quote_name(row[SHOW_FIELDNAME], name_buff, 0));
1740
dynstr_append_checked(&insert_pat,
1741
quote_name(row[SHOW_FIELDNAME], name_buff, 0));
1673
num_fields= drizzle_num_rows(result);
1674
drizzle_free_result(result);
1744
num_fields= mysql_num_rows(result);
1745
mysql_free_result(result);
1678
1749
verbose_msg("%s: Warning: Can't set SQL_QUOTE_SHOW_CREATE option (%s)\n",
1679
my_progname, drizzle_error(drizzle));
1750
my_progname, mysql_error(mysql));
1681
1752
snprintf(query_buff, sizeof(query_buff), "show fields from %s",
1683
if (drizzle_query_with_error_report(drizzle, &result, query_buff))
1754
if (mysql_query_with_error_report(mysql, &result, query_buff))
1686
1757
/* Make an sql-file, if path was given iow. option -T was given */
1701
1772
fprintf(sql_file, "CREATE TABLE %s (\n", result_table);
1703
1774
print_xml_tag(sql_file, "\t", "\n", "table_structure", "name=", table,
1705
1776
check_io(sql_file);
1708
1779
if (write_data)
1710
1781
if (opt_replace_into)
1711
insert_pat.append("REPLACE ");
1782
dynstr_append_checked(&insert_pat, "REPLACE ");
1713
insert_pat.append("INSERT ");
1714
insert_pat.append(insert_option);
1715
insert_pat.append("INTO ");
1716
insert_pat.append(result_table);
1784
dynstr_append_checked(&insert_pat, "INSERT ");
1785
dynstr_append_checked(&insert_pat, insert_option);
1786
dynstr_append_checked(&insert_pat, "INTO ");
1787
dynstr_append_checked(&insert_pat, result_table);
1717
1788
if (complete_insert)
1718
insert_pat.append(" (");
1789
dynstr_append_checked(&insert_pat, " (");
1721
insert_pat.append(" VALUES ");
1792
dynstr_append_checked(&insert_pat, " VALUES ");
1722
1793
if (!extended_insert)
1723
insert_pat.append("(");
1794
dynstr_append_checked(&insert_pat, "(");
1727
while ((row= drizzle_fetch_row(result)))
1798
while ((row= mysql_fetch_row(result)))
1729
uint32_t *lengths= drizzle_fetch_lengths(result);
1800
ulong *lengths= mysql_fetch_lengths(result);
1732
1803
if (!opt_xml && !opt_no_create_info)
1768
1840
check_io(sql_file);
1771
num_fields= drizzle_num_rows(result);
1772
drizzle_free_result(result);
1843
num_fields= mysql_num_rows(result);
1844
mysql_free_result(result);
1773
1845
if (!opt_no_create_info)
1775
1847
/* Make an sql-file, if path was given iow. option -T was given */
1776
1848
char buff[20+FN_REFLEN];
1777
1849
uint keynr,primary_key;
1778
1850
snprintf(buff, sizeof(buff), "show keys from %s", result_table);
1779
if (drizzle_query_with_error_report(drizzle, &result, buff))
1851
if (mysql_query_with_error_report(mysql, &result, buff))
1781
if (drizzle_errno(drizzle) == ER_WRONG_OBJECT)
1853
if (mysql_errno(mysql) == ER_WRONG_OBJECT)
1783
1855
/* it is VIEW */
1784
1856
fputs("\t\t<options Comment=\"view\" />\n", sql_file);
1785
1857
goto continue_xml;
1787
1859
fprintf(stderr, "%s: Can't get keys for table %s (%s)\n",
1788
my_progname, result_table, drizzle_error(drizzle));
1860
my_progname, result_table, mysql_error(mysql));
1790
1862
my_fclose(sql_file, MYF(MY_WME));
1858
1930
snprintf(buff, sizeof(buff), "show table status like %s",
1859
1931
quote_for_like(table, show_name_buff));
1861
if (drizzle_query_with_error_report(drizzle, &result, buff))
1933
if (mysql_query_with_error_report(mysql, &result, buff))
1863
if (drizzle_errno(drizzle) != ER_PARSE_ERROR)
1864
{ /* If old DRIZZLE version */
1935
if (mysql_errno(mysql) != ER_PARSE_ERROR)
1936
{ /* If old MySQL version */
1865
1937
verbose_msg("-- Warning: Couldn't get status information for " \
1866
"table %s (%s)\n", result_table,drizzle_error(drizzle));
1938
"table %s (%s)\n", result_table,mysql_error(mysql));
1869
else if (!(row= drizzle_fetch_row(result)))
1941
else if (!(row= mysql_fetch_row(result)))
1871
1943
fprintf(stderr,
1872
1944
"Error: Couldn't read status information for table %s (%s)\n",
1873
result_table,drizzle_error(drizzle));
1945
result_table,mysql_error(mysql));
1995
2067
char ignore_flag;
1996
2068
char buf[200], table_buff[NAME_LEN+3];
1997
string query_string;
2069
DYNAMIC_STRING query_string;
1998
2070
char table_type[NAME_LEN];
1999
2071
char *result_table, table_buff2[NAME_LEN*2+3], *opt_quoted_table;
2001
uint32_t rownr, row_break, total_length, init_length;
2073
ulong rownr, row_break, total_length, init_length;
2002
2074
uint num_fields;
2004
DRIZZLE_FIELD *field;
2048
2120
discarding SHOW CREATE EVENT statements generation. The myslq.event
2049
2121
table data should be skipped too.
2051
if (!opt_events && !my_strcasecmp(&my_charset_utf8_general_ci, db, "mysql") &&
2052
!my_strcasecmp(&my_charset_utf8_general_ci, table, "event"))
2123
if (!opt_events && !my_strcasecmp(&my_charset_latin1, db, "mysql") &&
2124
!my_strcasecmp(&my_charset_latin1, table, "event"))
2054
2126
verbose_msg("-- Skipping data table mysql.event, --skip-events was used\n");
2071
2142
Convert the path to native os format
2072
2143
and resolve to the full filepath.
2074
convert_dirname(tmp_path,path,NULL);
2145
convert_dirname(tmp_path,path,NullS);
2075
2146
my_load_path(tmp_path, tmp_path, NULL);
2076
2147
fn_format(filename, table, tmp_path, ".txt", MYF(MY_UNPACK_FILENAME));
2084
2155
/* now build the query string */
2086
query_string.append( "SELECT * INTO OUTFILE '");
2087
query_string.append( filename);
2088
query_string.append( "'");
2157
dynstr_append_checked(&query_string, "SELECT * INTO OUTFILE '");
2158
dynstr_append_checked(&query_string, filename);
2159
dynstr_append_checked(&query_string, "'");
2090
2161
if (fields_terminated || enclosed || opt_enclosed || escaped)
2091
query_string.append( " FIELDS");
2162
dynstr_append_checked(&query_string, " FIELDS");
2093
add_load_option(query_string, " TERMINATED BY ", fields_terminated);
2094
add_load_option(query_string, " ENCLOSED BY ", enclosed);
2095
add_load_option(query_string, " OPTIONALLY ENCLOSED BY ", opt_enclosed);
2096
add_load_option(query_string, " ESCAPED BY ", escaped);
2097
add_load_option(query_string, " LINES TERMINATED BY ", lines_terminated);
2164
add_load_option(&query_string, " TERMINATED BY ", fields_terminated);
2165
add_load_option(&query_string, " ENCLOSED BY ", enclosed);
2166
add_load_option(&query_string, " OPTIONALLY ENCLOSED BY ", opt_enclosed);
2167
add_load_option(&query_string, " ESCAPED BY ", escaped);
2168
add_load_option(&query_string, " LINES TERMINATED BY ", lines_terminated);
2099
query_string.append( " FROM ");
2100
query_string.append( result_table);
2170
dynstr_append_checked(&query_string, " FROM ");
2171
dynstr_append_checked(&query_string, result_table);
2104
query_string.append( " WHERE ");
2105
query_string.append( where);
2175
dynstr_append_checked(&query_string, " WHERE ");
2176
dynstr_append_checked(&query_string, where);
2110
query_string.append( " ORDER BY ");
2111
query_string.append( order_by);
2181
dynstr_append_checked(&query_string, " ORDER BY ");
2182
dynstr_append_checked(&query_string, order_by);
2114
if (drizzle_real_query(drizzle, query_string.c_str(), query_string.length()))
2185
if (mysql_real_query(mysql, query_string.str, query_string.length))
2116
DB_error(drizzle, "when executing 'SELECT INTO OUTFILE'");
2187
DB_error(mysql, "when executing 'SELECT INTO OUTFILE'");
2188
dynstr_free(&query_string);
2147
2219
fprintf(md_result_file, "-- ORDER BY: %s\n", order_by);
2148
2220
check_io(md_result_file);
2150
query_string.append( " ORDER BY ");
2151
query_string.append( order_by);
2222
dynstr_append_checked(&query_string, " ORDER BY ");
2223
dynstr_append_checked(&query_string, order_by);
2154
2226
if (!opt_xml && !opt_compact)
2156
2228
fputs("\n", md_result_file);
2157
2229
check_io(md_result_file);
2159
if (drizzle_query_with_error_report(drizzle, 0, query_string.c_str()))
2231
if (mysql_query_with_error_report(mysql, 0, query_string.str))
2161
DB_error(drizzle, "when retrieving data from server");
2233
DB_error(mysql, "when retrieving data from server");
2165
res=drizzle_use_result(drizzle);
2237
res=mysql_use_result(mysql);
2167
res=drizzle_store_result(drizzle);
2239
res=mysql_store_result(mysql);
2170
DB_error(drizzle, "when retrieving data from server");
2242
DB_error(mysql, "when retrieving data from server");
2174
2246
verbose_msg("-- Retrieving rows...\n");
2175
if (drizzle_num_fields(res) != num_fields)
2247
if (mysql_num_fields(res) != num_fields)
2177
2249
fprintf(stderr,"%s: Error in field count for table: %s ! Aborting.\n",
2178
2250
my_progname, result_table);
2196
2268
total_length= opt_net_buffer_length; /* Force row break */
2199
init_length=(uint) insert_pat.length()+4;
2271
init_length=(uint) insert_pat.length+4;
2201
2273
print_xml_tag(md_result_file, "\t", "\n", "table_data", "name=", table,
2203
2275
if (opt_autocommit)
2205
2277
fprintf(md_result_file, "set autocommit=0;\n");
2206
2278
check_io(md_result_file);
2209
while ((row= drizzle_fetch_row(res)))
2281
while ((row= mysql_fetch_row(res)))
2212
uint32_t *lengths= drizzle_fetch_lengths(res);
2284
ulong *lengths= mysql_fetch_lengths(res);
2214
2286
if (!extended_insert && !opt_xml)
2216
fputs(insert_pat.c_str(),md_result_file);
2288
fputs(insert_pat.str,md_result_file);
2217
2289
check_io(md_result_file);
2219
drizzle_field_seek(res,0);
2291
mysql_field_seek(res,0);
2240
2312
we'll dump in hex only BLOB columns.
2242
2314
is_blob= (opt_hex_blob && field->charsetnr == 63 &&
2243
(field->type == DRIZZLE_TYPE_VARCHAR ||
2244
field->type == DRIZZLE_TYPE_BLOB)) ? 1 : 0;
2315
(field->type == MYSQL_TYPE_STRING ||
2316
field->type == MYSQL_TYPE_VARCHAR ||
2317
field->type == MYSQL_TYPE_BLOB)) ? 1 : 0;
2245
2318
if (extended_insert && !opt_xml)
2321
dynstr_set_checked(&extended_row,"(");
2250
extended_row.append(",");
2323
dynstr_append_checked(&extended_row,",");
2256
if (!(field->type & NUM_FLAG))
2329
if (!IS_NUM_FIELD(field))
2259
2332
"length * 2 + 2" is OK for both HEX and non-HEX modes:
2263
2336
plus 2 bytes for leading and trailing '\'' characters.
2264
2337
Also we need to reserve 1 byte for terminating '\0'.
2266
char * tmp_str= (char *)malloc(length * 2 + 2 + 1);
2267
memset(tmp_str, '\0', length * 2 + 2 + 1);
2339
dynstr_realloc_checked(&extended_row,length * 2 + 2 + 1);
2268
2340
if (opt_hex_blob && is_blob)
2270
extended_row.append("0x");
2271
drizzle_hex_string(tmp_str, row[i], length);
2272
extended_row.append(tmp_str);
2342
dynstr_append_checked(&extended_row, "0x");
2343
extended_row.length+= mysql_hex_string(extended_row.str +
2344
extended_row.length,
2346
assert(extended_row.length+1 <= extended_row.max_length);
2347
/* mysql_hex_string() already terminated string by '\0' */
2348
assert(extended_row.str[extended_row.length] == '\0');
2276
extended_row.append("'");
2277
drizzle_escape_string(tmp_str,
2279
extended_row.append(tmp_str);
2280
extended_row.append("'");
2352
dynstr_append_checked(&extended_row,"'");
2353
extended_row.length +=
2354
mysql_real_escape_string(&mysql_connection,
2355
&extended_row.str[extended_row.length],
2357
extended_row.str[extended_row.length]='\0';
2358
dynstr_append_checked(&extended_row,"'");
2287
2364
char *ptr= row[i];
2288
2365
if (my_isalpha(charset_info, *ptr) || (*ptr == '-' &&
2289
2366
my_isalpha(charset_info, ptr[1])))
2290
extended_row.append( "NULL");
2367
dynstr_append_checked(&extended_row, "NULL");
2293
extended_row.append( ptr);
2370
dynstr_append_checked(&extended_row, ptr);
2298
extended_row.append("''");
2375
dynstr_append_checked(&extended_row,"''");
2301
extended_row.append("NULL");
2378
dynstr_append_checked(&extended_row,"NULL");
2318
2395
/* Define xsi:type="xs:hexBinary" for hex encoded data */
2319
2396
print_xml_tag(md_result_file, "\t\t", "", "field", "name=",
2320
field->name, "xsi:type=", "xs:hexBinary", NULL);
2397
field->name, "xsi:type=", "xs:hexBinary", NullS);
2321
2398
print_blob_as_hex(md_result_file, row[i], length);
2325
2402
print_xml_tag(md_result_file, "\t\t", "", "field", "name=",
2403
field->name, NullS);
2327
2404
print_quoted_xml(md_result_file, row[i], length);
2329
2406
fputs("</field>\n", md_result_file);
2377
2454
if (extended_insert)
2379
uint32_t row_length;
2380
extended_row.append(")");
2381
row_length= 2 + extended_row.length();
2457
dynstr_append_checked(&extended_row,")");
2458
row_length= 2 + extended_row.length;
2382
2459
if (total_length + row_length < opt_net_buffer_length)
2384
2461
total_length+= row_length;
2385
2462
fputc(',',md_result_file); /* Always row break */
2386
fputs(extended_row.c_str(),md_result_file);
2463
fputs(extended_row.str,md_result_file);
2391
2468
fputs(";\n", md_result_file);
2392
2469
row_break=1; /* This is first row */
2394
fputs(insert_pat.c_str(),md_result_file);
2395
fputs(extended_row.c_str(),md_result_file);
2471
fputs(insert_pat.str,md_result_file);
2472
fputs(extended_row.str,md_result_file);
2396
2473
total_length= row_length+init_length;
2398
2475
check_io(md_result_file);
2455
2534
static char *getTableName(int reset)
2457
static DRIZZLE_RES *res= NULL;
2536
static MYSQL_RES *res= NULL;
2462
if (!(res= drizzle_list_tables(drizzle,NULL)))
2541
if (!(res= mysql_list_tables(mysql,NullS)))
2465
if ((row= drizzle_fetch_row(res)))
2544
if ((row= mysql_fetch_row(res)))
2466
2545
return((char*) row[0]);
2469
drizzle_data_seek(res,0); /* We want to read again */
2548
mysql_data_seek(res,0); /* We want to read again */
2472
drizzle_free_result(res);
2551
mysql_free_result(res);
2567
2646
static int init_dumping(char *database, int init_func(char*))
2569
if (drizzle_get_server_version(drizzle) >= 50003 &&
2570
!my_strcasecmp(&my_charset_utf8_general_ci, database, "information_schema"))
2648
if (mysql_get_server_version(mysql) >= 50003 &&
2649
!my_strcasecmp(&my_charset_latin1, database, "information_schema"))
2573
if (drizzle_select_db(drizzle, database))
2652
if (mysql_select_db(mysql, database))
2575
DB_error(drizzle, "when selecting the database");
2654
DB_error(mysql, "when selecting the database");
2576
2655
return 1; /* If --force */
2578
2657
if (!path && !opt_xml)
2618
2697
char table_buff[NAME_LEN*2+3];
2619
2698
char hash_key[2*NAME_LEN+2]; /* "db.tablename" */
2620
2699
char *afterdot;
2621
int using_mysql_db= my_strcasecmp(&my_charset_utf8_general_ci, database, "mysql");
2624
afterdot= my_stpcpy(hash_key, database);
2700
int using_mysql_db= my_strcasecmp(&my_charset_latin1, database, "mysql");
2703
afterdot= strmov(hash_key, database);
2625
2704
*afterdot++= '.';
2627
2706
if (init_dumping(database, init_dumping_tables))
2630
print_xml_tag(md_result_file, "", "\n", "database", "name=", database, NULL);
2709
print_xml_tag(md_result_file, "", "\n", "database", "name=", database, NullS);
2631
2710
if (lock_tables)
2634
query= "LOCK TABLES ";
2712
DYNAMIC_STRING query;
2713
init_dynamic_string_checked(&query, "LOCK TABLES ", 256, 1024);
2635
2714
for (numrows= 0 ; (table= getTableName(1)) ; )
2637
char *end= my_stpcpy(afterdot, table);
2638
if (include_table((unsigned char*) hash_key,end - hash_key))
2716
char *end= strmov(afterdot, table);
2717
if (include_table((uchar*) hash_key,end - hash_key))
2641
query.append( quote_name(table, table_buff, 1));
2642
query.append( " READ /*!32311 LOCAL */,");
2720
dynstr_append_checked(&query, quote_name(table, table_buff, 1));
2721
dynstr_append_checked(&query, " READ /*!32311 LOCAL */,");
2645
if (numrows && drizzle_real_query(drizzle, query.c_str(), query.length()-1))
2646
DB_error(drizzle, "when using LOCK TABLES");
2724
if (numrows && mysql_real_query(mysql, query.str, query.length-1))
2725
DB_error(mysql, "when using LOCK TABLES");
2647
2726
/* We shall continue here, if --force was given */
2727
dynstr_free(&query);
2650
2729
if (flush_logs)
2652
if (drizzle_refresh(drizzle, REFRESH_LOG))
2653
DB_error(drizzle, "when doing refresh");
2731
if (mysql_refresh(mysql, REFRESH_LOG))
2732
DB_error(mysql, "when doing refresh");
2654
2733
/* We shall continue here, if --force was given */
2656
2735
while ((table= getTableName(0)))
2658
char *end= my_stpcpy(afterdot, table);
2659
if (include_table((unsigned char*) hash_key, end - hash_key))
2737
char *end= strmov(afterdot, table);
2738
if (include_table((uchar*) hash_key, end - hash_key))
2661
2740
dump_table(table,database);
2741
my_free(order_by, MYF(MY_ALLOW_ZERO_PTR));
2704
2783
snprintf(query, sizeof(query), "SHOW TABLES LIKE %s",
2705
2784
quote_for_like(old_table_name, show_name_buff));
2707
if (drizzle_query_with_error_report(drizzle, 0, query))
2786
if (mysql_query_with_error_report(mysql, 0, query))
2710
if ((table_res= drizzle_store_result(drizzle)))
2789
if ((table_res= mysql_store_result(mysql)))
2712
uint64_t num_rows= drizzle_num_rows(table_res);
2791
my_uint64_t num_rows= mysql_num_rows(table_res);
2713
2792
if (num_rows > 0)
2717
2796
Return first row
2718
2797
TODO: Return all matching rows
2720
row= drizzle_fetch_row(table_res);
2721
lengths= drizzle_fetch_lengths(table_res);
2799
row= mysql_fetch_row(table_res);
2800
lengths= mysql_fetch_lengths(table_res);
2722
2801
name= strmake_root(root, row[0], lengths[0]);
2724
drizzle_free_result(table_res);
2803
mysql_free_result(table_res);
2742
2821
if (!(dump_tables= pos= (char**) alloc_root(&root, tables * sizeof(char *))))
2743
2822
die(EX_EOM, "alloc_root failure.");
2745
lock_tables_query= "LOCK TABLES ";
2824
init_dynamic_string_checked(&lock_tables_query, "LOCK TABLES ", 256, 1024);
2746
2825
for (; tables > 0 ; tables-- , table_names++)
2748
2827
/* the table name passed on commandline may be wrong case */
2751
2830
/* Add found table name to lock_tables_query */
2752
2831
if (lock_tables)
2754
lock_tables_query.append( quote_name(*pos, table_buff, 1));
2755
lock_tables_query.append( " READ /*!32311 LOCAL */,");
2833
dynstr_append_checked(&lock_tables_query, quote_name(*pos, table_buff, 1));
2834
dynstr_append_checked(&lock_tables_query, " READ /*!32311 LOCAL */,");
2771
2851
if (lock_tables)
2773
if (drizzle_real_query(drizzle, lock_tables_query.c_str(),
2774
lock_tables_query.length()-1))
2853
if (mysql_real_query(mysql, lock_tables_query.str,
2854
lock_tables_query.length-1))
2776
2856
if (!ignore_errors)
2858
dynstr_free(&lock_tables_query);
2778
2859
free_root(&root, MYF(0));
2780
DB_error(drizzle, "when doing LOCK TABLES");
2861
DB_error(mysql, "when doing LOCK TABLES");
2781
2862
/* We shall countinue here, if --force was given */
2865
dynstr_free(&lock_tables_query);
2784
2866
if (flush_logs)
2786
if (drizzle_refresh(drizzle, REFRESH_LOG))
2868
if (mysql_refresh(mysql, REFRESH_LOG))
2788
2870
if (!ignore_errors)
2789
2871
free_root(&root, MYF(0));
2790
DB_error(drizzle, "when doing refresh");
2872
DB_error(mysql, "when doing refresh");
2792
2874
/* We shall countinue here, if --force was given */
2795
print_xml_tag(md_result_file, "", "\n", "database", "name=", db, NULL);
2877
print_xml_tag(md_result_file, "", "\n", "database", "name=", db, NullS);
2797
2879
/* Dump each selected table */
2798
2880
for (pos= dump_tables; pos < end; pos++)
2799
2881
dump_table(*pos, db);
2801
2883
free_root(&root, MYF(0));
2884
my_free(order_by, MYF(MY_ALLOW_ZERO_PTR));
2807
2889
check_io(md_result_file);
2809
2891
if (lock_tables)
2810
drizzle_query_with_error_report(drizzle, 0, "UNLOCK TABLES");
2892
VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
2812
2894
} /* dump_selected_tables */
2815
static int do_show_master_status(DRIZZLE *drizzle_con)
2897
static int do_show_master_status(MYSQL *mysql_con)
2818
DRIZZLE_RES *master;
2819
2901
const char *comment_prefix=
2820
(opt_master_data == DRIZZLE_OPT_MASTER_DATA_COMMENTED_SQL) ? "-- " : "";
2821
if (drizzle_query_with_error_report(drizzle_con, &master, "SHOW MASTER STATUS"))
2902
(opt_master_data == MYSQL_OPT_MASTER_DATA_COMMENTED_SQL) ? "-- " : "";
2903
if (mysql_query_with_error_report(mysql_con, &master, "SHOW MASTER STATUS"))
2827
row= drizzle_fetch_row(master);
2909
row= mysql_fetch_row(master);
2828
2910
if (row && row[0] && row[1])
2830
2912
/* SHOW MASTER STATUS reports file and position */
2842
2924
/* SHOW MASTER STATUS reports nothing and --force is not enabled */
2843
2925
my_printf_error(0, "Error: Binlogging on server not active",
2845
drizzle_free_result(master);
2846
maybe_exit(EX_DRIZZLEERR);
2927
mysql_free_result(master);
2928
maybe_exit(EX_MYSQLERR);
2849
drizzle_free_result(master);
2931
mysql_free_result(master);
2854
static int do_stop_slave_sql(DRIZZLE *drizzle_con)
2936
static int do_stop_slave_sql(MYSQL *mysql_con)
2857
2939
/* We need to check if the slave sql is running in the first place */
2858
if (drizzle_query_with_error_report(drizzle_con, &slave, "SHOW SLAVE STATUS"))
2940
if (mysql_query_with_error_report(mysql_con, &slave, "SHOW SLAVE STATUS"))
2862
DRIZZLE_ROW row= drizzle_fetch_row(slave);
2944
MYSQL_ROW row= mysql_fetch_row(slave);
2863
2945
if (row && row[11])
2865
2947
/* if SLAVE SQL is not running, we don't stop it */
2866
2948
if (!strcmp(row[11],"No"))
2868
drizzle_free_result(slave);
2950
mysql_free_result(slave);
2869
2951
/* Silently assume that they don't have the slave running */
2874
drizzle_free_result(slave);
2956
mysql_free_result(slave);
2876
2958
/* now, stop slave if running */
2877
if (drizzle_query_with_error_report(drizzle_con, 0, "STOP SLAVE SQL_THREAD"))
2959
if (mysql_query_with_error_report(mysql_con, 0, "STOP SLAVE SQL_THREAD"))
2901
static int do_show_slave_status(DRIZZLE *drizzle_con)
2983
static int do_show_slave_status(MYSQL *mysql_con)
2904
2986
const char *comment_prefix=
2905
(opt_slave_data == DRIZZLE_OPT_SLAVE_DATA_COMMENTED_SQL) ? "-- " : "";
2906
if (drizzle_query_with_error_report(drizzle_con, &slave, "SHOW SLAVE STATUS"))
2987
(opt_slave_data == MYSQL_OPT_SLAVE_DATA_COMMENTED_SQL) ? "-- " : "";
2988
if (mysql_query_with_error_report(mysql_con, &slave, "SHOW SLAVE STATUS"))
2908
2990
if (!ignore_errors)
2938
3020
check_io(md_result_file);
2940
drizzle_free_result(slave);
3022
mysql_free_result(slave);
2945
static int do_start_slave_sql(DRIZZLE *drizzle_con)
3027
static int do_start_slave_sql(MYSQL *mysql_con)
2948
3030
/* We need to check if the slave sql is stopped in the first place */
2949
if (drizzle_query_with_error_report(drizzle_con, &slave, "SHOW SLAVE STATUS"))
3031
if (mysql_query_with_error_report(mysql_con, &slave, "SHOW SLAVE STATUS"))
2953
DRIZZLE_ROW row= drizzle_fetch_row(slave);
3035
MYSQL_ROW row= mysql_fetch_row(slave);
2954
3036
if (row && row[11])
2956
3038
/* if SLAVE SQL is not running, we don't start it */
2957
3039
if (!strcmp(row[11],"Yes"))
2959
drizzle_free_result(slave);
3041
mysql_free_result(slave);
2960
3042
/* Silently assume that they don't have the slave running */
2965
drizzle_free_result(slave);
3047
mysql_free_result(slave);
2967
3049
/* now, start slave if stopped */
2968
if (drizzle_query_with_error_report(drizzle_con, 0, "START SLAVE"))
3050
if (mysql_query_with_error_report(mysql_con, 0, "START SLAVE"))
2970
3052
my_printf_error(0, "Error: Unable to start slave", MYF(0));
2986
3068
update starts between the two FLUSHes, we have that bad stall.
2989
( drizzle_query_with_error_report(drizzle_con, 0, "FLUSH TABLES") ||
2990
drizzle_query_with_error_report(drizzle_con, 0,
3071
( mysql_query_with_error_report(mysql_con, 0, "FLUSH TABLES") ||
3072
mysql_query_with_error_report(mysql_con, 0,
2991
3073
"FLUSH TABLES WITH READ LOCK") );
2995
static int do_unlock_tables(DRIZZLE *drizzle_con)
3077
static int do_unlock_tables(MYSQL *mysql_con)
2997
return drizzle_query_with_error_report(drizzle_con, 0, "UNLOCK TABLES");
3079
return mysql_query_with_error_report(mysql_con, 0, "UNLOCK TABLES");
3000
static int get_bin_log_name(DRIZZLE *drizzle_con,
3082
static int get_bin_log_name(MYSQL *mysql_con,
3001
3083
char* buff_log_name, uint buff_len)
3006
if (drizzle_query(drizzle_con, "SHOW MASTER STATUS") ||
3007
!(res= drizzle_store_result(drizzle)))
3088
if (mysql_query(mysql_con, "SHOW MASTER STATUS") ||
3089
!(res= mysql_store_result(mysql)))
3010
if (!(row= drizzle_fetch_row(res)))
3092
if (!(row= mysql_fetch_row(res)))
3012
drizzle_free_result(res);
3094
mysql_free_result(res);
3019
3101
strmake(buff_log_name, row[0], buff_len - 1);
3021
drizzle_free_result(res);
3103
mysql_free_result(res);
3025
static int purge_bin_logs_to(DRIZZLE *drizzle_con, char* log_name)
3107
static int purge_bin_logs_to(MYSQL *mysql_con, char* log_name)
3028
string str= "PURGE BINARY LOGS TO '";
3029
str.append(log_name);
3031
err = drizzle_query_with_error_report(drizzle_con, 0, str.c_str());
3111
init_dynamic_string_checked(&str, "PURGE BINARY LOGS TO '", 1024, 1024);
3112
dynstr_append_checked(&str, log_name);
3113
dynstr_append_checked(&str, "'");
3114
err = mysql_query_with_error_report(mysql_con, 0, str.str);
3036
static int start_transaction(DRIZZLE *drizzle_con)
3120
static int start_transaction(MYSQL *mysql_con)
3039
3123
We use BEGIN for old servers. --single-transaction --master-data will fail
3044
3128
need the REPEATABLE READ level (not anything lower, for example READ
3045
3129
COMMITTED would give one new consistent read per dumped table).
3047
if ((drizzle_get_server_version(drizzle_con) < 40100) && opt_master_data)
3131
if ((mysql_get_server_version(mysql_con) < 40100) && opt_master_data)
3049
3133
fprintf(stderr, "-- %s: the combination of --single-transaction and "
3050
"--master-data requires a DRIZZLE server version of at least 4.1 "
3134
"--master-data requires a MySQL server version of at least 4.1 "
3051
3135
"(current server's version is %s). %s\n",
3052
3136
ignore_errors ? "Warning" : "Error",
3053
drizzle_con->server_version ? drizzle_con->server_version : "unknown",
3137
mysql_con->server_version ? mysql_con->server_version : "unknown",
3054
3138
ignore_errors ? "Continuing due to --force, backup may not be consistent across all tables!" : "Aborting.");
3055
3139
if (!ignore_errors)
3056
exit(EX_DRIZZLEERR);
3059
return (drizzle_query_with_error_report(drizzle_con, 0,
3143
return (mysql_query_with_error_report(mysql_con, 0,
3060
3144
"SET SESSION TRANSACTION ISOLATION "
3061
3145
"LEVEL REPEATABLE READ") ||
3062
drizzle_query_with_error_report(drizzle_con, 0,
3146
mysql_query_with_error_report(mysql_con, 0,
3063
3147
"START TRANSACTION "
3064
3148
"/*!40100 WITH CONSISTENT SNAPSHOT */"));
3068
static uint32_t find_set(TYPELIB *lib, const char *x, uint length,
3152
static ulong find_set(TYPELIB *lib, const char *x, uint length,
3069
3153
char **err_pos, uint *err_len)
3071
3155
const char *end= x + length;
3074
3158
char buff[255];
3086
3170
const char *pos= start;
3089
3173
for (; pos != end && *pos != ','; pos++) ;
3090
var_len= (uint32_t) (pos - start);
3091
strmake(buff, start, min((uint32_t)sizeof(buff), var_len));
3174
var_len= (uint) (pos - start);
3175
strmake(buff, start, min(sizeof(buff), var_len));
3092
3176
find= find_type(buff, lib, var_len);
3109
3193
/* Print a value with a prefix on file */
3110
static void print_value(FILE *file, DRIZZLE_RES *result, DRIZZLE_ROW row,
3194
static void print_value(FILE *file, MYSQL_RES *result, MYSQL_ROW row,
3111
3195
const char *prefix, const char *name,
3112
3196
int string_value)
3114
DRIZZLE_FIELD *field;
3115
drizzle_field_seek(result, 0);
3199
mysql_field_seek(result, 0);
3117
for ( ; (field= drizzle_fetch_field(result)) ; row++)
3201
for ( ; (field= mysql_fetch_field(result)) ; row++)
3119
3203
if (!strcmp(field->name,name))
3141
3225
Check if we the table is one of the table types that should be ignored:
3142
3226
MRG_ISAM, MRG_MYISAM, if opt_delayed, if that table supports delayed inserts.
3143
If the table should be altogether ignored, it returns a true, false if it
3227
If the table should be altogether ignored, it returns a TRUE, FALSE if it
3144
3228
should not be ignored. If the user has selected to use INSERT DELAYED, it
3145
3229
sets the value of the bool pointer supports_delayed_inserts to 0 if not
3146
3230
supported, 1 if it is supported.
3164
3248
char result= IGNORE_NONE;
3165
3249
char buff[FN_REFLEN+80], show_name_buff[FN_REFLEN];
3166
DRIZZLE_RES *res= NULL;
3250
MYSQL_RES *res= NULL;
3170
3254
/* Check memory for quote_for_like() */
3171
3255
assert(2*sizeof(table_name) < sizeof(show_name_buff));
3172
3256
snprintf(buff, sizeof(buff), "show table status like %s",
3173
3257
quote_for_like(table_name, show_name_buff));
3174
if (drizzle_query_with_error_report(drizzle, &res, buff))
3258
if (mysql_query_with_error_report(mysql, &res, buff))
3176
if (drizzle_errno(drizzle) != ER_PARSE_ERROR)
3177
{ /* If old DRIZZLE version */
3260
if (mysql_errno(mysql) != ER_PARSE_ERROR)
3261
{ /* If old MySQL version */
3178
3262
verbose_msg("-- Warning: Couldn't get status information for "
3179
"table %s (%s)\n", table_name, drizzle_error(drizzle));
3263
"table %s (%s)\n", table_name, mysql_error(mysql));
3180
3264
return(result); /* assume table is ok */
3183
if (!(row= drizzle_fetch_row(res)))
3267
if (!(row= mysql_fetch_row(res)))
3185
3269
fprintf(stderr,
3186
3270
"Error: Couldn't read status information for table %s (%s)\n",
3187
table_name, drizzle_error(drizzle));
3188
drizzle_free_result(res);
3271
table_name, mysql_error(mysql));
3272
mysql_free_result(res);
3189
3273
return(result); /* assume table is ok */
3254
3338
snprintf(show_keys_buff, sizeof(show_keys_buff),
3255
3339
"SHOW KEYS FROM %s", table_name);
3256
if (drizzle_query(drizzle, show_keys_buff) ||
3257
!(res= drizzle_store_result(drizzle)))
3340
if (mysql_query(mysql, show_keys_buff) ||
3341
!(res= mysql_store_result(mysql)))
3259
3343
fprintf(stderr, "Warning: Couldn't read keys from table %s;"
3260
3344
" records are NOT sorted (%s)\n",
3261
table_name, drizzle_error(drizzle));
3345
table_name, mysql_error(mysql));
3262
3346
/* Don't exit, because it's better to print out unsorted records */
3269
3353
* row, and UNIQUE keys come before others. So we only need to check
3270
3354
* the first key, not all keys.
3272
if ((row= drizzle_fetch_row(res)) && atoi(row[1]) == 0)
3356
if ((row= mysql_fetch_row(res)) && atoi(row[1]) == 0)
3274
3358
/* Key is unique */
3277
3361
quoted_field= quote_name(row[4], buff, 0);
3278
3362
result_length+= strlen(quoted_field) + 1; /* + 1 for ',' or \0 */
3279
} while ((row= drizzle_fetch_row(res)) && atoi(row[3]) > 1);
3363
} while ((row= mysql_fetch_row(res)) && atoi(row[3]) > 1);
3282
3366
/* Build the ORDER BY clause result */
3286
3370
/* result (terminating \0 is already in result_length) */
3287
result= (char *)my_malloc(result_length + 10, MYF(MY_WME));
3371
result= my_malloc(result_length + 10, MYF(MY_WME));
3290
3374
fprintf(stderr, "Error: Not enough memory to store ORDER BY clause\n");
3293
drizzle_data_seek(res, 0);
3294
row= drizzle_fetch_row(res);
3377
mysql_data_seek(res, 0);
3378
row= mysql_fetch_row(res);
3295
3379
quoted_field= quote_name(row[4], buff, 0);
3296
end= my_stpcpy(result, quoted_field);
3297
while ((row= drizzle_fetch_row(res)) && atoi(row[3]) > 1)
3380
end= strmov(result, quoted_field);
3381
while ((row= mysql_fetch_row(res)) && atoi(row[3]) > 1)
3299
3383
quoted_field= quote_name(row[4], buff, 0);
3300
end= strxmov(end, ",", quoted_field, NULL);
3384
end= strxmov(end, ",", quoted_field, NullS);
3306
drizzle_free_result(res);
3390
mysql_free_result(res);
3396
The following functions are wrappers for the dynamic string functions
3397
and if they fail, the wrappers will terminate the current process.
3400
#define DYNAMIC_STR_ERROR_MSG "Couldn't perform DYNAMIC_STRING operation"
3402
static void init_dynamic_string_checked(DYNAMIC_STRING *str, const char *init_str,
3403
uint init_alloc, uint alloc_increment)
3405
if (init_dynamic_string(str, init_str, init_alloc, alloc_increment))
3406
die(EX_MYSQLERR, DYNAMIC_STR_ERROR_MSG);
3409
static void dynstr_append_checked(DYNAMIC_STRING* dest, const char* src)
3411
if (dynstr_append(dest, src))
3412
die(EX_MYSQLERR, DYNAMIC_STR_ERROR_MSG);
3415
static void dynstr_set_checked(DYNAMIC_STRING *str, const char *init_str)
3417
if (dynstr_set(str, init_str))
3418
die(EX_MYSQLERR, DYNAMIC_STR_ERROR_MSG);
3421
static void dynstr_append_mem_checked(DYNAMIC_STRING *str, const char *append,
3424
if (dynstr_append_mem(str, append, length))
3425
die(EX_MYSQLERR, DYNAMIC_STR_ERROR_MSG);
3428
static void dynstr_realloc_checked(DYNAMIC_STRING *str, ulong additional_size)
3430
if (dynstr_realloc(str, additional_size))
3431
die(EX_MYSQLERR, DYNAMIC_STR_ERROR_MSG);
3312
3435
int main(int argc, char **argv)
3331
3454
if(!(stderror_file= freopen(log_error_file, "a+", stderr)))
3333
3456
free_resources();
3334
exit(EX_DRIZZLEERR);
3338
3461
if (connect_to_db(current_host, current_user, opt_password))
3340
3463
free_resources();
3341
exit(EX_DRIZZLEERR);
3344
3467
write_header(md_result_file, *argv);
3346
if (opt_slave_data && do_stop_slave_sql(drizzle))
3469
if (opt_slave_data && do_stop_slave_sql(mysql))
3349
3472
if ((opt_lock_all_tables || opt_master_data) &&
3350
do_flush_tables_read_lock(drizzle))
3473
do_flush_tables_read_lock(mysql))
3352
if (opt_single_transaction && start_transaction(drizzle))
3475
if (opt_single_transaction && start_transaction(mysql))
3354
3477
if (opt_delete_master_logs)
3356
if (drizzle_refresh(drizzle, REFRESH_LOG) ||
3357
get_bin_log_name(drizzle, bin_log_name, sizeof(bin_log_name)))
3479
if (mysql_refresh(mysql, REFRESH_LOG) ||
3480
get_bin_log_name(mysql, bin_log_name, sizeof(bin_log_name)))
3361
3484
if (opt_lock_all_tables || opt_master_data)
3363
if (flush_logs && drizzle_refresh(drizzle, REFRESH_LOG))
3486
if (flush_logs && mysql_refresh(mysql, REFRESH_LOG))
3365
3488
flush_logs= 0; /* not anymore; that would not be sensible */
3367
3490
/* Add 'STOP SLAVE to beginning of dump */
3368
3491
if (opt_slave_apply && add_stop_slave())
3370
if (opt_master_data && do_show_master_status(drizzle))
3372
if (opt_slave_data && do_show_slave_status(drizzle))
3374
if (opt_single_transaction && do_unlock_tables(drizzle)) /* unlock but no commit! */
3493
if (opt_master_data && do_show_master_status(mysql))
3495
if (opt_slave_data && do_show_slave_status(mysql))
3497
if (opt_single_transaction && do_unlock_tables(mysql)) /* unlock but no commit! */
3377
3500
if (opt_alldbs)
3400
3523
if (md_result_file && fflush(md_result_file))
3402
3525
if (!first_error)
3403
first_error= EX_DRIZZLEERR;
3526
first_error= EX_MYSQLERR;
3406
3529
/* everything successful, purge the old logs files */
3407
if (opt_delete_master_logs && purge_bin_logs_to(drizzle, bin_log_name))
3530
if (opt_delete_master_logs && purge_bin_logs_to(mysql, bin_log_name))
3534
my_free(shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
3411
3537
No reason to explicitely COMMIT the transaction, neither to explicitely
3412
3538
UNLOCK TABLES: these will be automatically be done by the server when we
added
removed
client/mysqldump.c
