mysqldump.c 74.1 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* mysqldump.c  - Dump a tables contents and format to an ASCII file
**
** The author's original notes follow :-
**
unknown's avatar
unknown committed
21 22 23 24 25 26 27 28 29 30 31 32
** AUTHOR: Igor Romanenko (igor@frog.kiev.ua)
** DATE:   December 3, 1994
** WARRANTY: None, expressed, impressed, implied
**	    or other
** STATUS: Public domain
** Adapted and optimized for MySQL by
** Michael Widenius, Sinisa Milivojevic, Jani Tolonen
** -w --where added 9/10/98 by Jim Faucette
** slave code by David Saez Padros <david@ols.es>
** master/autocommit code by Brian Aker <brian@tangent.org>
** SSL by
** Andrei Errapart <andreie@no.spam.ee>
33
** Tõnu Samuel  <tonu@please.do.not.remove.this.spam.ee>
unknown's avatar
unknown committed
34 35
** XML by Gary Huntress <ghuntress@mediaone.net> 10/10/01, cleaned up
** and adapted to mysqldump 05/11/01 by Jani Tolonen
36
** Added --single-transaction option 06/06/2002 by Peter Zaitsev
unknown's avatar
unknown committed
37
** 10 Jun 2003: SET NAMES and --no-set-names by Alexander Barkov
unknown's avatar
unknown committed
38
*/
unknown's avatar
unknown committed
39

40
#define DUMP_VERSION "10.9"
unknown's avatar
unknown committed
41

unknown's avatar
unknown committed
42
#include <my_global.h>
unknown's avatar
unknown committed
43 44 45
#include <my_sys.h>
#include <m_string.h>
#include <m_ctype.h>
46
#include <hash.h>
unknown's avatar
unknown committed
47

48
#include "client_priv.h"
unknown's avatar
unknown committed
49 50 51 52 53 54 55 56 57 58
#include "mysql.h"
#include "mysql_version.h"
#include "mysqld_error.h"

/* Exit codes */

#define EX_USAGE 1
#define EX_MYSQLERR 2
#define EX_CONSCHECK 3
#define EX_EOM 4
59
#define EX_EOF 5 /* ferror for output file was got */
unknown's avatar
unknown committed
60 61 62 63 64 65 66 67 68

/* index into 'show fields from table' */

#define SHOW_FIELDNAME  0
#define SHOW_TYPE  1
#define SHOW_NULL  2
#define SHOW_DEFAULT  4
#define SHOW_EXTRA  5

69 70 71
/* Size of buffer for dump's select query */
#define QUERY_LENGTH 1536

unknown's avatar
unknown committed
72 73
static char *add_load_option(char *ptr, const char *object,
			     const char *statement);
74 75
static ulong find_set(TYPELIB *lib, const char *x, uint length,
		      char **err_pos, uint *err_len);
unknown's avatar
unknown committed
76 77

static char *field_escape(char *to,const char *from,uint length);
78
static my_bool  verbose=0,tFlag=0,cFlag=0,dFlag=0,quick= 1, extended_insert= 1,
79 80
		lock_tables=1,ignore_errors=0,flush_logs=0,
		opt_drop=1,opt_keywords=0,opt_lock=1,opt_compress=0,
81
                opt_delayed=0,create_options=1,opt_quoted=0,opt_databases=0,
82 83
                opt_alldbs=0,opt_create_db=0,opt_lock_all_tables=0,opt_set_charset,
		opt_autocommit=0,opt_disable_keys=1,opt_xml=0,
unknown's avatar
unknown committed
84
		opt_delete_master_logs=0, tty_password=0,
85
		opt_single_transaction=0, opt_comments= 0, opt_compact= 0,
86
		opt_hex_blob=0, opt_order_by_primary=0;
87
static ulong opt_max_allowed_packet, opt_net_buffer_length;
unknown's avatar
unknown committed
88
static MYSQL mysql_connection,*sock=0;
89
static char  insert_pat[12 * 1024],*opt_password=0,*current_user=0,
unknown's avatar
unknown committed
90 91
             *current_host=0,*path=0,*fields_terminated=0,
             *lines_terminated=0, *enclosed=0, *opt_enclosed=0, *escaped=0,
92
             *where=0, *order_by=0,
93
             *opt_compatible_mode_str= 0,
94
             *err_ptr= 0;
95
static char compatible_mode_normal_str[255];
96
static ulong opt_compatible_mode= 0;
97 98 99
#define MYSQL_OPT_MASTER_DATA_EFFECTIVE_SQL 1
#define MYSQL_OPT_MASTER_DATA_COMMENTED_SQL 2
static uint     opt_mysql_port= 0, err_len= 0, opt_master_data;
unknown's avatar
unknown committed
100 101 102
static my_string opt_mysql_unix_port=0;
static int   first_error=0;
static DYNAMIC_STRING extended_row;
103
#include <sslopt-vars.h>
unknown's avatar
unknown committed
104
FILE  *md_result_file;
105 106 107
#ifdef HAVE_SMEM
static char *shared_memory_base_name=0;
#endif
108
static uint opt_protocol= 0;
109
/*
unknown's avatar
unknown committed
110 111 112
  Constant for detection of default value of default_charset.
  If default_charset is equal to mysql_universal_client_charset, then
  it is the default value which assigned at the very beginning of main().
113
*/
unknown's avatar
unknown committed
114
static const char *mysql_universal_client_charset=
115 116
  MYSQL_UNIVERSAL_CLIENT_CHARSET;
static char *default_charset;
117
static CHARSET_INFO *charset_info= &my_charset_latin1;
unknown's avatar
unknown committed
118
const char *default_dbug_option="d:t:o,/tmp/mysqldump.trace";
119 120 121 122

const char *compatible_mode_names[]=
{
  "MYSQL323", "MYSQL40", "POSTGRESQL", "ORACLE", "MSSQL", "DB2",
123 124
  "MAXDB", "NO_KEY_OPTIONS", "NO_TABLE_OPTIONS", "NO_FIELD_OPTIONS",
  "ANSI",
125 126
  NullS
};
127 128 129 130 131 132 133 134 135
#define MASK_ANSI_QUOTES \
(\
 (1<<2)  | /* POSTGRESQL */\
 (1<<3)  | /* ORACLE     */\
 (1<<4)  | /* MSSQL      */\
 (1<<5)  | /* DB2        */\
 (1<<6)  | /* MAXDB      */\
 (1<<10)   /* ANSI       */\
)
136
TYPELIB compatible_mode_typelib= {array_elements(compatible_mode_names) - 1,
unknown's avatar
unknown committed
137
				  "", compatible_mode_names, NULL};
138

139 140 141 142 143 144 145 146 147
#define TABLE_RULE_HASH_SIZE   16

typedef struct st_table_rule_ent
{
  char* key;    /* dbname.tablename */
  uint key_len;
} TABLE_RULE_ENT;

HASH ignore_table;
unknown's avatar
unknown committed
148

149
static struct my_option my_long_options[] =
unknown's avatar
unknown committed
150
{
151 152 153
  {"all", 'a', "Deprecated. Use --create-options instead.",
   (gptr*) &create_options, (gptr*) &create_options, 0, GET_BOOL, NO_ARG, 1,
   0, 0, 0, 0, 0},
154 155 156 157 158
  {"all-databases", 'A',
   "Dump all the databases. This will be same as --databases with all databases selected.",
   (gptr*) &opt_alldbs, (gptr*) &opt_alldbs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
  {"add-drop-table", OPT_DROP, "Add a 'drop table' before each create.",
159
   (gptr*) &opt_drop, (gptr*) &opt_drop, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0,
160 161
   0},
  {"add-locks", OPT_LOCKS, "Add locks around insert statements.",
162
   (gptr*) &opt_lock, (gptr*) &opt_lock, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0,
163 164 165 166 167
   0},
  {"allow-keywords", OPT_KEYWORDS,
   "Allow creation of column names that are keywords.", (gptr*) &opt_keywords,
   (gptr*) &opt_keywords, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"character-sets-dir", OPT_CHARSETS_DIR,
168
   "Directory where character sets are.", (gptr*) &charsets_dir,
169
   (gptr*) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
170 171 172
  {"comments", 'i', "Write additional information.",
   (gptr*) &opt_comments, (gptr*) &opt_comments, 0, GET_BOOL, NO_ARG,
   1, 0, 0, 0, 0, 0},
173
  {"compatible", OPT_COMPATIBLE,
unknown's avatar
unknown committed
174
   "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.",
175 176
   (gptr*) &opt_compatible_mode_str, (gptr*) &opt_compatible_mode_str, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
177
  {"compact", OPT_COMPACT,
unknown's avatar
unknown committed
178
   "Give less verbose output (useful for debugging). Disables structure comments and header/footer constructs.  Enables options --skip-add-drop-table --no-set-names --skip-disable-keys --skip-add-locks",
unknown's avatar
unknown committed
179 180
   (gptr*) &opt_compact, (gptr*) &opt_compact, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
181 182
  {"complete-insert", 'c', "Use complete insert statements.", (gptr*) &cFlag,
   (gptr*) &cFlag, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
183 184 185
  {"compress", 'C', "Use compression in server/client protocol.",
   (gptr*) &opt_compress, (gptr*) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
   0, 0, 0},
unknown's avatar
unknown committed
186 187 188 189
  {"create-options", OPT_CREATE_OPTIONS,
   "Include all MySQL specific create options.",
   (gptr*) &create_options, (gptr*) &create_options, 0, GET_BOOL, NO_ARG, 1,
   0, 0, 0, 0, 0},
190 191 192 193
  {"databases", 'B',
   "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.",
   (gptr*) &opt_databases, (gptr*) &opt_databases, 0, GET_BOOL, NO_ARG, 0, 0,
   0, 0, 0, 0},
unknown's avatar
unknown committed
194 195 196 197 198 199 200
#ifdef DBUG_OFF
  {"debug", '#', "This is a non-debug version. Catch this and exit",
   0,0, 0, GET_DISABLED, OPT_ARG, 0, 0, 0, 0, 0, 0},
#else
  {"debug", '#', "Output debug log", (gptr*) &default_dbug_option,
   (gptr*) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
201 202 203 204 205 206
  {"default-character-set", OPT_DEFAULT_CHARSET,
   "Set the default character set.", (gptr*) &default_charset,
   (gptr*) &default_charset, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"delayed-insert", OPT_DELAYED, "Insert rows with INSERT DELAYED.",
   (gptr*) &opt_delayed, (gptr*) &opt_delayed, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
unknown's avatar
unknown committed
207
  {"delete-master-logs", OPT_DELETE_MASTER_LOGS,
208 209 210
   "Delete logs on master after backup. This automatically enables --master-data.",
   (gptr*) &opt_delete_master_logs, (gptr*) &opt_delete_master_logs, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
211 212
  {"disable-keys", 'K',
   "'/*!40000 ALTER TABLE tb_name DISABLE KEYS */; and '/*!40000 ALTER TABLE tb_name ENABLE KEYS */; will be put in the output.", (gptr*) &opt_disable_keys,
213
   (gptr*) &opt_disable_keys, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
214 215 216
  {"extended-insert", 'e',
   "Allows utilization of the new, much faster INSERT syntax.",
   (gptr*) &extended_insert, (gptr*) &extended_insert, 0, GET_BOOL, NO_ARG,
217
   1, 0, 0, 0, 0, 0},
218 219 220 221 222 223 224 225 226 227
  {"fields-terminated-by", OPT_FTB,
   "Fields in the textfile are terminated by ...", (gptr*) &fields_terminated,
   (gptr*) &fields_terminated, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"fields-enclosed-by", OPT_ENC,
   "Fields in the importfile are enclosed by ...", (gptr*) &enclosed,
   (gptr*) &enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0 ,0, 0},
  {"fields-optionally-enclosed-by", OPT_O_ENC,
   "Fields in the i.file are opt. enclosed by ...", (gptr*) &opt_enclosed,
   (gptr*) &opt_enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0 ,0, 0},
  {"fields-escaped-by", OPT_ESC, "Fields in the i.file are escaped by ...",
unknown's avatar
unknown committed
228
   (gptr*) &escaped, (gptr*) &escaped, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
229 230
  {"first-slave", 'x', "Deprecated, renamed to --lock-all-tables.",
   (gptr*) &opt_lock_all_tables, (gptr*) &opt_lock_all_tables, 0, GET_BOOL, NO_ARG,
231
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
232
  {"flush-logs", 'F', "Flush logs file in server before starting dump. "
233 234 235 236 237 238 239 240
   "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 "
   "or --master-data: "
   "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 --master-data with --flush-logs",
241 242 243 244 245 246 247
   (gptr*) &flush_logs, (gptr*) &flush_logs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
  {"force", 'f', "Continue even if we get an sql-error.",
   (gptr*) &ignore_errors, (gptr*) &ignore_errors, 0, GET_BOOL, NO_ARG,
   0, 0, 0, 0, 0, 0},
  {"help", '?', "Display this help message and exit.", 0, 0, 0, GET_NO_ARG,
   NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
248 249 250
  {"hex-blob", OPT_HEXBLOB, "Dump binary strings (BINARY, "
    "VARBINARY, BLOB) in hexadecimal format.",
   (gptr*) &opt_hex_blob, (gptr*) &opt_hex_blob, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
251
  {"host", 'h', "Connect to host.", (gptr*) &current_host,
252
   (gptr*) &current_host, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
253 254 255 256 257
  {"ignore-table", OPT_IGNORE_TABLE,
   "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",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
258 259 260
  {"lines-terminated-by", OPT_LTB, "Lines in the i.file are terminated by ...",
   (gptr*) &lines_terminated, (gptr*) &lines_terminated, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
261 262 263 264 265
  {"lock-all-tables", 'x', "Locks all tables across all databases. This " 
   "is achieved by taking a global read lock for the duration of the whole "
   "dump. Automatically turns --single-transaction and --lock-tables off.",
   (gptr*) &opt_lock_all_tables, (gptr*) &opt_lock_all_tables, 0, GET_BOOL, NO_ARG,
   0, 0, 0, 0, 0, 0},
266
  {"lock-tables", 'l', "Lock all tables for read.", (gptr*) &lock_tables,
267
   (gptr*) &lock_tables, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
268
  {"master-data", OPT_MASTER_DATA,
269 270 271 272 273 274 275 276 277 278
   "This causes the binary log position and filename to be appended to the "
   "output. If equal to 1, will print it as a CHANGE MASTER command; if equal"
   " to 2, that command will be prefixed with a comment symbol. "
   "This option will turn --lock-all-tables on, unless "
   "--single-transaction is specified too (in which case a "
   "global read lock is only taken a short time at the beginning of the dump "
   "- don't forget to read about --single-transaction below). In all cases "
   "any action on logs will happen at the exact moment of the dump."
   "Option automatically turns --lock-tables off.",
   (gptr*) &opt_master_data, (gptr*) &opt_master_data, 0,
279
   GET_UINT, OPT_ARG, 0, 0, MYSQL_OPT_MASTER_DATA_COMMENTED_SQL, 0, 0, 0},
unknown's avatar
unknown committed
280 281 282 283 284 285 286 287
  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET, "",
    (gptr*) &opt_max_allowed_packet, (gptr*) &opt_max_allowed_packet, 0,
    GET_ULONG, REQUIRED_ARG, 24*1024*1024, 4096, 
   (longlong) 2L*1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},
  {"net_buffer_length", OPT_NET_BUFFER_LENGTH, "",
    (gptr*) &opt_net_buffer_length, (gptr*) &opt_net_buffer_length, 0,
    GET_ULONG, REQUIRED_ARG, 1024*1024L-1025, 4096, 16*1024L*1024L,
   MALLOC_OVERHEAD-1024, 1024, 0},
288 289 290 291 292
  {"no-autocommit", OPT_AUTOCOMMIT,
   "Wrap tables with autocommit/commit statements.",
   (gptr*) &opt_autocommit, (gptr*) &opt_autocommit, 0, GET_BOOL, NO_ARG,
   0, 0, 0, 0, 0, 0},
  {"no-create-db", 'n',
293
   "'CREATE DATABASE /*!32312 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.}.",
294 295 296
   (gptr*) &opt_create_db, (gptr*) &opt_create_db, 0, GET_BOOL, NO_ARG, 0, 0,
   0, 0, 0, 0},
  {"no-create-info", 't', "Don't write table creation info.",
297 298 299
   (gptr*) &tFlag, (gptr*) &tFlag, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"no-data", 'd', "No row information.", (gptr*) &dFlag, (gptr*) &dFlag, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
300
  {"no-set-names", 'N',
301
   "Deprecated. Use --skip-set-charset instead.",
302
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
303
  {"opt", OPT_OPTIMIZE,
304
   "Same as --add-drop-table, --add-locks, --create-options, --quick, --extended-insert, --lock-tables, --set-charset, and --disable-keys. Enabled by default, disable with --skip-opt.",
305 306 307 308
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"password", 'p',
   "Password to use when connecting to server. If password is not given it's solicited on the tty.",
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
309
#ifdef __WIN__
310
  {"pipe", 'W', "Use named pipes to connect to server.", 0, 0, 0, GET_NO_ARG,
311
   NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
312
#endif
313 314 315
  {"port", 'P', "Port number to use for connection.", (gptr*) &opt_mysql_port,
   (gptr*) &opt_mysql_port, 0, GET_UINT, REQUIRED_ARG, MYSQL_PORT, 0, 0, 0, 0,
   0},
316
  {"protocol", OPT_MYSQL_PROTOCOL, "The protocol of connection (tcp,socket,pipe,memory).",
317
   0, 0, 0, GET_STR,  REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
318
  {"quick", 'q', "Don't buffer query, dump directly to stdout.",
319
   (gptr*) &quick, (gptr*) &quick, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
320
  {"quote-names",'Q', "Quote table and column names with backticks (`).",
321
   (gptr*) &opt_quoted, (gptr*) &opt_quoted, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0,
322 323
   0, 0},
  {"result-file", 'r',
unknown's avatar
unknown committed
324
   "Direct output to a given file. This option should be used in MSDOS, because it prevents new line '\\n' from being converted to '\\r\\n' (carriage return + line feed).",
unknown's avatar
unknown committed
325
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
326 327 328 329
  {"set-charset", OPT_SET_CHARSET,
   "Add 'SET NAMES default_character_set' to the output. Enabled by default; suppress with --skip-set-charset.",
   (gptr*) &opt_set_charset, (gptr*) &opt_set_charset, 0, GET_BOOL, NO_ARG, 1,
   0, 0, 0, 0, 0},
330 331 332
  {"set-variable", 'O',
   "Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
333
#ifdef HAVE_SMEM
334
  {"shared-memory-base-name", OPT_SHARED_MEMORY_BASE_NAME,
335
   "Base name of shared memory.", (gptr*) &shared_memory_base_name, (gptr*) &shared_memory_base_name,
336 337
   0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#endif
unknown's avatar
unknown committed
338 339 340 341 342
  /*
    Note that the combination --single-transaction --master-data
    will give bullet-proof binlog position only if server >=4.1.3. That's the
    old "FLUSH TABLES WITH READ LOCK does not block commit" fixed bug.
  */
343
  {"single-transaction", OPT_TRANSACTION,
unknown's avatar
unknown committed
344 345 346 347 348 349 350
   "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. Option "
   "automatically turns off --lock-tables.",
   (gptr*) &opt_single_transaction, (gptr*) &opt_single_transaction, 0,
   GET_BOOL, NO_ARG,  0, 0, 0, 0, 0, 0},
351
  {"skip-opt", OPT_SKIP_OPTIMIZATION,
352
   "Disable --opt. Disables --add-drop-table, --add-locks, --create-options, --quick, --extended-insert, --lock-tables, --set-charset, and --disable-keys.",
353
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
354 355 356
  {"socket", 'S', "Socket file to use for connection.",
   (gptr*) &opt_mysql_unix_port, (gptr*) &opt_mysql_unix_port, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
357
  {"order-by-primary", OPT_ORDER_BY_PRIMARY,
unknown's avatar
unknown committed
358 359
   "Sorts each table's rows by primary key, or first unique key, if such a key exists.  Useful when dumping a MyISAM table to be loaded into an InnoDB table, but will make the dump itself take considerably longer.",
   (gptr*) &opt_order_by_primary, (gptr*) &opt_order_by_primary, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
360
#include <sslopt-longopts.h>
361 362 363 364 365
  {"tab",'T',
   "Creates tab separated textfile for each table to given path. (creates .sql and .txt files). NOTE: This only works if mysqldump is run on the same machine as the mysqld daemon.",
   (gptr*) &path, (gptr*) &path, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"tables", OPT_TABLES, "Overrides option --databases (-B).",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
366
#ifndef DONT_ALLOW_USER_CHANGE
367 368 369
  {"user", 'u', "User for login if not current user.",
   (gptr*) &current_user, (gptr*) &current_user, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
370
#endif
371 372 373 374 375 376 377 378
  {"verbose", 'v', "Print info about the various stages.",
   (gptr*) &verbose, (gptr*) &verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"version",'V', "Output version information and exit.", 0, 0, 0,
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"where", 'w', "Dump only selected records; QUOTES mandatory!",
   (gptr*) &where, (gptr*) &where, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"xml", 'X', "Dump a database as well formed XML.", 0, 0, 0, GET_NO_ARG,
   NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
379
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
unknown's avatar
unknown committed
380 381 382 383 384
};

static const char *load_default_groups[]= { "mysqldump","client",0 };

static void safe_exit(int error);
385
static void write_header(FILE *sql_file, char *db_name);
unknown's avatar
unknown committed
386 387 388 389 390 391 392 393
static void print_value(FILE *file, MYSQL_RES  *result, MYSQL_ROW row,
			const char *prefix,const char *name,
			int string_value);
static int dump_selected_tables(char *db, char **table_names, int tables);
static int dump_all_tables_in_db(char *db);
static int init_dumping(char *);
static int dump_databases(char **);
static int dump_all_databases();
unknown's avatar
unknown committed
394
static char *quote_name(const char *name, char *buff, my_bool force);
395
static const char *check_if_ignore_table(const char *table_name);
396
static char *primary_key_fields(const char *table_name);
397

unknown's avatar
unknown committed
398
#include <help_start.h>
unknown's avatar
unknown committed
399

400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
/*
  exit with message if ferror(file)
  
  SYNOPSIS
    check_io()
    file	- checked file
*/

void check_io(FILE *file)
{
  if (ferror(file))
  {
    fprintf(stderr, "%s: Got errno %d on write\n", my_progname, errno);
    safe_exit(EX_EOF);
  }
}

unknown's avatar
unknown committed
417 418 419
static void print_version(void)
{
  printf("%s  Ver %s Distrib %s, for %s (%s)\n",my_progname,DUMP_VERSION,
unknown's avatar
unknown committed
420 421
         MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
  NETWARE_SET_SCREEN_MODE(1);
unknown's avatar
unknown committed
422 423 424
} /* print_version */


425 426 427 428 429 430
static void short_usage_sub(void)
{
  printf("Usage: %s [OPTIONS] database [tables]\n", my_progname);
  printf("OR     %s [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...]\n",
	 my_progname);
  printf("OR     %s [OPTIONS] --all-databases [OPTIONS]\n", my_progname);
unknown's avatar
unknown committed
431
  NETWARE_SET_SCREEN_MODE(1);
432 433
}

unknown's avatar
unknown committed
434

unknown's avatar
unknown committed
435 436 437 438 439 440
static void usage(void)
{
  print_version();
  puts("By Igor Romanenko, Monty, Jani & Sinisa");
  puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,\nand you are welcome to modify and redistribute it under the GPL license\n");
  puts("Dumping definition and data mysql database or table");
441
  short_usage_sub();
unknown's avatar
unknown committed
442
  print_defaults("my",load_default_groups);
443 444
  my_print_help(my_long_options);
  my_print_variables(my_long_options);
unknown's avatar
unknown committed
445 446 447
} /* usage */


448 449 450 451 452 453
static void short_usage(void)
{
  short_usage_sub();
  printf("For more options, use %s --help\n", my_progname);
}

unknown's avatar
unknown committed
454 455
#include <help_end.h>

456

457
static void write_header(FILE *sql_file, char *db_name)
unknown's avatar
unknown committed
458
{
unknown's avatar
unknown committed
459
  if (opt_xml)
unknown's avatar
unknown committed
460
  {
461 462
    fputs("<?xml version=\"1.0\"?>\n", sql_file);
    fputs("<mysqldump>\n", sql_file);
463
    check_io(sql_file);
unknown's avatar
unknown committed
464
  }
unknown's avatar
unknown committed
465
  else if (!opt_compact)
unknown's avatar
unknown committed
466
  {
unknown's avatar
unknown committed
467 468 469 470 471 472 473 474 475 476 477
    if (opt_comments)
    {
      fprintf(sql_file, "-- MySQL dump %s\n--\n", DUMP_VERSION);
      fprintf(sql_file, "-- Host: %s    Database: %s\n",
	      current_host ? current_host : "localhost", db_name ? db_name :
	      "");
      fputs("-- ------------------------------------------------------\n",
	    sql_file);
      fprintf(sql_file, "-- Server version\t%s\n",
	      mysql_get_server_info(&mysql_connection));
    }
478
    if (opt_set_charset)
unknown's avatar
unknown committed
479 480 481 482 483
      fprintf(sql_file,
"\n/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;"
"\n/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;"
"\n/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;"
"\n/*!40101 SET NAMES %s */;\n",default_charset);
484 485 486
    if (!path)
    {
      fprintf(md_result_file,"\
487 488 489
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;\n\
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;\n\
");
490 491
    }
    fprintf(sql_file,
unknown's avatar
Merge  
unknown committed
492 493 494
	    "/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE=\"%s%s%s\" */;\n",
	    path?"":"NO_AUTO_VALUE_ON_ZERO",compatible_mode_normal_str[0]==0?"":",",
	    compatible_mode_normal_str);
495
    check_io(sql_file);
unknown's avatar
unknown committed
496
  }
497
} /* write_header */
unknown's avatar
unknown committed
498

499

unknown's avatar
unknown committed
500 501 502
static void write_footer(FILE *sql_file)
{
  if (opt_xml)
503
  {
unknown's avatar
unknown committed
504
    fputs("</mysqldump>\n", sql_file);
505 506
    check_io(sql_file);
  }
unknown's avatar
unknown committed
507
  else if (!opt_compact)
508
  {
509 510 511 512
    fprintf(sql_file,"\n/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;\n");
    if (!path)
    {
      fprintf(md_result_file,"\
513
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;\n\
unknown's avatar
unknown committed
514
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;\n");
515
    }
516
    if (opt_set_charset)
517
      fprintf(sql_file,
unknown's avatar
unknown committed
518 519 520
"/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;\n"
"/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;\n"
"/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;\n");
unknown's avatar
unknown committed
521
    fputs("\n", sql_file);
522
    check_io(sql_file);
523
  }
unknown's avatar
unknown committed
524
} /* write_footer */
unknown's avatar
unknown committed
525

526

527 528 529 530 531 532 533 534 535 536 537 538 539 540
static void free_table_ent(TABLE_RULE_ENT* e)
{
  my_free((gptr) e, MYF(0));
}


static byte* get_table_key(TABLE_RULE_ENT* e, uint* len,
			   my_bool not_used __attribute__((unused)))
{
  *len= e->key_len;
  return (byte*)e->key;
}


unknown's avatar
unknown committed
541
void init_table_rule_hash(HASH* h)
542 543 544 545
{
  if(hash_init(h, charset_info, TABLE_RULE_HASH_SIZE, 0, 0,
	       (hash_get_key) get_table_key,
	       (hash_free_key) free_table_ent, 0))
unknown's avatar
unknown committed
546
    exit(EX_EOM);
547 548
}

unknown's avatar
unknown committed
549

550 551 552
static my_bool
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument)
unknown's avatar
unknown committed
553
{
unknown's avatar
unknown committed
554
  switch (optid) {
555 556 557 558 559 560 561 562 563
  case 'p':
    if (argument)
    {
      char *start=argument;
      my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
      opt_password=my_strdup(argument,MYF(MY_FAE));
      while (*argument) *argument++= 'x';		/* Destroy argument */
      if (*start)
	start[1]=0;				/* Cut length of argument */
564
      tty_password= 0;
565 566 567 568 569
    }
    else
      tty_password=1;
    break;
  case 'r':
unknown's avatar
unknown committed
570
    if (!(md_result_file = my_fopen(argument, O_WRONLY | FILE_BINARY,
571 572 573 574
				    MYF(MY_WME))))
      exit(1);
    break;
  case 'W':
unknown's avatar
unknown committed
575
#ifdef __WIN__
576
    opt_protocol = MYSQL_PROTOCOL_PIPE;
unknown's avatar
unknown committed
577
#endif
578
    break;
579 580 581
  case 'N':
    opt_set_charset= 0;
    break;
582 583 584 585
  case 'T':
    opt_disable_keys=0;
    break;
  case '#':
unknown's avatar
unknown committed
586
    DBUG_PUSH(argument ? argument : default_dbug_option);
587
    break;
588
#include <sslopt-case.h>
589 590 591
  case 'V': print_version(); exit(0);
  case 'X':
    opt_xml = 1;
592 593
    extended_insert= opt_drop= opt_lock= 
      opt_disable_keys= opt_autocommit= opt_create_db= 0;
594 595 596 597 598
    break;
  case 'I':
  case '?':
    usage();
    exit(0);
599 600 601 602
  case (int) OPT_MASTER_DATA:
    if (!argument) /* work like in old versions */
      opt_master_data= MYSQL_OPT_MASTER_DATA_EFFECTIVE_SQL;
    break;
603
  case (int) OPT_OPTIMIZE:
604
    extended_insert= opt_drop= opt_lock= quick= create_options=
605
      opt_disable_keys= lock_tables= opt_set_charset= 1;
606
    break;
607 608
  case (int) OPT_SKIP_OPTIMIZATION:
    extended_insert= opt_drop= opt_lock= quick= create_options=
unknown's avatar
unknown committed
609
      opt_disable_keys= lock_tables= opt_set_charset= 0;
610
    break;
unknown's avatar
unknown committed
611 612 613 614
  case (int) OPT_COMPACT:
  if (opt_compact)
  {
    opt_comments= opt_drop= opt_disable_keys= opt_lock= 0;
615
    opt_set_charset= 0;
unknown's avatar
unknown committed
616
  }
617 618 619
  case (int) OPT_TABLES:
    opt_databases=0;
    break;
620 621 622
  case (int) OPT_IGNORE_TABLE:
  {
    uint len= (uint)strlen(argument);
unknown's avatar
unknown committed
623 624
    TABLE_RULE_ENT* e;
    if (!strchr(argument, '.'))
625
    {
unknown's avatar
unknown committed
626
      fprintf(stderr, "Illegal use of option --ignore-table=<database>.<table>\n");
627 628
      exit(1);
    }
unknown's avatar
unknown committed
629 630 631 632
    /* len is always > 0 because we know the there exists a '.' */
    e= (TABLE_RULE_ENT*)my_malloc(sizeof(TABLE_RULE_ENT) + len, MYF(MY_WME));
    if (!e)
      exit(EX_EOM);
633 634 635 636
    e->key= (char*)e + sizeof(TABLE_RULE_ENT);
    e->key_len= len;
    memcpy(e->key, argument, len);

unknown's avatar
unknown committed
637 638 639
    if (!hash_inited(&ignore_table))
      init_table_rule_hash(&ignore_table);

640
    if(my_hash_insert(&ignore_table, (byte*)e))
unknown's avatar
unknown committed
641
      exit(EX_EOM);
642 643
    break;
  }
644
  case (int) OPT_COMPATIBLE:
unknown's avatar
unknown committed
645
    {
646
      char buff[255];
647 648 649
      char *end= compatible_mode_normal_str;
      int i;
      ulong mode;
650 651

      opt_quoted= 1;
652
      opt_set_charset= 0;
653 654 655 656 657 658 659 660 661 662
      opt_compatible_mode_str= argument;
      opt_compatible_mode= find_set(&compatible_mode_typelib,
				    argument, strlen(argument),
				    &err_ptr, &err_len);
      if (err_len)
      {
	strmake(buff, err_ptr, min(sizeof(buff), err_len));
	fprintf(stderr, "Invalid mode to --compatible: %s\n", buff);
	exit(1);
      }
663 664
#if !defined(DBUG_OFF)
      {
unknown's avatar
unknown committed
665
	uint size_for_sql_mode= 0;
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
	const char **ptr;
	for (ptr= compatible_mode_names; *ptr; ptr++)
	  size_for_sql_mode+= strlen(*ptr);
	size_for_sql_mode+= sizeof(compatible_mode_names)-1;
	DBUG_ASSERT(sizeof(compatible_mode_normal_str)>=size_for_sql_mode);
      }
#endif
      mode= opt_compatible_mode;
      for (i= 0, mode= opt_compatible_mode; mode; mode>>= 1, i++)
      {
	if (mode & 1)
	{
	  end= strmov(end, compatible_mode_names[i]);
	  end= strmov(end, ",");
	}
      }
      if (end!=compatible_mode_normal_str)
	end[-1]= 0;
684 685 686 687
      /* 
        Set charset to the default compiled value if it hasn't
        been reset yet by --default-character-set=xxx.
      */
688
      if (default_charset == mysql_universal_client_charset)
689
        default_charset= (char*) MYSQL_DEFAULT_CHARSET_NAME;
690 691 692
      break;
    }
  case (int) OPT_MYSQL_PROTOCOL:
693
    {
694
      if ((opt_protocol= find_type(argument, &sql_protocol_typelib,0)) <= 0)
695 696 697 698 699
      {
	fprintf(stderr, "Unknown option to protocol: %s\n", argument);
	exit(1);
      }
      break;
700
    }
unknown's avatar
unknown committed
701
  }
702 703 704 705 706 707
  return 0;
}

static int get_options(int *argc, char ***argv)
{
  int ho_error;
708 709 710 711
  MYSQL_PARAMETERS *mysql_params= mysql_get_parameters();

  opt_max_allowed_packet= *mysql_params->p_max_allowed_packet;
  opt_net_buffer_length= *mysql_params->p_net_buffer_length;
712 713 714 715

  md_result_file= stdout;
  load_defaults("my",load_default_groups,argc,argv);

716
  if ((ho_error=handle_options(argc, argv, my_long_options, get_one_option)))
717
    exit(ho_error);
718

719 720 721
  *mysql_params->p_max_allowed_packet= opt_max_allowed_packet;
  *mysql_params->p_net_buffer_length= opt_net_buffer_length;

unknown's avatar
unknown committed
722 723 724 725 726
  if (opt_delayed)
    opt_lock=0;				/* Can't have lock with delayed */
  if (!path && (enclosed || opt_enclosed || escaped || lines_terminated ||
		fields_terminated))
  {
727 728
    fprintf(stderr,
	    "%s: You must use option --tab with --fields-...\n", my_progname);
unknown's avatar
unknown committed
729 730
    return(1);
  }
731 732 733 734 735 736 737 738 739 740 741 742 743

  /* Ensure consistency of the set of binlog & locking options */
  if (opt_delete_master_logs && !opt_master_data)
    opt_master_data= MYSQL_OPT_MASTER_DATA_COMMENTED_SQL;
  if (opt_single_transaction && opt_lock_all_tables)
  {
    fprintf(stderr, "%s: You can't use --single-transaction and "
            "--lock-all-tables at the same time.\n", my_progname);
    return(1);
  }  
  if (opt_master_data)
    opt_lock_all_tables= !opt_single_transaction;
  if (opt_single_transaction || opt_lock_all_tables)
744
    lock_tables= 0;
unknown's avatar
unknown committed
745 746 747 748 749 750 751 752 753 754 755 756
  if (enclosed && opt_enclosed)
  {
    fprintf(stderr, "%s: You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.\n", my_progname);
    return(1);
  }
  if ((opt_databases || opt_alldbs) && path)
  {
    fprintf(stderr,
	    "%s: --databases or --all-databases can't be used with --tab.\n",
	    my_progname);
    return(1);
  }
757 758
  if (strcmp(default_charset, charset_info->csname) &&
      !(charset_info= get_charset_by_csname(default_charset, 
759
  					    MY_CS_PRIMARY, MYF(MY_WME))))
760
    exit(1);
unknown's avatar
unknown committed
761 762
  if ((*argc < 1 && !opt_alldbs) || (*argc > 0 && opt_alldbs))
  {
763
    short_usage();
unknown's avatar
unknown committed
764 765 766
    return 1;
  }
  if (tty_password)
767
    opt_password=get_tty_password(NullS);
unknown's avatar
unknown committed
768 769 770 771 772 773 774 775 776 777
  return(0);
} /* get_options */


/*
** DBerror -- prints mysql error message and exits the program.
*/
static void DBerror(MYSQL *mysql, const char *when)
{
  DBUG_ENTER("DBerror");
unknown's avatar
unknown committed
778
  my_printf_error(0,"Got error: %d: %s %s", MYF(0),
unknown's avatar
unknown committed
779 780 781 782 783 784
		  mysql_errno(mysql), mysql_error(mysql), when);
  safe_exit(EX_MYSQLERR);
  DBUG_VOID_RETURN;
} /* DBerror */


785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
/*
  Sends a query to server, optionally reads result, prints error message if
  some.

  SYNOPSIS
    mysql_query_with_error_report()
    mysql_con       connection to use
    res             if non zero, result will be put there with mysql_store_result
    query           query to send to server

  RETURN VALUES
    0               query sending and (if res!=0) result reading went ok
    1               error
*/
  
static int mysql_query_with_error_report(MYSQL *mysql_con, MYSQL_RES **res,
                                         const char *query)
{
  if (mysql_query(mysql_con, query) ||
      (res && !((*res)= mysql_store_result(mysql_con))))
  {
    my_printf_error(0, "%s: Couldn't execute '%s': %s (%d)",
                    MYF(0), my_progname, query,
                    mysql_error(mysql_con), mysql_errno(mysql_con));
    return 1;
  }
  return 0;
}


unknown's avatar
unknown committed
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
static void safe_exit(int error)
{
  if (!first_error)
    first_error= error;
  if (ignore_errors)
    return;
  if (sock)
    mysql_close(sock);
  exit(error);
}
/* safe_exit */


/*
** dbConnect -- connects to the host and selects DB.
*/
static int dbConnect(char *host, char *user,char *passwd)
{
833
  char buff[20+FN_REFLEN];
unknown's avatar
unknown committed
834 835 836
  DBUG_ENTER("dbConnect");
  if (verbose)
  {
837
    fprintf(stderr, "-- Connecting to %s...\n", host ? host : "localhost");
unknown's avatar
unknown committed
838 839 840 841 842 843 844
  }
  mysql_init(&mysql_connection);
  if (opt_compress)
    mysql_options(&mysql_connection,MYSQL_OPT_COMPRESS,NullS);
#ifdef HAVE_OPENSSL
  if (opt_use_ssl)
    mysql_ssl_set(&mysql_connection, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
845
		  opt_ssl_capath, opt_ssl_cipher);
846 847 848 849 850 851
#endif
  if (opt_protocol)
    mysql_options(&mysql_connection,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
#ifdef HAVE_SMEM
  if (shared_memory_base_name)
    mysql_options(&mysql_connection,MYSQL_SHARED_MEMORY_BASE_NAME,shared_memory_base_name);
unknown's avatar
unknown committed
852
#endif
853
  mysql_options(&mysql_connection, MYSQL_SET_CHARSET_NAME, default_charset);
unknown's avatar
unknown committed
854 855 856 857 858 859 860
  if (!(sock= mysql_real_connect(&mysql_connection,host,user,passwd,
         NULL,opt_mysql_port,opt_mysql_unix_port,
         0)))
  {
    DBerror(&mysql_connection, "when trying to connect");
    return 1;
  }
861 862 863 864 865
  /*
    As we're going to set SQL_MODE, it would be lost on reconnect, so we
    cannot reconnect.
  */
  sock->reconnect= 0;
866 867
  sprintf(buff, "/*!40100 SET @@SQL_MODE=\"%s\" */",
	  compatible_mode_normal_str);
868
  if (mysql_query_with_error_report(sock, 0, buff))
869 870 871 872 873
  {
    mysql_close(sock);
    safe_exit(EX_MYSQLERR);
    return 1;
  }
unknown's avatar
unknown committed
874 875 876 877 878 879 880 881 882 883
  return 0;
} /* dbConnect */


/*
** dbDisconnect -- disconnects from the host.
*/
static void dbDisconnect(char *host)
{
  if (verbose)
884
    fprintf(stderr, "-- Disconnecting from %s...\n", host ? host : "localhost");
unknown's avatar
unknown committed
885 886 887 888 889 890 891 892 893 894 895 896 897
  mysql_close(sock);
} /* dbDisconnect */


static void unescape(FILE *file,char *pos,uint length)
{
  char *tmp;
  DBUG_ENTER("unescape");
  if (!(tmp=(char*) my_malloc(length*2+1, MYF(MY_WME))))
  {
    ignore_errors=0;				/* Fatal error */
    safe_exit(EX_MYSQLERR);			/* Force exit */
  }
unknown's avatar
unknown committed
898
  mysql_real_escape_string(&mysql_connection, tmp, pos, length);
unknown's avatar
unknown committed
899 900 901
  fputc('\'', file);
  fputs(tmp, file);
  fputc('\'', file);
902
  check_io(file);
unknown's avatar
unknown committed
903 904 905 906 907 908 909 910 911
  my_free(tmp, MYF(MY_WME));
  DBUG_VOID_RETURN;
} /* unescape */


static my_bool test_if_special_chars(const char *str)
{
#if MYSQL_VERSION_ID >= 32300
  for ( ; *str ; str++)
912
    if (!my_isvar(charset_info,*str) && *str != '$')
unknown's avatar
unknown committed
913 914 915 916 917
      return 1;
#endif
  return 0;
} /* test_if_special_chars */

unknown's avatar
unknown committed
918

unknown's avatar
unknown committed
919

unknown's avatar
unknown committed
920
static char *quote_name(const char *name, char *buff, my_bool force)
unknown's avatar
unknown committed
921
{
unknown's avatar
unknown committed
922
  char *to= buff;
923 924
  char qtype= (opt_compatible_mode & MASK_ANSI_QUOTES) ? '\"' : '`';

unknown's avatar
unknown committed
925 926
  if (!force && !opt_quoted && !test_if_special_chars(name))
    return (char*) name;
927
  *to++= qtype;
unknown's avatar
unknown committed
928 929
  while (*name)
  {
930 931
    if (*name == qtype)
      *to++= qtype;
unknown's avatar
unknown committed
932 933
    *to++= *name++;
  }
934 935
  to[0]= qtype;
  to[1]= 0;
unknown's avatar
unknown committed
936 937 938 939
  return buff;
} /* quote_name */


940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956

static char *quote_for_like(const char *name, char *buff)
{
  char *to= buff;
  *to++= '\'';
  while (*name)
  {
    if (*name == '\'' || *name == '_' || *name == '\\' || *name == '%')
      *to++= '\\';
    *to++= *name++;
  }
  to[0]= '\'';
  to[1]= 0;
  return buff;
}


957 958 959 960 961 962 963 964 965 966
/*
  Quote and print a string.
  
  SYNOPSIS
    print_quoted_xml()
    output	- output file
    str		- string to print
    len		- its length
    
  DESCRIPTION
967
    Quote '<' '>' '&' '\"' chars and print a string to the xml_file.
968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
*/

static void print_quoted_xml(FILE *xml_file, const char *str, ulong len)
{
  const char *end;
  
  for (end= str + len; str != end; str++)
  {
    switch (*str) {
    case '<':
      fputs("&lt;", xml_file);
      break;
    case '>':
      fputs("&gt;", xml_file);
      break;
    case '&':
      fputs("&amp;", xml_file);
      break;
    case '\"':
      fputs("&quot;", xml_file);
      break;
    default:
      fputc(*str, xml_file);
      break;
    }
  }
994
  check_io(xml_file);
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
}


/*
  Print xml tag with one attribute.
  
  SYNOPSIS
    print_xml_tag1()
    xml_file	- output file
    sbeg	- line beginning
    stag_atr	- tag and attribute
    sval	- value of attribute
    send	- line ending
    
  DESCRIPTION
    Print tag with one attribute to the xml_file. Format is:
      sbeg<stag_atr="sval">send
  NOTE
    sval MUST be a NULL terminated string.
    sval string will be qouted before output.
*/

static void print_xml_tag1(FILE * xml_file, const char* sbeg,
			   const char* stag_atr, const char* sval,
			   const char* send)
{
  fputs(sbeg, xml_file);
  fputs("<", xml_file);
  fputs(stag_atr, xml_file);
  fputs("\"", xml_file);
  print_quoted_xml(xml_file, sval, strlen(sval));
  fputs("\">", xml_file);
  fputs(send, xml_file);
1028
  check_io(xml_file);
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
}


/*
  Print xml tag with many attributes.

  SYNOPSIS
    print_xml_row()
    xml_file	- output file
    row_name	- xml tag name
    tableRes	- query result
    row		- result row
    
  DESCRIPTION
    Print tag with many attribute to the xml_file. Format is:
      \t\t<row_name Atr1="Val1" Atr2="Val2"... />
  NOTE
    All atributes and values will be quoted before output.
*/

static void print_xml_row(FILE *xml_file, const char *row_name,
			  MYSQL_RES *tableRes, MYSQL_ROW *row)
1051 1052 1053 1054 1055 1056
{
  uint i;
  MYSQL_FIELD *field;
  ulong *lengths= mysql_fetch_lengths(tableRes);
  
  fprintf(xml_file, "\t\t<%s", row_name);
1057
  check_io(xml_file);
1058 1059 1060
  mysql_field_seek(tableRes, 0);
  for (i= 0; (field= mysql_fetch_field(tableRes)); i++)
  {
1061
    if ((*row)[i])
1062
    {
unknown's avatar
unknown committed
1063
      fputc(' ', xml_file);
1064
      print_quoted_xml(xml_file, field->name, field->name_length);
1065 1066
      fputs("=\"", xml_file);
      print_quoted_xml(xml_file, (*row)[i], lengths[i]);
unknown's avatar
unknown committed
1067
      fputc('"', xml_file);
1068
      check_io(xml_file);
1069 1070 1071
    }
  }
  fputs(" />\n", xml_file);
1072
  check_io(xml_file);
1073 1074
}

unknown's avatar
unknown committed
1075
/*
unknown's avatar
unknown committed
1076 1077 1078 1079 1080
  getStructure -- retrievs database structure, prints out corresponding
  CREATE statement and fills out insert_pat.

  RETURN
    number of fields in table, 0 if error
unknown's avatar
unknown committed
1081
*/
unknown's avatar
unknown committed
1082

unknown's avatar
unknown committed
1083 1084 1085 1086 1087 1088
static uint getTableStructure(char *table, char* db)
{
  MYSQL_RES  *tableRes;
  MYSQL_ROW  row;
  my_bool    init=0;
  uint       numFields;
unknown's avatar
unknown committed
1089
  char	     *strpos, *result_table, *opt_quoted_table;
unknown's avatar
unknown committed
1090
  const char *delayed;
unknown's avatar
unknown committed
1091 1092
  char	     name_buff[NAME_LEN+3],table_buff[NAME_LEN*2+3];
  char	     table_buff2[NAME_LEN*2+3];
unknown's avatar
unknown committed
1093
  FILE       *sql_file = md_result_file;
unknown's avatar
unknown committed
1094 1095 1096 1097 1098
  DBUG_ENTER("getTableStructure");

  delayed= opt_delayed ? " DELAYED " : "";

  if (verbose)
1099
    fprintf(stderr, "-- Retrieving table structure for table %s...\n", table);
unknown's avatar
unknown committed
1100

unknown's avatar
unknown committed
1101 1102
  sprintf(insert_pat,"SET OPTION SQL_QUOTE_SHOW_CREATE=%d",
	  (opt_quoted || opt_keywords));
unknown's avatar
unknown committed
1103
  if (!create_options)
unknown's avatar
unknown committed
1104
    strmov(strend(insert_pat), "/*!40102 ,SQL_MODE=concat(@@sql_mode, _utf8 ',NO_KEY_OPTIONS,NO_TABLE_OPTIONS,NO_FIELD_OPTIONS') */");
unknown's avatar
unknown committed
1105

unknown's avatar
unknown committed
1106 1107
  result_table=     quote_name(table, table_buff, 1);
  opt_quoted_table= quote_name(table, table_buff2, 0);
1108 1109 1110 1111

  if (opt_order_by_primary)
    order_by = primary_key_fields(opt_quoted_table);

1112
  if (!opt_xml && !mysql_query_with_error_report(sock, 0, insert_pat))
unknown's avatar
unknown committed
1113
  {
1114 1115
    /* using SHOW CREATE statement */
    if (!tFlag)
unknown's avatar
unknown committed
1116
    {
1117 1118 1119
      /* Make an sql-file, if path was given iow. option -T was given */
      char buff[20+FN_REFLEN];

unknown's avatar
unknown committed
1120
      sprintf(buff,"show create table %s", result_table);
1121
      if (mysql_query_with_error_report(sock, 0, buff))
unknown's avatar
unknown committed
1122
      {
1123 1124
        safe_exit(EX_MYSQLERR);
        DBUG_RETURN(0);
unknown's avatar
unknown committed
1125 1126
      }

1127 1128 1129
      if (path)
      {
        char filename[FN_REFLEN], tmp_path[FN_REFLEN];
1130
        convert_dirname(tmp_path,path,NullS);
1131
        sql_file= my_fopen(fn_format(filename, table, tmp_path, ".sql", 4),
1132
				 O_WRONLY, MYF(MY_WME));
1133 1134
        if (!sql_file)			/* If file couldn't be opened */
        {
unknown's avatar
unknown committed
1135 1136
	  safe_exit(EX_MYSQLERR);
	  DBUG_RETURN(0);
1137
        }
1138
        write_header(sql_file, db);
1139
      }
1140
      if (!opt_xml && opt_comments)
1141
      {
unknown's avatar
unknown committed
1142
        fprintf(sql_file, "\n--\n-- Table structure for table %s\n--\n\n",
unknown's avatar
unknown committed
1143
		result_table);
1144 1145
	check_io(sql_file);
      }
1146
      if (opt_drop)
1147
      {
unknown's avatar
unknown committed
1148
        fprintf(sql_file, "DROP TABLE IF EXISTS %s;\n", opt_quoted_table);
1149 1150
	check_io(sql_file);
      }
1151 1152 1153

      tableRes=mysql_store_result(sock);
      row=mysql_fetch_row(tableRes);
1154
      fprintf(sql_file, "%s;\n", row[1]);
1155
      check_io(sql_file);
1156 1157
      mysql_free_result(tableRes);
    }
unknown's avatar
unknown committed
1158
    sprintf(insert_pat,"show fields from %s", result_table);
1159
    if (mysql_query_with_error_report(sock, &tableRes, insert_pat))
unknown's avatar
unknown committed
1160
    {
1161 1162
      if (path)
	my_fclose(sql_file, MYF(MY_WME));
1163 1164
      safe_exit(EX_MYSQLERR);
      DBUG_RETURN(0);
unknown's avatar
unknown committed
1165
    }
1166

unknown's avatar
unknown committed
1167
    if (cFlag)
unknown's avatar
unknown committed
1168
      sprintf(insert_pat, "INSERT %sINTO %s (", delayed, opt_quoted_table);
1169
    else
unknown's avatar
unknown committed
1170
    {
unknown's avatar
unknown committed
1171 1172
      sprintf(insert_pat, "INSERT %sINTO %s VALUES ", delayed,
	      opt_quoted_table);
1173 1174 1175 1176 1177 1178 1179 1180
      if (!extended_insert)
        strcat(insert_pat,"(");
    }

    strpos=strend(insert_pat);
    while ((row=mysql_fetch_row(tableRes)))
    {
      if (init)
unknown's avatar
unknown committed
1181
      {
1182
        if (cFlag)
1183
	  strpos=strmov(strpos,", ");
unknown's avatar
unknown committed
1184
      }
1185 1186
      init=1;
      if (cFlag)
unknown's avatar
unknown committed
1187
        strpos=strmov(strpos,quote_name(row[SHOW_FIELDNAME], name_buff, 0));
unknown's avatar
unknown committed
1188
    }
1189 1190
    numFields = (uint) mysql_num_rows(tableRes);
    mysql_free_result(tableRes);
unknown's avatar
unknown committed
1191
  }
1192
  else
unknown's avatar
unknown committed
1193
  {
unknown's avatar
unknown committed
1194 1195 1196 1197
    if (verbose)
      fprintf(stderr,
              "%s: Warning: Can't set SQL_QUOTE_SHOW_CREATE option (%s)\n",
              my_progname, mysql_error(sock));
1198

unknown's avatar
unknown committed
1199
    sprintf(insert_pat,"show fields from %s", result_table);
1200
    if (mysql_query_with_error_report(sock, &tableRes, insert_pat))
unknown's avatar
unknown committed
1201 1202 1203 1204 1205
    {
      safe_exit(EX_MYSQLERR);
      DBUG_RETURN(0);
    }

1206 1207
    /* Make an sql-file, if path was given iow. option -T was given */
    if (!tFlag)
unknown's avatar
unknown committed
1208
    {
1209
      if (path)
unknown's avatar
unknown committed
1210
      {
1211
        char filename[FN_REFLEN], tmp_path[FN_REFLEN];
1212
        convert_dirname(tmp_path,path,NullS);
1213 1214 1215 1216
        sql_file= my_fopen(fn_format(filename, table, tmp_path, ".sql", 4),
				 O_WRONLY, MYF(MY_WME));
        if (!sql_file)			/* If file couldn't be opened */
        {
1217 1218
	  safe_exit(EX_MYSQLERR);
	  DBUG_RETURN(0);
1219
        }
1220
        write_header(sql_file, db);
unknown's avatar
unknown committed
1221
      }
1222
      if (!opt_xml && opt_comments)
unknown's avatar
unknown committed
1223 1224
	fprintf(sql_file, "\n--\n-- Table structure for table %s\n--\n\n",
		result_table);
1225
      if (opt_drop)
1226
        fprintf(sql_file, "DROP TABLE IF EXISTS %s;\n",result_table);
1227 1228 1229
      if (!opt_xml)
	fprintf(sql_file, "CREATE TABLE %s (\n", result_table);
      else
1230
        print_xml_tag1(sql_file, "\t", "table_structure name=", table, "\n");
1231
      check_io(sql_file);
1232 1233
    }
    if (cFlag)
1234
      sprintf(insert_pat, "INSERT %sINTO %s (", delayed, result_table);
1235 1236
    else
    {
1237
      sprintf(insert_pat, "INSERT %sINTO %s VALUES ", delayed, result_table);
1238 1239
      if (!extended_insert)
        strcat(insert_pat,"(");
unknown's avatar
unknown committed
1240
    }
1241 1242

    strpos=strend(insert_pat);
unknown's avatar
unknown committed
1243 1244
    while ((row=mysql_fetch_row(tableRes)))
    {
1245 1246
      ulong *lengths=mysql_fetch_lengths(tableRes);
      if (init)
unknown's avatar
unknown committed
1247
      {
1248
        if (!opt_xml && !tFlag)
1249
	{
1250
	  fputs(",\n",sql_file);
1251 1252
	  check_io(sql_file);
	}
1253
        if (cFlag)
1254
	  strpos=strmov(strpos,", ");
1255 1256 1257
      }
      init=1;
      if (cFlag)
unknown's avatar
unknown committed
1258
        strpos=strmov(strpos,quote_name(row[SHOW_FIELDNAME], name_buff, 0));
1259 1260
      if (!tFlag)
      {
1261 1262 1263 1264 1265 1266
	if (opt_xml)
	{
	  print_xml_row(sql_file, "field", tableRes, &row);
	  continue;
	}
	
1267
        if (opt_keywords)
1268
	  fprintf(sql_file, "  %s.%s %s", result_table,
unknown's avatar
unknown committed
1269 1270
		  quote_name(row[SHOW_FIELDNAME],name_buff, 0),
		  row[SHOW_TYPE]);
1271
        else
unknown's avatar
unknown committed
1272
	  fprintf(sql_file, "  %s %s", quote_name(row[SHOW_FIELDNAME],
unknown's avatar
unknown committed
1273 1274
						  name_buff, 0),
		  row[SHOW_TYPE]);
1275 1276
        if (row[SHOW_DEFAULT])
        {
unknown's avatar
unknown committed
1277
	  fputs(" DEFAULT ", sql_file);
unknown's avatar
unknown committed
1278
	  unescape(sql_file, row[SHOW_DEFAULT], lengths[SHOW_DEFAULT]);
1279 1280
        }
        if (!row[SHOW_NULL][0])
unknown's avatar
unknown committed
1281
	  fputs(" NOT NULL", sql_file);
1282
        if (row[SHOW_EXTRA][0])
unknown's avatar
unknown committed
1283
	  fprintf(sql_file, " %s",row[SHOW_EXTRA]);
1284
	check_io(sql_file);
unknown's avatar
unknown committed
1285 1286
      }
    }
1287 1288 1289
    numFields = (uint) mysql_num_rows(tableRes);
    mysql_free_result(tableRes);
    if (!tFlag)
unknown's avatar
unknown committed
1290
    {
1291 1292 1293
      /* Make an sql-file, if path was given iow. option -T was given */
      char buff[20+FN_REFLEN];
      uint keynr,primary_key;
unknown's avatar
unknown committed
1294
      sprintf(buff,"show keys from %s", result_table);
1295
      if (mysql_query_with_error_report(sock, &tableRes, buff))
unknown's avatar
unknown committed
1296
      {
1297
        if (path)
unknown's avatar
unknown committed
1298
	  my_fclose(sql_file, MYF(MY_WME));
1299 1300
        safe_exit(EX_MYSQLERR);
        DBUG_RETURN(0);
unknown's avatar
unknown committed
1301
      }
1302 1303 1304 1305 1306

      /* Find first which key is primary key */
      keynr=0;
      primary_key=INT_MAX;
      while ((row=mysql_fetch_row(tableRes)))
unknown's avatar
unknown committed
1307
      {
1308 1309
        if (atoi(row[3]) == 1)
        {
unknown's avatar
unknown committed
1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
	  keynr++;
#ifdef FORCE_PRIMARY_KEY
	  if (atoi(row[1]) == 0 && primary_key == INT_MAX)
	    primary_key=keynr;
#endif
	  if (!strcmp(row[2],"PRIMARY"))
	  {
	    primary_key=keynr;
	    break;
	  }
1320
        }
unknown's avatar
unknown committed
1321
      }
1322 1323 1324 1325
      mysql_data_seek(tableRes,0);
      keynr=0;
      while ((row=mysql_fetch_row(tableRes)))
      {
1326 1327 1328 1329 1330 1331
	if (opt_xml)
	{
	  print_xml_row(sql_file, "key", tableRes, &row);
	  continue;
	}
        
1332 1333
        if (atoi(row[3]) == 1)
        {
unknown's avatar
unknown committed
1334 1335 1336 1337
	  if (keynr++)
	    putc(')', sql_file);
	  if (atoi(row[1]))       /* Test if duplicate key */
	    /* Duplicate allowed */
unknown's avatar
unknown committed
1338
	    fprintf(sql_file, ",\n  KEY %s (",quote_name(row[2],name_buff,0));
unknown's avatar
unknown committed
1339 1340 1341
	  else if (keynr == primary_key)
	    fputs(",\n  PRIMARY KEY (",sql_file); /* First UNIQUE is primary */
	  else
unknown's avatar
unknown committed
1342 1343
	    fprintf(sql_file, ",\n  UNIQUE %s (",quote_name(row[2],name_buff,
							    0));
1344 1345
        }
        else
unknown's avatar
unknown committed
1346
	  putc(',', sql_file);
unknown's avatar
unknown committed
1347
        fputs(quote_name(row[4], name_buff, 0), sql_file);
1348
        if (row[7])
unknown's avatar
unknown committed
1349
	  fprintf(sql_file, " (%s)",row[7]);      /* Sub key */
1350
	check_io(sql_file);
1351
      }
1352 1353 1354 1355 1356
      if (!opt_xml)
      {
	if (keynr)
	  putc(')', sql_file);
	fputs("\n)",sql_file);
1357
	check_io(sql_file);
1358
      }
1359 1360 1361

      /* Get MySQL specific create options */
      if (create_options)
unknown's avatar
unknown committed
1362
      {
1363 1364 1365
	char show_name_buff[FN_REFLEN];
        sprintf(buff,"show table status like %s",
		quote_for_like(table, show_name_buff));
1366
        if (mysql_query_with_error_report(sock, &tableRes, buff))
1367
        {
unknown's avatar
unknown committed
1368 1369 1370 1371
	  if (mysql_errno(sock) != ER_PARSE_ERROR)
	  {					/* If old MySQL version */
	    if (verbose)
	      fprintf(stderr,
unknown's avatar
unknown committed
1372 1373
		      "-- Warning: Couldn't get status information for table %s (%s)\n",
		      result_table,mysql_error(sock));
unknown's avatar
unknown committed
1374
	  }
1375
        }
1376
        else if (!(row=mysql_fetch_row(tableRes)))
1377
        {
unknown's avatar
unknown committed
1378
	  fprintf(stderr,
unknown's avatar
unknown committed
1379 1380
		  "Error: Couldn't read status information for table %s (%s)\n",
		  result_table,mysql_error(sock));
1381 1382 1383
        }
        else
        {
1384 1385 1386 1387 1388 1389 1390
	  if (opt_xml)
	  {
	    print_xml_row(sql_file, "options", tableRes, &row);
	  }
	  else
	  {
	    fputs("/*!",sql_file);
unknown's avatar
unknown committed
1391
	    print_value(sql_file,tableRes,row,"engine=","Engine",0);
1392 1393 1394
	    print_value(sql_file,tableRes,row,"","Create_options",0);
	    print_value(sql_file,tableRes,row,"comment=","Comment",1);
	    fputs(" */",sql_file);
1395
	    check_io(sql_file);
1396
	  }
1397 1398
        }
        mysql_free_result(tableRes);		/* Is always safe to free */
unknown's avatar
unknown committed
1399
      }
1400 1401 1402 1403
      if (!opt_xml)
	fputs(";\n", sql_file);
      else
	fputs("\t</table_structure>\n", sql_file);
1404
      check_io(sql_file);
unknown's avatar
unknown committed
1405 1406 1407 1408 1409 1410 1411 1412
    }
  }
  if (cFlag)
  {
    strpos=strmov(strpos,") VALUES ");
    if (!extended_insert)
      strpos=strmov(strpos,"(");
  }
1413
  if (sql_file != md_result_file)
1414 1415 1416
  {
    fputs("\n", sql_file);
    write_footer(sql_file);
1417
    my_fclose(sql_file, MYF(MY_WME));
1418
  }
unknown's avatar
unknown committed
1419 1420 1421 1422 1423 1424 1425 1426 1427
  DBUG_RETURN(numFields);
} /* getTableStructure */


static char *add_load_option(char *ptr,const char *object,
			     const char *statement)
{
  if (object)
  {
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
    /* Don't escape hex constants */
    if (object[0] == '0' && (object[1] == 'x' || object[1] == 'X'))
      ptr= strxmov(ptr," ",statement," ",object,NullS);
    else
    {
      /* char constant; escape */
      ptr= strxmov(ptr," ",statement," '",NullS);
      ptr= field_escape(ptr,object,(uint) strlen(object));
      *ptr++= '\'';
    }
unknown's avatar
unknown committed
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
  }
  return ptr;
} /* add_load_option */


/*
** Allow the user to specify field terminator strings like:
** "'", "\", "\\" (escaped backslash), "\t" (tab), "\n" (newline)
** This is done by doubleing ' and add a end -\ if needed to avoid
** syntax errors from the SQL parser.
*/

static char *field_escape(char *to,const char *from,uint length)
{
  const char *end;
  uint end_backslashes=0;

  for (end= from+length; from != end; from++)
  {
    *to++= *from;
    if (*from == '\\')
      end_backslashes^=1;    /* find odd number of backslashes */
    else
    {
      if (*from == '\'' && !end_backslashes)
	*to++= *from;      /* We want a duplicate of "'" for MySQL */
      end_backslashes=0;
    }
  }
  /* Add missing backslashes if user has specified odd number of backs.*/
  if (end_backslashes)
    *to++= '\\';
  return to;
} /* field_escape */


1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
static char *alloc_query_str(ulong size)
{
  char *query;

  if (!(query= (char*) my_malloc(size, MYF(MY_WME))))
  {
    ignore_errors= 0;   			/* Fatal error */
    safe_exit(EX_MYSQLERR);			/* Force exit */
  }
  return query;
}

unknown's avatar
unknown committed
1486 1487 1488 1489 1490
/*
** dumpTable saves database contents as a series of INSERT statements.
*/
static void dumpTable(uint numFields, char *table)
{
1491
  char query_buf[QUERY_LENGTH], *end, buff[256],table_buff[NAME_LEN+3];
unknown's avatar
unknown committed
1492
  char *result_table, table_buff2[NAME_LEN*2+3], *opt_quoted_table;
1493
  char *query= query_buf;
unknown's avatar
unknown committed
1494
  MYSQL_RES	*res;
unknown's avatar
unknown committed
1495 1496
  MYSQL_FIELD	*field;
  MYSQL_ROW	row;
unknown's avatar
unknown committed
1497
  ulong		rownr, row_break, total_length, init_length;
1498
  const char    *table_type;
1499
  int error= 0;
unknown's avatar
unknown committed
1500

unknown's avatar
unknown committed
1501 1502
  result_table= quote_name(table,table_buff, 1);
  opt_quoted_table= quote_name(table, table_buff2, 0);
1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515

  /* Check table type */
  if ((table_type= check_if_ignore_table(table)))
  {
    if (verbose)
      fprintf(stderr,
	      "-- Skipping data for table '%s' because it's of type %s\n",
	      table, table_type);
    return;
  }

  if (verbose)
    fprintf(stderr, "-- Sending SELECT query...\n");
unknown's avatar
unknown committed
1516 1517 1518
  if (path)
  {
    char filename[FN_REFLEN], tmp_path[FN_REFLEN];
1519
    convert_dirname(tmp_path,path,NullS);
unknown's avatar
unknown committed
1520 1521 1522 1523 1524
    my_load_path(tmp_path, tmp_path, NULL);
    fn_format(filename, table, tmp_path, ".txt", 4);
    my_delete(filename, MYF(0)); /* 'INTO OUTFILE' doesn't work, if
				    filename wasn't deleted */
    to_unix_path(filename);
1525 1526
    sprintf(query, "SELECT /*!40001 SQL_NO_CACHE */ * INTO OUTFILE '%s'",
	    filename);
unknown's avatar
unknown committed
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
    end= strend(query);

    if (fields_terminated || enclosed || opt_enclosed || escaped)
      end= strmov(end, " FIELDS");
    end= add_load_option(end, fields_terminated, " TERMINATED BY");
    end= add_load_option(end, enclosed, " ENCLOSED BY");
    end= add_load_option(end, opt_enclosed, " OPTIONALLY ENCLOSED BY");
    end= add_load_option(end, escaped, " ESCAPED BY");
    end= add_load_option(end, lines_terminated, " LINES TERMINATED BY");
    *end= '\0';

unknown's avatar
unknown committed
1538
    sprintf(buff," FROM %s", result_table);
unknown's avatar
unknown committed
1539
    end= strmov(end,buff);
1540
    if (where || order_by)
1541
    {
1542 1543 1544 1545 1546 1547 1548 1549 1550
      query = alloc_query_str((ulong) ((end - query) + 1 +
                             (where ? strlen(where) + 7 : 0) +
                             (order_by ? strlen(order_by) + 10 : 0)));
      end = strmov(query, query_buf);

      if (where)
        end = strxmov(end, " WHERE ", where, NullS);
      if (order_by)
        end = strxmov(end, " ORDER BY ", order_by, NullS);
1551 1552
    }
    if (mysql_real_query(sock, query, (uint) (end - query)))
unknown's avatar
unknown committed
1553 1554 1555 1556 1557 1558 1559
    {
      DBerror(sock, "when executing 'SELECT INTO OUTFILE'");
      return;
    }
  }
  else
  {
1560
    if (!opt_xml && opt_comments)
1561
    {
unknown's avatar
unknown committed
1562 1563
      fprintf(md_result_file,"\n--\n-- Dumping data for table %s\n--\n",
	      result_table);
1564 1565
      check_io(md_result_file);
    }
1566
    sprintf(query, "SELECT /*!40001 SQL_NO_CACHE */ * FROM %s",
unknown's avatar
unknown committed
1567
	    result_table);
1568
    if (where || order_by)
unknown's avatar
unknown committed
1569
    {
1570 1571 1572 1573 1574 1575
      query = alloc_query_str((ulong) (strlen(query) + 1 +
                             (where ? strlen(where) + 7 : 0) +
                             (order_by ? strlen(order_by) + 10 : 0)));
      end = strmov(query, query_buf);

      if (where)
1576
      {
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
        if (!opt_xml && opt_comments)
        {
          fprintf(md_result_file, "-- WHERE:  %s\n", where);
          check_io(md_result_file);
        }
        end = strxmov(end, " WHERE ", where, NullS);
      }
      if (order_by)
      {
        if (!opt_xml && opt_comments)
        {
          fprintf(md_result_file, "-- ORDER BY:  %s\n", order_by);
          check_io(md_result_file);
        }
        end = strxmov(end, " ORDER BY ", order_by, NullS);
1592
      }
unknown's avatar
unknown committed
1593
    }
unknown's avatar
unknown committed
1594
    if (!opt_xml && !opt_compact)
1595
    {
unknown's avatar
merge  
unknown committed
1596
      fputs("\n", md_result_file);
1597 1598
      check_io(md_result_file);
    }
1599
    if (mysql_query_with_error_report(sock, 0, query))
unknown's avatar
unknown committed
1600 1601 1602 1603 1604 1605 1606 1607
      DBerror(sock, "when retrieving data from server");
    if (quick)
      res=mysql_use_result(sock);
    else
      res=mysql_store_result(sock);
    if (!res)
      DBerror(sock, "when retrieving data from server");
    if (verbose)
1608
      fprintf(stderr, "-- Retrieving rows...\n");
unknown's avatar
unknown committed
1609 1610
    if (mysql_num_fields(res) != numFields)
    {
unknown's avatar
unknown committed
1611 1612
      fprintf(stderr,"%s: Error in field count for table: %s !  Aborting.\n",
	      my_progname, result_table);
1613 1614
      error= EX_CONSCHECK;
      goto err;
unknown's avatar
unknown committed
1615 1616
    }

unknown's avatar
merge  
unknown committed
1617
    if (opt_disable_keys)
1618
    {
unknown's avatar
unknown committed
1619
      fprintf(md_result_file, "\n/*!40000 ALTER TABLE %s DISABLE KEYS */;\n",
unknown's avatar
unknown committed
1620
	      opt_quoted_table);
1621 1622
      check_io(md_result_file);
    }
unknown's avatar
unknown committed
1623
    if (opt_lock)
1624
    {
unknown's avatar
unknown committed
1625
      fprintf(md_result_file,"LOCK TABLES %s WRITE;\n", opt_quoted_table);
1626 1627
      check_io(md_result_file);
    }
unknown's avatar
unknown committed
1628

1629
    total_length= opt_net_buffer_length;		/* Force row break */
unknown's avatar
unknown committed
1630 1631
    row_break=0;
    rownr=0;
unknown's avatar
unknown committed
1632
    init_length=(uint) strlen(insert_pat)+4;
unknown's avatar
unknown committed
1633
    if (opt_xml)
1634
      print_xml_tag1(md_result_file, "\t", "table_data name=", table, "\n");
unknown's avatar
unknown committed
1635

unknown's avatar
unknown committed
1636
    if (opt_autocommit)
1637
    {
unknown's avatar
unknown committed
1638
      fprintf(md_result_file, "set autocommit=0;\n");
1639 1640
      check_io(md_result_file);
    }
unknown's avatar
unknown committed
1641

unknown's avatar
unknown committed
1642 1643 1644 1645 1646
    while ((row=mysql_fetch_row(res)))
    {
      uint i;
      ulong *lengths=mysql_fetch_lengths(res);
      rownr++;
unknown's avatar
unknown committed
1647
      if (!extended_insert && !opt_xml)
1648
      {
unknown's avatar
unknown committed
1649
	fputs(insert_pat,md_result_file);
1650 1651
	check_io(md_result_file);
      }
unknown's avatar
unknown committed
1652 1653
      mysql_field_seek(res,0);

unknown's avatar
merge  
unknown committed
1654
      if (opt_xml)
1655
      {
1656
        fputs("\t<row>\n", md_result_file);
1657 1658
	check_io(md_result_file);
      }
unknown's avatar
merge  
unknown committed
1659

unknown's avatar
unknown committed
1660 1661
      for (i = 0; i < mysql_num_fields(res); i++)
      {
1662
        int is_blob;
unknown's avatar
unknown committed
1663 1664
	if (!(field = mysql_fetch_field(res)))
	{
unknown's avatar
unknown committed
1665 1666
	  sprintf(query,"%s: Not enough fields from table %s! Aborting.\n",
		  my_progname, result_table);
unknown's avatar
unknown committed
1667
	  fputs(query,stderr);
1668 1669
	  error= EX_CONSCHECK;
	  goto err;
unknown's avatar
unknown committed
1670
	}
1671 1672 1673 1674
	
	/*
	   63 is my_charset_bin. If charsetnr is not 63,
	   we have not a BLOB but a TEXT column. 
unknown's avatar
unknown committed
1675
	   we'll dump in hex only BLOB columns.
1676 1677
	*/
        is_blob= (opt_hex_blob && field->charsetnr == 63 &&
unknown's avatar
unknown committed
1678
                  (field->type == FIELD_TYPE_STRING ||
unknown's avatar
unknown committed
1679
                   field->type == FIELD_TYPE_VAR_STRING ||
unknown's avatar
unknown committed
1680
                   field->type == FIELD_TYPE_BLOB ||
1681 1682 1683
                   field->type == FIELD_TYPE_LONG_BLOB ||
                   field->type == FIELD_TYPE_MEDIUM_BLOB ||
                   field->type == FIELD_TYPE_TINY_BLOB)) ? 1 : 0;
1684
	if (extended_insert)
unknown's avatar
unknown committed
1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
	{
	  ulong length = lengths[i];
	  if (i == 0)
	    dynstr_set(&extended_row,"(");
	  else
	    dynstr_append(&extended_row,",");

	  if (row[i])
	  {
	    if (length)
	    {
1696
	      if (!IS_NUM_FIELD(field))
unknown's avatar
unknown committed
1697
	      {
unknown's avatar
unknown committed
1698 1699 1700 1701 1702 1703 1704
	        /*
	          "length * 2 + 2" is OK for both HEX and non-HEX modes:
	          - In HEX mode we need exactly 2 bytes per character
	          plus 2 bytes for '0x' prefix.
	          - In non-HEX mode we need up to 2 bytes per character,
	          plus 2 bytes for leading and trailing '\'' characters.
	        */
unknown's avatar
unknown committed
1705 1706 1707
		if (dynstr_realloc(&extended_row,length * 2+2))
		{
		  fputs("Aborting dump (out of memory)",stderr);
1708 1709
		  error= EX_EOM;
		  goto err;
unknown's avatar
unknown committed
1710
		}
1711 1712 1713
                if (opt_hex_blob && is_blob)
                {
                  dynstr_append(&extended_row, "0x");
unknown's avatar
unknown committed
1714 1715 1716 1717
                  extended_row.length+= mysql_hex_string(extended_row.str + 
                                                         extended_row.length,
                                                         row[i], length);
                  extended_row.str[extended_row.length]= '\0';
1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
                }
                else
                {
                  dynstr_append(&extended_row,"'");
                  extended_row.length +=
                  mysql_real_escape_string(&mysql_connection,
                                           &extended_row.str[extended_row.length],
                                           row[i],length);
                  extended_row.str[extended_row.length]='\0';
                  dynstr_append(&extended_row,"'");
                }
unknown's avatar
unknown committed
1729 1730
	      }
	      else
1731
	      {
unknown's avatar
unknown committed
1732
		/* change any strings ("inf", "-inf", "nan") into NULL */
1733
		char *ptr = row[i];
unknown's avatar
unknown committed
1734 1735
		if (my_isalpha(charset_info, *ptr) || (*ptr == '-' &&
		    my_isalpha(charset_info, ptr[1])))
unknown's avatar
unknown committed
1736 1737 1738 1739 1740 1741
		  dynstr_append(&extended_row, "NULL");
		else
		{
		  if (field->type == FIELD_TYPE_DECIMAL)
		  {
		    /* add " signs around */
unknown's avatar
unknown committed
1742
		    dynstr_append(&extended_row, "'");
unknown's avatar
unknown committed
1743
		    dynstr_append(&extended_row, ptr);
unknown's avatar
unknown committed
1744
		    dynstr_append(&extended_row, "'");
unknown's avatar
unknown committed
1745 1746 1747 1748
		  }
		  else
		    dynstr_append(&extended_row, ptr);
		}
1749
	      }
unknown's avatar
unknown committed
1750 1751
	    }
	    else
unknown's avatar
unknown committed
1752
	      dynstr_append(&extended_row,"''");
unknown's avatar
unknown committed
1753 1754 1755 1756
	  }
	  else if (dynstr_append(&extended_row,"NULL"))
	  {
	    fputs("Aborting dump (out of memory)",stderr);
1757 1758
	    error= EX_EOM;
	    goto err;
unknown's avatar
unknown committed
1759 1760 1761 1762
	  }
	}
	else
	{
unknown's avatar
unknown committed
1763
	  if (i && !opt_xml)
1764
	  {
unknown's avatar
unknown committed
1765
	    fputc(',', md_result_file);
1766 1767
	    check_io(md_result_file);
	  }
unknown's avatar
unknown committed
1768 1769
	  if (row[i])
	  {
1770
	    if (!IS_NUM_FIELD(field))
1771
	    {
unknown's avatar
unknown committed
1772
	      if (opt_xml)
1773
	      {
1774 1775
	        print_xml_tag1(md_result_file, "\t\t", "field name=",
			      field->name, "");
1776 1777 1778
		print_quoted_xml(md_result_file, row[i], lengths[i]);
		fputs("</field>\n", md_result_file);
	      }
1779
	      else if (opt_hex_blob && is_blob)
unknown's avatar
unknown committed
1780 1781
              {
                /* sakaik got the idea to to provide blob's in hex notation. */
1782
                char *ptr= row[i], *end= ptr+ lengths[i];
1783
                fputs("0x", md_result_file);
unknown's avatar
unknown committed
1784 1785
                for (; ptr < end ; ptr++)
                  fprintf(md_result_file, "%02X", *ptr);
1786 1787 1788
              }
              else
                unescape(md_result_file, row[i], lengths[i]);
unknown's avatar
unknown committed
1789
	    }
unknown's avatar
unknown committed
1790
	    else
1791
	    {
unknown's avatar
unknown committed
1792
	      /* change any strings ("inf", "-inf", "nan") into NULL */
1793
	      char *ptr = row[i];
unknown's avatar
unknown committed
1794
	      if (opt_xml)
1795
	      {
1796 1797
	        print_xml_tag1(md_result_file, "\t\t", "field name=",
			       field->name, "");
1798 1799 1800 1801
		fputs(!my_isalpha(charset_info, *ptr) ? ptr: "NULL",
		      md_result_file);
		fputs("</field>\n", md_result_file);
	      }
unknown's avatar
unknown committed
1802 1803 1804 1805
	      else if (my_isalpha(charset_info, *ptr) ||
		       (*ptr == '-' && my_isalpha(charset_info, ptr[1])))
	        fputs("NULL", md_result_file);
	      else if (field->type == FIELD_TYPE_DECIMAL)
unknown's avatar
unknown committed
1806 1807
	      {
		/* add " signs around */
unknown's avatar
unknown committed
1808
		fputc('\'', md_result_file);
unknown's avatar
unknown committed
1809
		fputs(ptr, md_result_file);
unknown's avatar
unknown committed
1810
		fputc('\'', md_result_file);
unknown's avatar
unknown committed
1811
	      }
unknown's avatar
unknown committed
1812
	      else
unknown's avatar
unknown committed
1813
		fputs(ptr, md_result_file);
1814
	    }
unknown's avatar
unknown committed
1815
	  }
1816 1817
	  else
            fputs("NULL", md_result_file);
unknown's avatar
Merge  
unknown committed
1818
          check_io(md_result_file);
unknown's avatar
unknown committed
1819 1820 1821
	}
      }

unknown's avatar
merge  
unknown committed
1822
      if (opt_xml)
1823
      {
1824
        fputs("\t</row>\n", md_result_file);
1825 1826
	check_io(md_result_file);
      }
unknown's avatar
merge  
unknown committed
1827

1828
      if (extended_insert)
unknown's avatar
unknown committed
1829 1830 1831 1832
      {
	ulong row_length;
	dynstr_append(&extended_row,")");
        row_length = 2 + extended_row.length;
1833
        if (total_length + row_length < opt_net_buffer_length)
unknown's avatar
unknown committed
1834 1835
        {
	  total_length += row_length;
unknown's avatar
unknown committed
1836 1837
	  fputc(',',md_result_file);		/* Always row break */
	  fputs(extended_row.str,md_result_file);
unknown's avatar
unknown committed
1838 1839 1840
	}
        else
        {
1841
	  if (row_break)
unknown's avatar
unknown committed
1842
	    fputs(";\n", md_result_file);
unknown's avatar
unknown committed
1843
	  row_break=1;				/* This is first row */
unknown's avatar
unknown committed
1844

1845 1846
          fputs(insert_pat,md_result_file);
          fputs(extended_row.str,md_result_file);
unknown's avatar
unknown committed
1847 1848
	  total_length = row_length+init_length;
        }
1849
	check_io(md_result_file);
unknown's avatar
unknown committed
1850
      }
unknown's avatar
unknown committed
1851
      else if (!opt_xml)
1852
      {
unknown's avatar
unknown committed
1853
	fputs(");\n", md_result_file);
1854 1855
	check_io(md_result_file);
      }
unknown's avatar
unknown committed
1856
    }
unknown's avatar
unknown committed
1857

unknown's avatar
unknown committed
1858
    /* XML - close table tag and supress regular output */
unknown's avatar
unknown committed
1859
    if (opt_xml)
1860
	fputs("\t</table_data>\n", md_result_file);
unknown's avatar
unknown committed
1861
    else if (extended_insert && row_break)
unknown's avatar
unknown committed
1862 1863
      fputs(";\n", md_result_file);		/* If not empty table */
    fflush(md_result_file);
1864
    check_io(md_result_file);
unknown's avatar
unknown committed
1865 1866
    if (mysql_errno(sock))
    {
unknown's avatar
unknown committed
1867
      sprintf(query,"%s: Error %d: %s when dumping table %s at row: %ld\n",
unknown's avatar
unknown committed
1868 1869 1870
	      my_progname,
	      mysql_errno(sock),
	      mysql_error(sock),
unknown's avatar
unknown committed
1871
	      result_table,
unknown's avatar
unknown committed
1872 1873
	      rownr);
      fputs(query,stderr);
1874 1875
      error= EX_CONSCHECK;
      goto err;
unknown's avatar
unknown committed
1876 1877
    }
    if (opt_lock)
1878
    {
unknown's avatar
unknown committed
1879
      fputs("UNLOCK TABLES;\n", md_result_file);
1880 1881
      check_io(md_result_file);
    }
unknown's avatar
merge  
unknown committed
1882
    if (opt_disable_keys)
1883
    {
unknown's avatar
merge  
unknown committed
1884
      fprintf(md_result_file,"/*!40000 ALTER TABLE %s ENABLE KEYS */;\n",
unknown's avatar
unknown committed
1885
	      opt_quoted_table);
1886 1887
      check_io(md_result_file);
    }
unknown's avatar
unknown committed
1888
    if (opt_autocommit)
1889
    {
unknown's avatar
unknown committed
1890
      fprintf(md_result_file, "commit;\n");
1891 1892
      check_io(md_result_file);
    }
1893
    mysql_free_result(res);
1894 1895 1896 1897 1898 1899 1900 1901 1902 1903
    if (query != query_buf)
      my_free(query, MYF(MY_ALLOW_ZERO_PTR));
  } 
  return;

err:
  if (query != query_buf)
    my_free(query, MYF(MY_ALLOW_ZERO_PTR));
  safe_exit(error);
  return;
unknown's avatar
unknown committed
1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
} /* dumpTable */


static char *getTableName(int reset)
{
  static MYSQL_RES *res = NULL;
  MYSQL_ROW    row;

  if (!res)
  {
    if (!(res = mysql_list_tables(sock,NullS)))
      return(NULL);
  }
  if ((row = mysql_fetch_row(res)))
    return((char*) row[0]);
unknown's avatar
unknown committed
1919

unknown's avatar
unknown committed
1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936
  if (reset)
    mysql_data_seek(res,0);      /* We want to read again */
  else
  {
    mysql_free_result(res);
    res = NULL;
  }
  return(NULL);
} /* getTableName */


static int dump_all_databases()
{
  MYSQL_ROW row;
  MYSQL_RES *tableres;
  int result=0;

1937
  if (mysql_query_with_error_report(sock, &tableres, "SHOW DATABASES"))
unknown's avatar
unknown committed
1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952
    return 1;
  while ((row = mysql_fetch_row(tableres)))
  {
    if (dump_all_tables_in_db(row[0]))
      result=1;
  }
  return result;
}
/* dump_all_databases */


static int dump_databases(char **db_names)
{
  int result=0;
  for ( ; *db_names ; db_names++)
1953
  {
unknown's avatar
unknown committed
1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967
    if (dump_all_tables_in_db(*db_names))
      result=1;
  }
  return result;
} /* dump_databases */


static int init_dumping(char *database)
{
  if (mysql_select_db(sock, database))
  {
    DBerror(sock, "when selecting the database");
    return 1;			/* If --force */
  }
unknown's avatar
unknown committed
1968
  if (!path && !opt_xml)
unknown's avatar
unknown committed
1969 1970 1971
  {
    if (opt_databases || opt_alldbs)
    {
unknown's avatar
unknown committed
1972
      /*
unknown's avatar
unknown committed
1973
	length of table name * 2 (if name contains quotes), 2 quotes and 0
unknown's avatar
unknown committed
1974
      */
unknown's avatar
unknown committed
1975 1976
      char quoted_database_buf[64*2+3];
      char *qdatabase= quote_name(database,quoted_database_buf,opt_quoted);
1977
      if (opt_comments)
1978
      {
unknown's avatar
unknown committed
1979
	fprintf(md_result_file,"\n--\n-- Current Database: %s\n--\n", qdatabase);
1980 1981
	check_io(md_result_file);
      }
unknown's avatar
unknown committed
1982
      if (!opt_create_db)
1983
      {
unknown's avatar
unknown committed
1984
        char qbuf[256];
1985 1986
        MYSQL_ROW row;
        MYSQL_RES *dbinfo;
1987

1988
        sprintf(qbuf,"SHOW CREATE DATABASE IF NOT EXISTS %s",
unknown's avatar
unknown committed
1989
		qdatabase);
1990

1991
        if (mysql_query(sock, qbuf) || !(dbinfo = mysql_store_result(sock)))
1992 1993
        {
          /* Old server version, dump generic CREATE DATABASE */
1994
	  fprintf(md_result_file,
unknown's avatar
unknown committed
1995 1996
		  "\nCREATE DATABASE /*!32312 IF NOT EXISTS*/ %s;\n",
		  qdatabase);
1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
	}
	else
        {
	  row = mysql_fetch_row(dbinfo);
	  if (row[1])
	  {
	    fprintf(md_result_file,"\n%s;\n",row[1]);
          }
	}
      }
unknown's avatar
unknown committed
2007
      fprintf(md_result_file,"\nUSE %s;\n", qdatabase);
2008
      check_io(md_result_file);
unknown's avatar
unknown committed
2009 2010
    }
  }
unknown's avatar
unknown committed
2011 2012
  if (extended_insert && init_dynamic_string(&extended_row, "", 1024, 1024))
    exit(EX_EOM);
unknown's avatar
unknown committed
2013 2014 2015 2016
  return 0;
} /* init_dumping */


2017 2018
my_bool include_table(byte* hash_key, uint len)
{
unknown's avatar
unknown committed
2019
  if (hash_search(&ignore_table, (byte*) hash_key, len))
2020 2021 2022 2023 2024
    return FALSE;

  return TRUE;
}

unknown's avatar
unknown committed
2025

unknown's avatar
unknown committed
2026 2027 2028 2029
static int dump_all_tables_in_db(char *database)
{
  char *table;
  uint numrows;
unknown's avatar
unknown committed
2030
  char table_buff[NAME_LEN*2+3];
unknown's avatar
unknown committed
2031

2032 2033 2034 2035 2036 2037
  char hash_key[2*NAME_LEN+2];  /* "db.tablename" */
  char *afterdot;

  afterdot= strmov(hash_key, database);
  *afterdot++= '.';

unknown's avatar
unknown committed
2038 2039
  if (init_dumping(database))
    return 1;
unknown's avatar
unknown committed
2040
  if (opt_xml)
2041
    print_xml_tag1(md_result_file, "", "database name=", database, "\n");
unknown's avatar
unknown committed
2042 2043 2044 2045
  if (lock_tables)
  {
    DYNAMIC_STRING query;
    init_dynamic_string(&query, "LOCK TABLES ", 256, 1024);
2046
    for (numrows= 0 ; (table= getTableName(1)) ; numrows++)
unknown's avatar
unknown committed
2047
    {
unknown's avatar
unknown committed
2048
      dynstr_append(&query, quote_name(table, table_buff, 1));
unknown's avatar
unknown committed
2049 2050 2051
      dynstr_append(&query, " READ /*!32311 LOCAL */,");
    }
    if (numrows && mysql_real_query(sock, query.str, query.length-1))
unknown's avatar
unknown committed
2052
      DBerror(sock, "when using LOCK TABLES");
unknown's avatar
unknown committed
2053 2054 2055 2056 2057 2058
            /* We shall continue here, if --force was given */
    dynstr_free(&query);
  }
  if (flush_logs)
  {
    if (mysql_refresh(sock, REFRESH_LOG))
unknown's avatar
unknown committed
2059
      DBerror(sock, "when doing refresh");
unknown's avatar
unknown committed
2060 2061
           /* We shall continue here, if --force was given */
  }
2062
  while ((table= getTableName(0)))
unknown's avatar
unknown committed
2063
  {
2064 2065 2066 2067 2068 2069 2070 2071 2072
    char *end= strmov(afterdot, table);
    if (include_table(hash_key, end - hash_key))
    {
      numrows = getTableStructure(table, database);
      if (!dFlag && numrows > 0)
	dumpTable(numrows,table);
      my_free(order_by, MYF(MY_ALLOW_ZERO_PTR));
      order_by= 0;
    }
unknown's avatar
unknown committed
2073
  }
unknown's avatar
unknown committed
2074
  if (opt_xml)
2075
  {
2076
    fputs("</database>\n", md_result_file);
2077 2078
    check_io(md_result_file);
  }
unknown's avatar
unknown committed
2079
  if (lock_tables)
2080
    mysql_query_with_error_report(sock, 0, "UNLOCK TABLES");
unknown's avatar
unknown committed
2081 2082 2083 2084 2085 2086 2087 2088
  return 0;
} /* dump_all_tables_in_db */



static int dump_selected_tables(char *db, char **table_names, int tables)
{
  uint numrows;
unknown's avatar
unknown committed
2089
  char table_buff[NAME_LEN*+3];
unknown's avatar
unknown committed
2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100

  if (init_dumping(db))
    return 1;
  if (lock_tables)
  {
    DYNAMIC_STRING query;
    int i;

    init_dynamic_string(&query, "LOCK TABLES ", 256, 1024);
    for (i=0 ; i < tables ; i++)
    {
unknown's avatar
unknown committed
2101
      dynstr_append(&query, quote_name(table_names[i], table_buff, 1));
unknown's avatar
unknown committed
2102 2103 2104
      dynstr_append(&query, " READ /*!32311 LOCAL */,");
    }
    if (mysql_real_query(sock, query.str, query.length-1))
unknown's avatar
unknown committed
2105
      DBerror(sock, "when doing LOCK TABLES");
unknown's avatar
unknown committed
2106 2107 2108 2109 2110 2111
       /* We shall countinue here, if --force was given */
    dynstr_free(&query);
  }
  if (flush_logs)
  {
    if (mysql_refresh(sock, REFRESH_LOG))
unknown's avatar
unknown committed
2112
      DBerror(sock, "when doing refresh");
unknown's avatar
unknown committed
2113 2114
     /* We shall countinue here, if --force was given */
  }
unknown's avatar
unknown committed
2115
  if (opt_xml)
2116
    print_xml_tag1(md_result_file, "", "database name=", db, "\n");
unknown's avatar
unknown committed
2117 2118 2119 2120 2121
  for (; tables > 0 ; tables-- , table_names++)
  {
    numrows = getTableStructure(*table_names, db);
    if (!dFlag && numrows > 0)
      dumpTable(numrows, *table_names);
2122 2123
    my_free(order_by, MYF(MY_ALLOW_ZERO_PTR));
    order_by= 0;
unknown's avatar
unknown committed
2124
  }
unknown's avatar
unknown committed
2125
  if (opt_xml)
2126
  {
2127
    fputs("</database>\n", md_result_file);
2128 2129
    check_io(md_result_file);
  }
unknown's avatar
unknown committed
2130
  if (lock_tables)
2131
    mysql_query_with_error_report(sock, 0, "UNLOCK TABLES");
unknown's avatar
unknown committed
2132 2133 2134 2135
  return 0;
} /* dump_selected_tables */


2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169
static int do_show_master_status(MYSQL *mysql_con)
{
  MYSQL_ROW row;
  MYSQL_RES *master;
  const char *comment_prefix=
    (opt_master_data == MYSQL_OPT_MASTER_DATA_COMMENTED_SQL) ? "-- " : "";
  if (mysql_query_with_error_report(mysql_con, &master, "SHOW MASTER STATUS"))
  {
    my_printf_error(0, "Error: Couldn't execute 'SHOW MASTER STATUS': %s",
                    MYF(0), mysql_error(mysql_con));
    return 1;
  }
  else
  {
    row = mysql_fetch_row(master);
    if (row && row[0] && row[1])
    {
      if (opt_comments)
        fprintf(md_result_file,
                "\n--\n-- Position to start replication or point-in-time "
                "recovery from\n--\n\n");
      fprintf(md_result_file,
              "%sCHANGE MASTER TO MASTER_LOG_FILE='%s', MASTER_LOG_POS=%s;\n",
              comment_prefix, row[0], row[1]); 
      check_io(md_result_file);
    }
    mysql_free_result(master);
  }
  return 0;
}


static int do_flush_tables_read_lock(MYSQL *mysql_con)
{
2170 2171 2172 2173 2174 2175 2176 2177
  /*
    We do first a FLUSH TABLES. If a long update is running, the FLUSH TABLES
    will wait but will not stall the whole mysqld, and when the long update is
    done the FLUSH TABLES WITH READ LOCK will start and succeed quickly. So,
    FLUSH TABLES is to lower the probability of a stage where both mysqldump
    and most client connections are stalled. Of course, if a second long
    update starts between the two FLUSHes, we have that bad stall.
  */
2178
  return 
2179 2180 2181
    ( mysql_query_with_error_report(mysql_con, 0, "FLUSH TABLES") ||
      mysql_query_with_error_report(mysql_con, 0,
                                    "FLUSH TABLES WITH READ LOCK") );
2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
}


static int do_unlock_tables(MYSQL *mysql_con)
{
  return mysql_query_with_error_report(mysql_con, 0, "UNLOCK TABLES");
}


static int do_reset_master(MYSQL *mysql_con)
{
  return mysql_query_with_error_report(mysql_con, 0, "RESET MASTER");
}


static int start_transaction(MYSQL *mysql_con, my_bool consistent_read_now)
{
  /*
    We use BEGIN for old servers. --single-transaction --master-data will fail
    on old servers, but that's ok as it was already silently broken (it didn't
    do a consistent read, so better tell people frankly, with the error).
2203 2204 2205 2206

    We want the first consistent read to be used for all tables to dump so we
    need the REPEATABLE READ level (not anything lower, for example READ
    COMMITTED would give one new consistent read per dumped table).
2207 2208
  */
  return (mysql_query_with_error_report(mysql_con, 0,
2209 2210 2211
                                        "SET SESSION TRANSACTION ISOLATION "
                                        "LEVEL REPEATABLE READ") ||
          mysql_query_with_error_report(mysql_con, 0,
2212 2213 2214 2215 2216 2217
                                        consistent_read_now ?
                                        "START TRANSACTION "
                                        "WITH CONSISTENT SNAPSHOT" :
                                        "BEGIN"));
}

2218 2219 2220 2221 2222 2223 2224 2225 2226

static ulong find_set(TYPELIB *lib, const char *x, uint length,
		      char **err_pos, uint *err_len)
{
  const char *end= x + length;
  ulong found= 0;
  uint find;
  char buff[255];

2227
  *err_pos= 0;                  /* No error yet */
2228
  while (end > x && my_isspace(charset_info, end[-1]))
2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259
    end--;

  *err_len= 0;
  if (x != end)
  {
    const char *start= x;
    for (;;)
    {
      const char *pos= start;
      uint var_len;

      for (; pos != end && *pos != ','; pos++) ;
      var_len= (uint) (pos - start);
      strmake(buff, start, min(sizeof(buff), var_len));
      find= find_type(buff, lib, var_len);
      if (!find)
      {
        *err_pos= (char*) start;
        *err_len= var_len;
      }
      else
        found|= ((longlong) 1 << (find - 1));
      if (pos == end)
        break;
      start= pos + 1;
    }
  }
  return found;
}


unknown's avatar
unknown committed
2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276
/* Print a value with a prefix on file */
static void print_value(FILE *file, MYSQL_RES  *result, MYSQL_ROW row,
			const char *prefix, const char *name,
			int string_value)
{
  MYSQL_FIELD	*field;
  mysql_field_seek(result, 0);

  for ( ; (field = mysql_fetch_field(result)) ; row++)
  {
    if (!strcmp(field->name,name))
    {
      if (row[0] && row[0][0] && strcmp(row[0],"0")) /* Skip default */
      {
	fputc(' ',file);
	fputs(prefix, file);
	if (string_value)
unknown's avatar
unknown committed
2277
	  unescape(file,row[0],(uint) strlen(row[0]));
unknown's avatar
unknown committed
2278 2279
	else
	  fputs(row[0], file);
2280
	check_io(file);
unknown's avatar
unknown committed
2281 2282 2283 2284 2285 2286 2287 2288
	return;
      }
    }
  }
  return;					/* This shouldn't happen */
} /* print_value */


2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314
/*
  Check if we the table is one of the table types that should be ignored:
  MRG_ISAM, MRG_MYISAM

  SYNOPSIS
    check_if_ignore_table()
    table_name			Table name to check

  GLOBAL VARIABLES
    sock			MySQL socket
    verbose			Write warning messages

  RETURN
    0	Table should be backuped
    #	Type of table (that should be skipped)
*/

static const char *check_if_ignore_table(const char *table_name)
{
  char buff[FN_REFLEN+80], show_name_buff[FN_REFLEN];
  MYSQL_RES *res;
  MYSQL_ROW row;
  const char *result= 0;

  sprintf(buff,"show table status like %s",
	  quote_for_like(table_name, show_name_buff));
2315
  if (mysql_query_with_error_report(sock, &res, buff))
2316 2317 2318 2319 2320 2321 2322 2323 2324 2325
  {
    if (mysql_errno(sock) != ER_PARSE_ERROR)
    {					/* If old MySQL version */
      if (verbose)
	fprintf(stderr,
		"-- Warning: Couldn't get status information for table %s (%s)\n",
		table_name,mysql_error(sock));
      return 0;					/* assume table is ok */
    }
  }
2326
  if (!(row= mysql_fetch_row(res)))
2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341
  {
    fprintf(stderr,
	    "Error: Couldn't read status information for table %s (%s)\n",
	    table_name, mysql_error(sock));
    if (res)
      mysql_free_result(res);
    return 0;					/* assume table is ok */
  }
  if (strcmp(row[1], (result= "MRG_MyISAM")) &&
      strcmp(row[1], (result= "MRG_ISAM")))
    result= 0;
  mysql_free_result(res);  
  return result;
}

2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
/*
  Get string of comma-separated primary key field names

  SYNOPSIS
    char *primary_key_fields(const char *table_name)
    RETURNS     pointer to allocated buffer (must be freed by caller)
    table_name  quoted table name

  DESCRIPTION
    Use SHOW KEYS FROM table_name, allocate a buffer to hold the
    field names, and then build that string and return the pointer
    to that buffer.

    Returns NULL if there is no PRIMARY or UNIQUE key on the table,
    or if there is some failure.  It is better to continue to dump
    the table unsorted, rather than exit without dumping the data.
*/
static char *primary_key_fields(const char *table_name)
{
  MYSQL_RES  *res = NULL;
  MYSQL_ROW  row;
  /* SHOW KEYS FROM + table name * 2 (escaped) + 2 quotes + \0 */
  char show_keys_buff[15 + 64 * 2 + 3];
unknown's avatar
unknown committed
2365
  uint result_length = 0;
2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378
  char *result = 0;

  sprintf(show_keys_buff, "SHOW KEYS FROM %s", table_name);
  if (mysql_query(sock, show_keys_buff) ||
      !(res = mysql_store_result(sock)))
  {
    fprintf(stderr, "Warning: Couldn't read keys from table %s;"
            " records are NOT sorted (%s)\n",
            table_name, mysql_error(sock));
    /* Don't exit, because it's better to print out unsorted records */
    goto cleanup;
  }

unknown's avatar
unknown committed
2379 2380 2381 2382 2383 2384 2385
  /*
   * Figure out the length of the ORDER BY clause result.
   * Note that SHOW KEYS is ordered:  a PRIMARY key is always the first
   * row, and UNIQUE keys come before others.  So we only need to check
   * the first key, not all keys.
   */
  if ((row = mysql_fetch_row(res)) && atoi(row[1]) == 0)
2386
  {
unknown's avatar
unknown committed
2387 2388 2389 2390
    /* Key is unique */
    do
      result_length += strlen(row[4]) + 1;      /* + 1 for ',' or \0 */
    while ((row = mysql_fetch_row(res)) && atoi(row[3]) > 1);
2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401
  }

  /* Build the ORDER BY clause result */
  if (result_length) {
    char *end;
    /* result (terminating \0 is already in result_length) */
    result = my_malloc(result_length + 10, MYF(MY_WME));
    if (!result) {
      fprintf(stderr, "Error: Not enough memory to store ORDER BY clause\n");
      goto cleanup;
    }
unknown's avatar
unknown committed
2402
    mysql_data_seek(res, 0);
2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
    row = mysql_fetch_row(res);
    end = strmov(result, row[4]);
    while ((row = mysql_fetch_row(res)) && atoi(row[3]) > 1)
      end = strxmov(end, ",", row[4], NullS);
  }

cleanup:
  if (res)
    mysql_free_result(res);

  return result;
}

2416

unknown's avatar
unknown committed
2417 2418
int main(int argc, char **argv)
{
2419
  compatible_mode_normal_str[0]= 0;
2420
  default_charset= (char *)mysql_universal_client_charset;
unknown's avatar
unknown committed
2421

unknown's avatar
unknown committed
2422 2423 2424 2425 2426 2427
  MY_INIT(argv[0]);
  if (get_options(&argc, &argv))
  {
    my_end(0);
    exit(EX_USAGE);
  }
2428
  if (dbConnect(current_host, current_user, opt_password))
unknown's avatar
unknown committed
2429 2430
    exit(EX_MYSQLERR);
  if (!path)
2431 2432
    write_header(md_result_file, *argv);

2433 2434 2435 2436 2437 2438 2439 2440
  if ((opt_lock_all_tables || opt_master_data) &&
      do_flush_tables_read_lock(sock))
    goto err;
  if (opt_single_transaction && start_transaction(sock, test(opt_master_data)))
      goto err;
  if (opt_delete_master_logs && do_reset_master(sock))
    goto err;
  if (opt_lock_all_tables || opt_master_data)
2441
  {
2442 2443 2444
    if (flush_logs && mysql_refresh(sock, REFRESH_LOG))
      goto err;
    flush_logs= 0; /* not anymore; that would not be sensible */
2445
  }
2446 2447
  if (opt_master_data && do_show_master_status(sock))
    goto err;
2448
  if (opt_single_transaction && do_unlock_tables(sock)) /* unlock but no commit! */
2449 2450
    goto err;

unknown's avatar
unknown committed
2451 2452 2453
  if (opt_alldbs)
    dump_all_databases();
  else if (argc > 1 && !opt_databases)
2454 2455
  {
    /* Only one database and selected table(s) */
unknown's avatar
unknown committed
2456
    dump_selected_tables(*argv, (argv + 1), (argc - 1));
2457
  }
unknown's avatar
unknown committed
2458
  else
2459 2460
  {
    /* One or more databases, all tables */
unknown's avatar
unknown committed
2461
    dump_databases(argv);
2462
  }
2463 2464 2465
#ifdef HAVE_SMEM
  my_free(shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
#endif
2466 2467 2468 2469 2470 2471 2472
  /*
    No reason to explicitely COMMIT the transaction, neither to explicitely
    UNLOCK TABLES: these will be automatically be done by the server when we
    disconnect now. Saves some code here, some network trips, adds nothing to
    server.
  */
err:
unknown's avatar
unknown committed
2473
  dbDisconnect(current_host);
2474 2475
  if (!path)
    write_footer(md_result_file);
unknown's avatar
unknown committed
2476 2477
  if (md_result_file != stdout)
    my_fclose(md_result_file, MYF(0));
2478
  my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));
2479
  if (extended_insert)
unknown's avatar
unknown committed
2480 2481 2482 2483
    dynstr_free(&extended_row);
  my_end(0);
  return(first_error);
} /* main */