← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzledump.cc

Updated an include guard thanks to a nice catch during code review from Jay. Thanks Jay!

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzledump.cc
1
1
/* Copyright 2000-2008 MySQL AB, 2008, 2009 Sun Microsystems, Inc.
2
2
 
3
 
  This program is free software; you can redistribute it and/or modify
4
 
  it under the terms of the GNU General Public License as published by
5
 
  the Free Software Foundation; version 2 of the License.
6
 
 
7
 
  This program is distributed in the hope that it will be useful,
8
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
  GNU General Public License for more details.
11
 
 
12
 
  You should have received a copy of the GNU General Public License
13
 
  along with this program; if not, write to the Free Software
14
 
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* drizzledump.cc  - Dump a tables contents and format to an ASCII file
17
17
 
18
18
 * Derived from mysqldump, which originally came from:
19
 
 **
20
 
 ** The author's original notes follow :-
21
 
 **
22
 
 ** AUTHOR: Igor Romanenko (igor@frog.kiev.ua)
23
 
 ** DATE:   December 3, 1994
24
 
 ** WARRANTY: None, expressed, impressed, implied
25
 
 **          or other
26
 
 ** STATUS: Public domain
 
19
**
 
20
** The author's original notes follow :-
 
21
**
 
22
** AUTHOR: Igor Romanenko (igor@frog.kiev.ua)
 
23
** DATE:   December 3, 1994
 
24
** WARRANTY: None, expressed, impressed, implied
 
25
**          or other
 
26
** STATUS: Public domain
27
27
 
28
 
 * and more work by Monty, Jani & Sinisa
29
 
 * and all the MySQL developers over the years.
 
28
* and more work by Monty, Jani & Sinisa
 
29
* and all the MySQL developers over the years.
30
30
*/
31
31
 
32
32
#include "client_priv.h"
33
33
#include <string>
34
34
 
35
 
#include "drizzled/internal/my_sys.h"
36
 
#include "drizzled/internal/m_string.h"
37
 
#include "drizzled/charset_info.h"
 
35
#include <mysys/my_sys.h>
 
36
#include <mystrings/m_string.h>
 
37
#include <mystrings/m_ctype.h>
38
38
#include "drizzled/hash.h"
39
39
#include <stdarg.h>
40
40
#include <algorithm>
44
44
#include <drizzled/error.h>
45
45
 
46
46
using namespace std;
47
 
using namespace drizzled;
48
47
 
49
48
/* Exit codes */
50
49
 
76
75
static void add_load_option(string &str, const char *option,
77
76
                            const char *option_value);
78
77
static uint32_t find_set(TYPELIB *lib, const char *x, uint32_t length,
79
 
                         char **err_pos, uint32_t *err_len);
 
78
                         char **err_pos, uint32_t *err_len);
80
79
 
81
80
static void field_escape(string &in, const char *from);
82
81
static bool  verbose= false;
83
82
static bool opt_no_create_info= false;
84
83
static bool opt_no_data= false;
85
 
static bool opt_mysql= false;
86
84
static bool quick= true;
87
85
static bool extended_insert= true;
88
86
static bool ignore_errors= false;
151
149
  NULL
152
150
};
153
151
static TYPELIB compatible_mode_typelib= {array_elements(compatible_mode_names) - 1,
154
 
  "", compatible_mode_names, NULL};
 
152
                                  "", compatible_mode_names, NULL};
155
153
 
156
154
drizzled::hash_set<string> ignore_table;
157
155
 
158
 
static struct option my_long_options[] =
 
156
static struct my_option my_long_options[] =
159
157
{
160
158
  {"all", 'a', "Deprecated. Use --create-options instead.",
161
 
    (char**) &create_options, (char**) &create_options, 0, GET_BOOL, NO_ARG, 1,
162
 
    0, 0, 0, 0, 0},
 
159
   (char**) &create_options, (char**) &create_options, 0, GET_BOOL, NO_ARG, 1,
 
160
   0, 0, 0, 0, 0},
163
161
  {"all-databases", 'A',
164
 
    "Dump all the databases. This will be same as --databases with all databases selected.",
165
 
    (char**) &opt_alldbs, (char**) &opt_alldbs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
166
 
    0, 0},
 
162
   "Dump all the databases. This will be same as --databases with all databases selected.",
 
163
   (char**) &opt_alldbs, (char**) &opt_alldbs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
164
   0, 0},
167
165
  {"all-tablespaces", 'Y',
168
 
    "Dump all the tablespaces.",
169
 
    (char**) &opt_alltspcs, (char**) &opt_alltspcs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
170
 
    0, 0},
 
166
   "Dump all the tablespaces.",
 
167
   (char**) &opt_alltspcs, (char**) &opt_alltspcs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
168
   0, 0},
171
169
  {"add-drop-database", OPT_DROP_DATABASE, "Add a 'DROP DATABASE' before each create.",
172
 
    (char**) &opt_drop_database, (char**) &opt_drop_database, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,
173
 
    0},
 
170
   (char**) &opt_drop_database, (char**) &opt_drop_database, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,
 
171
   0},
174
172
  {"add-drop-table", OPT_DROP, "Add a 'drop table' before each create.",
175
 
    (char**) &opt_drop, (char**) &opt_drop, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0,
176
 
    0},
 
173
   (char**) &opt_drop, (char**) &opt_drop, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0,
 
174
   0},
177
175
  {"allow-keywords", OPT_KEYWORDS,
178
 
    "Allow creation of column names that are keywords.", (char**) &opt_keywords,
179
 
    (char**) &opt_keywords, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
176
   "Allow creation of column names that are keywords.", (char**) &opt_keywords,
 
177
   (char**) &opt_keywords, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
180
178
  {"comments", 'i', "Write additional information.",
181
 
    (char**) &opt_comments, (char**) &opt_comments, 0, GET_BOOL, NO_ARG,
182
 
    1, 0, 0, 0, 0, 0},
 
179
   (char**) &opt_comments, (char**) &opt_comments, 0, GET_BOOL, NO_ARG,
 
180
   1, 0, 0, 0, 0, 0},
183
181
  {"compatible", OPT_COMPATIBLE,
184
 
    "Change the dump to be compatible with a given mode. By default tables are dumped in a format optimized for MySQL. Legal modes are: ansi, mysql323, mysql40, postgresql, oracle, mssql, db2, maxdb, no_key_options, no_table_options, no_field_options. One can use several modes separated by commas. Note: Requires DRIZZLE server version 4.1.0 or higher. This option is ignored with earlier server versions.",
185
 
    (char**) &opt_compatible_mode_str, (char**) &opt_compatible_mode_str, 0,
186
 
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
182
   "Change the dump to be compatible with a given mode. By default tables are dumped in a format optimized for MySQL. Legal modes are: ansi, mysql323, mysql40, postgresql, oracle, mssql, db2, maxdb, no_key_options, no_table_options, no_field_options. One can use several modes separated by commas. Note: Requires DRIZZLE server version 4.1.0 or higher. This option is ignored with earlier server versions.",
 
183
   (char**) &opt_compatible_mode_str, (char**) &opt_compatible_mode_str, 0,
 
184
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
187
185
  {"compact", OPT_COMPACT,
188
 
    "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",
189
 
    (char**) &opt_compact, (char**) &opt_compact, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
190
 
    0, 0},
 
186
   "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",
 
187
   (char**) &opt_compact, (char**) &opt_compact, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
188
   0, 0},
191
189
  {"complete-insert", 'c', "Use complete insert statements.",
192
 
    (char**) &opt_complete_insert, (char**) &opt_complete_insert, 0, GET_BOOL,
193
 
    NO_ARG, 0, 0, 0, 0, 0, 0},
 
190
   (char**) &opt_complete_insert, (char**) &opt_complete_insert, 0, GET_BOOL,
 
191
   NO_ARG, 0, 0, 0, 0, 0, 0},
194
192
  {"compress", 'C', "Use compression in server/client protocol.",
195
 
    (char**) &opt_compress, (char**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
196
 
    0, 0, 0},
 
193
   (char**) &opt_compress, (char**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
 
194
   0, 0, 0},
197
195
  {"create-options", OPT_CREATE_OPTIONS,
198
 
    "Include all DRIZZLE specific create options.",
199
 
    (char**) &create_options, (char**) &create_options, 0, GET_BOOL, NO_ARG, 1,
200
 
    0, 0, 0, 0, 0},
 
196
   "Include all DRIZZLE specific create options.",
 
197
   (char**) &create_options, (char**) &create_options, 0, GET_BOOL, NO_ARG, 1,
 
198
   0, 0, 0, 0, 0},
201
199
  {"databases", 'B',
202
 
    "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.",
203
 
    (char**) &opt_databases, (char**) &opt_databases, 0, GET_BOOL, NO_ARG, 0, 0,
204
 
    0, 0, 0, 0},
 
200
   "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.",
 
201
   (char**) &opt_databases, (char**) &opt_databases, 0, GET_BOOL, NO_ARG, 0, 0,
 
202
   0, 0, 0, 0},
205
203
  {"delayed-insert", OPT_DELAYED, "Insert rows with INSERT DELAYED; ",
206
 
    (char**) &opt_delayed, (char**) &opt_delayed, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
207
 
    0, 0},
 
204
   (char**) &opt_delayed, (char**) &opt_delayed, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
205
   0, 0},
208
206
  {"disable-keys", 'K',
209
 
    "'ALTER TABLE tb_name DISABLE KEYS; and 'ALTER TABLE tb_name ENABLE KEYS; will be put in the output.", (char**) &opt_disable_keys,
210
 
    (char**) &opt_disable_keys, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
 
207
   "'ALTER TABLE tb_name DISABLE KEYS; and 'ALTER TABLE tb_name ENABLE KEYS; will be put in the output.", (char**) &opt_disable_keys,
 
208
   (char**) &opt_disable_keys, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
211
209
  {"extended-insert", 'e',
212
 
    "Allows utilization of the new, much faster INSERT syntax.",
213
 
    (char**) &extended_insert, (char**) &extended_insert, 0, GET_BOOL, NO_ARG,
214
 
    1, 0, 0, 0, 0, 0},
 
210
   "Allows utilization of the new, much faster INSERT syntax.",
 
211
   (char**) &extended_insert, (char**) &extended_insert, 0, GET_BOOL, NO_ARG,
 
212
   1, 0, 0, 0, 0, 0},
215
213
  {"fields-terminated-by", OPT_FTB,
216
 
    "Fields in the textfile are terminated by ...", (char**) &fields_terminated,
217
 
    (char**) &fields_terminated, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
214
   "Fields in the textfile are terminated by ...", (char**) &fields_terminated,
 
215
   (char**) &fields_terminated, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
218
216
  {"fields-enclosed-by", OPT_ENC,
219
 
    "Fields in the importfile are enclosed by ...", (char**) &enclosed,
220
 
    (char**) &enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0 ,0, 0},
 
217
   "Fields in the importfile are enclosed by ...", (char**) &enclosed,
 
218
   (char**) &enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0 ,0, 0},
221
219
  {"fields-optionally-enclosed-by", OPT_O_ENC,
222
 
    "Fields in the i.file are opt. enclosed by ...", (char**) &opt_enclosed,
223
 
    (char**) &opt_enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0 ,0, 0},
 
220
   "Fields in the i.file are opt. enclosed by ...", (char**) &opt_enclosed,
 
221
   (char**) &opt_enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0 ,0, 0},
224
222
  {"fields-escaped-by", OPT_ESC, "Fields in the i.file are escaped by ...",
225
 
    (char**) &escaped, (char**) &escaped, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
223
   (char**) &escaped, (char**) &escaped, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
226
224
  {"flush-logs", 'F', "Flush logs file in server before starting dump. "
227
 
    "Note that if you dump many databases at once (using the option "
228
 
      "--databases= or --all-databases), the logs will be flushed for "
229
 
      "each database dumped. The exception is when using --lock-all-tables "
230
 
      "in this case the logs will be flushed only once, corresponding "
231
 
      "to the moment all tables are locked. So if you want your dump and "
232
 
      "the log flush to happen at the same exact moment you should use "
233
 
      "--lock-all-tables or --flush-logs",
234
 
    (char**) &flush_logs, (char**) &flush_logs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
235
 
    0, 0},
 
225
   "Note that if you dump many databases at once (using the option "
 
226
   "--databases= or --all-databases), the logs will be flushed for "
 
227
   "each database dumped. The exception is when using --lock-all-tables "
 
228
   "in this case the logs will be flushed only once, corresponding "
 
229
   "to the moment all tables are locked. So if you want your dump and "
 
230
   "the log flush to happen at the same exact moment you should use "
 
231
   "--lock-all-tables or --flush-logs",
 
232
   (char**) &flush_logs, (char**) &flush_logs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
233
   0, 0},
236
234
  {"force", 'f', "Continue even if we get an sql-error.",
237
 
    (char**) &ignore_errors, (char**) &ignore_errors, 0, GET_BOOL, NO_ARG,
238
 
    0, 0, 0, 0, 0, 0},
 
235
   (char**) &ignore_errors, (char**) &ignore_errors, 0, GET_BOOL, NO_ARG,
 
236
   0, 0, 0, 0, 0, 0},
239
237
  {"help", '?', "Display this help message and exit.", 0, 0, 0, GET_NO_ARG,
240
 
    NO_ARG, 0, 0, 0, 0, 0, 0},
 
238
   NO_ARG, 0, 0, 0, 0, 0, 0},
241
239
  {"hex-blob", OPT_HEXBLOB, "Dump binary strings (BINARY, "
242
240
    "VARBINARY, BLOB) in hexadecimal format.",
243
 
    (char**) &opt_hex_blob, (char**) &opt_hex_blob, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
241
   (char**) &opt_hex_blob, (char**) &opt_hex_blob, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
244
242
  {"host", 'h', "Connect to host.", (char**) &current_host,
245
 
    (char**) &current_host, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
243
   (char**) &current_host, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
246
244
  {"ignore-table", OPT_IGNORE_TABLE,
247
 
    "Do not dump the specified table. To specify more than one table to ignore, "
248
 
      "use the directive multiple times, once for each table.  Each table must "
249
 
      "be specified with both database and table names, e.g. --ignore-table=database.table",
250
 
    0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
245
   "Do not dump the specified table. To specify more than one table to ignore, "
 
246
   "use the directive multiple times, once for each table.  Each table must "
 
247
   "be specified with both database and table names, e.g. --ignore-table=database.table",
 
248
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
251
249
  {"insert-ignore", OPT_INSERT_IGNORE, "Insert rows with INSERT IGNORE.",
252
 
    (char**) &opt_ignore, (char**) &opt_ignore, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
253
 
    0, 0},
 
250
   (char**) &opt_ignore, (char**) &opt_ignore, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
251
   0, 0},
254
252
  {"lines-terminated-by", OPT_LTB, "Lines in the i.file are terminated by ...",
255
 
    (char**) &lines_terminated, (char**) &lines_terminated, 0, GET_STR,
256
 
    REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
253
   (char**) &lines_terminated, (char**) &lines_terminated, 0, GET_STR,
 
254
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
257
255
  {"lock-all-tables", 'x', "Locks all tables across all databases. This "
258
 
    "is achieved by taking a global read lock for the duration of the whole "
259
 
      "dump. Automatically turns --single-transaction and --lock-tables off.",
260
 
    (char**) &opt_lock_all_tables, (char**) &opt_lock_all_tables, 0, GET_BOOL, NO_ARG,
261
 
    0, 0, 0, 0, 0, 0},
262
 
  {"mysql", 'm', N_("Use MySQL Protocol."),
263
 
    (char**) &opt_mysql, (char**) &opt_mysql, 0, GET_BOOL, NO_ARG, 1, 0, 0,
264
 
    0, 0, 0},
 
256
   "is achieved by taking a global read lock for the duration of the whole "
 
257
   "dump. Automatically turns --single-transaction and --lock-tables off.",
 
258
   (char**) &opt_lock_all_tables, (char**) &opt_lock_all_tables, 0, GET_BOOL, NO_ARG,
 
259
   0, 0, 0, 0, 0, 0},
265
260
  {"no-autocommit", OPT_AUTOCOMMIT,
266
 
    "Wrap tables with autocommit/commit statements.",
267
 
    (char**) &opt_autocommit, (char**) &opt_autocommit, 0, GET_BOOL, NO_ARG,
268
 
    0, 0, 0, 0, 0, 0},
 
261
   "Wrap tables with autocommit/commit statements.",
 
262
   (char**) &opt_autocommit, (char**) &opt_autocommit, 0, GET_BOOL, NO_ARG,
 
263
   0, 0, 0, 0, 0, 0},
269
264
  {"no-create-db", 'n',
270
 
    "'CREATE DATABASE IF NOT EXISTS db_name;' will not be put in the output. The above line will be added otherwise, if --databases or --all-databases option was given.}.",
271
 
    (char**) &opt_create_db, (char**) &opt_create_db, 0, GET_BOOL, NO_ARG, 0, 0,
272
 
    0, 0, 0, 0},
 
265
   "'CREATE DATABASE IF NOT EXISTS db_name;' will not be put in the output. The above line will be added otherwise, if --databases or --all-databases option was given.}.",
 
266
   (char**) &opt_create_db, (char**) &opt_create_db, 0, GET_BOOL, NO_ARG, 0, 0,
 
267
   0, 0, 0, 0},
273
268
  {"no-create-info", 't', "Don't write table creation info.",
274
 
    (char**) &opt_no_create_info, (char**) &opt_no_create_info, 0, GET_BOOL,
275
 
    NO_ARG, 0, 0, 0, 0, 0, 0},
 
269
   (char**) &opt_no_create_info, (char**) &opt_no_create_info, 0, GET_BOOL,
 
270
   NO_ARG, 0, 0, 0, 0, 0, 0},
276
271
  {"no-data", 'd', "No row information.", (char**) &opt_no_data,
277
 
    (char**) &opt_no_data, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
272
   (char**) &opt_no_data, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
278
273
  {"no-set-names", 'N',
279
 
    "Deprecated. Use --skip-set-charset instead.",
280
 
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
274
   "Deprecated. Use --skip-set-charset instead.",
 
275
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
281
276
  {"opt", OPT_OPTIMIZE,
282
 
    "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.",
283
 
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
277
   "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.",
 
278
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
284
279
  {"order-by-primary", OPT_ORDER_BY_PRIMARY,
285
 
    "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.",
286
 
    (char**) &opt_order_by_primary, (char**) &opt_order_by_primary, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
280
   "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.",
 
281
   (char**) &opt_order_by_primary, (char**) &opt_order_by_primary, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
287
282
  {"password", 'P',
288
 
    "Password to use when connecting to server. If password is not given it's solicited on the tty.",
289
 
    0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
283
   "Password to use when connecting to server. If password is not given it's solicited on the tty.",
 
284
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
290
285
  {"port", 'p', "Port number to use for connection.", 
291
 
    0, 0, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
286
   0, 0, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
292
287
  {"quick", 'q', "Don't buffer query, dump directly to stdout.",
293
 
    (char**) &quick, (char**) &quick, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
 
288
   (char**) &quick, (char**) &quick, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
294
289
  {"quote-names",'Q', "Quote table and column names with backticks (`).",
295
 
    (char**) &opt_quoted, (char**) &opt_quoted, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0,
296
 
    0, 0},
 
290
   (char**) &opt_quoted, (char**) &opt_quoted, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0,
 
291
   0, 0},
297
292
  {"replace", OPT_DRIZZLE_REPLACE_INTO, "Use REPLACE INTO instead of INSERT INTO.",
298
 
    (char**) &opt_replace_into, (char**) &opt_replace_into, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
299
 
    0, 0},
 
293
   (char**) &opt_replace_into, (char**) &opt_replace_into, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
 
294
   0, 0},
300
295
  {"result-file", 'r',
301
 
    "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).",
302
 
    0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
296
   "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).",
 
297
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
303
298
  {"routines", 'R', "Dump stored routines (functions and procedures).",
304
 
    (char**) &opt_routines, (char**) &opt_routines, 0, GET_BOOL,
305
 
    NO_ARG, 0, 0, 0, 0, 0, 0},
 
299
     (char**) &opt_routines, (char**) &opt_routines, 0, GET_BOOL,
 
300
     NO_ARG, 0, 0, 0, 0, 0, 0},
306
301
  {"single-transaction", OPT_TRANSACTION,
307
 
    "Creates a consistent snapshot by dumping all tables in a single "
308
 
      "transaction. Works ONLY for tables stored in storage engines which "
309
 
      "support multiversioning (currently only InnoDB does); the dump is NOT "
310
 
      "guaranteed to be consistent for other storage engines. "
311
 
      "While a --single-transaction dump is in process, to ensure a valid "
312
 
      "dump file (correct table contents), no other "
313
 
      "connection should use the following statements: ALTER TABLE, DROP "
314
 
      "TABLE, RENAME TABLE, TRUNCATE TABLE, as consistent snapshot is not "
315
 
      "isolated from them. Option automatically turns off --lock-tables.",
316
 
    (char**) &opt_single_transaction, (char**) &opt_single_transaction, 0,
317
 
    GET_BOOL, NO_ARG,  0, 0, 0, 0, 0, 0},
 
302
   "Creates a consistent snapshot by dumping all tables in a single "
 
303
   "transaction. Works ONLY for tables stored in storage engines which "
 
304
   "support multiversioning (currently only InnoDB does); the dump is NOT "
 
305
   "guaranteed to be consistent for other storage engines. "
 
306
   "While a --single-transaction dump is in process, to ensure a valid "
 
307
   "dump file (correct table contents), no other "
 
308
   "connection should use the following statements: ALTER TABLE, DROP "
 
309
   "TABLE, RENAME TABLE, TRUNCATE TABLE, as consistent snapshot is not "
 
310
   "isolated from them. Option automatically turns off --lock-tables.",
 
311
   (char**) &opt_single_transaction, (char**) &opt_single_transaction, 0,
 
312
   GET_BOOL, NO_ARG,  0, 0, 0, 0, 0, 0},
318
313
  {"dump-date", OPT_DUMP_DATE, "Put a dump date to the end of the output.",
319
 
    (char**) &opt_dump_date, (char**) &opt_dump_date, 0,
320
 
    GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
 
314
   (char**) &opt_dump_date, (char**) &opt_dump_date, 0,
 
315
   GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
321
316
  {"skip-opt", OPT_SKIP_OPTIMIZATION,
322
 
    "Disable --opt. Disables --add-drop-table, --add-locks, --create-options, --quick, --extended-insert, --lock-tables, --set-charset, and --disable-keys.",
323
 
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
317
   "Disable --opt. Disables --add-drop-table, --add-locks, --create-options, --quick, --extended-insert, --lock-tables, --set-charset, and --disable-keys.",
 
318
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
324
319
  {"tab",'T',
325
 
    "Creates tab separated textfile for each table to given path. (creates .sql and .txt files). NOTE: This only works if drizzledump is run on the same machine as the drizzled daemon.",
326
 
    (char**) &path, (char**) &path, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
320
   "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.",
 
321
   (char**) &path, (char**) &path, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
327
322
  {"tables", OPT_TABLES, "Overrides option --databases (-B).",
328
 
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
323
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
329
324
  {"show-progress-size", OPT_SHOW_PROGRESS_SIZE, N_("Number of rows before each output progress report (requires --verbose)."),
330
 
    (char**) &show_progress_size, (char**) &show_progress_size, 0, GET_UINT32, REQUIRED_ARG,
331
 
    10000, 0, 0, 0, 0, 0},
 
325
   (char**) &show_progress_size, (char**) &show_progress_size, 0, GET_UINT32, REQUIRED_ARG,
 
326
   10000, 0, 0, 0, 0, 0},
332
327
  {"user", 'u', "User for login if not current user.",
333
 
    (char**) &current_user, (char**) &current_user, 0, GET_STR, REQUIRED_ARG,
334
 
    0, 0, 0, 0, 0, 0},
 
328
   (char**) &current_user, (char**) &current_user, 0, GET_STR, REQUIRED_ARG,
 
329
   0, 0, 0, 0, 0, 0},
335
330
  {"verbose", 'v', "Print info about the various stages.",
336
 
    (char**) &verbose, (char**) &verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
331
   (char**) &verbose, (char**) &verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
337
332
  {"version",'V', "Output version information and exit.", 0, 0, 0,
338
 
    GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
333
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
339
334
  {"where", 'w', "Dump only selected records; QUOTES mandatory!",
340
 
    (char**) &where, (char**) &where, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
335
   (char**) &where, (char**) &where, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
341
336
  {"xml", 'X', "Dump a database as well formed XML.", 0, 0, 0, GET_NO_ARG,
342
 
    NO_ARG, 0, 0, 0, 0, 0, 0},
 
337
   NO_ARG, 0, 0, 0, 0, 0, 0},
343
338
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
344
339
};
345
340
 
368
363
  Print the supplied message if in verbose mode
369
364
 
370
365
  SYNOPSIS
371
 
  verbose_msg()
372
 
  fmt   format specifier
373
 
  ...   variable number of parameters
 
366
    verbose_msg()
 
367
    fmt   format specifier
 
368
    ...   variable number of parameters
374
369
*/
375
370
static void verbose_msg(const char *fmt, ...)
376
371
{
389
384
  exit with message if ferror(file)
390
385
 
391
386
  SYNOPSIS
392
 
  check_io()
393
 
  file        - checked file
 
387
    check_io()
 
388
    file        - checked file
394
389
*/
395
390
 
396
391
static void check_io(FILE *file)
401
396
 
402
397
static void print_version(void)
403
398
{
404
 
  printf(_("%s  Drizzle %s libdrizzle %s, for %s-%s (%s)\n"), internal::my_progname,
 
399
  printf(_("%s  Drizzle %s libdrizzle %s, for %s-%s (%s)\n"), my_progname,
405
400
         VERSION, drizzle_version(), HOST_VENDOR, HOST_OS, HOST_CPU);
406
401
} /* print_version */
407
402
 
408
403
 
409
404
static void short_usage_sub(void)
410
405
{
411
 
  printf(_("Usage: %s [OPTIONS] database [tables]\n"), internal::my_progname);
 
406
  printf(_("Usage: %s [OPTIONS] database [tables]\n"), my_progname);
412
407
  printf(_("OR     %s [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...]\n"),
413
 
         internal::my_progname);
414
 
  printf(_("OR     %s [OPTIONS] --all-databases [OPTIONS]\n"), internal::my_progname);
 
408
         my_progname);
 
409
  printf(_("OR     %s [OPTIONS] --all-databases [OPTIONS]\n"), my_progname);
415
410
}
416
411
 
417
412
 
422
417
  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"));
423
418
  puts(_("Dumps definitions and data from a Drizzle database server"));
424
419
  short_usage_sub();
425
 
  internal::print_defaults("drizzle",load_default_groups);
 
420
  print_defaults("drizzle",load_default_groups);
426
421
  my_print_help(my_long_options);
427
422
  my_print_variables(my_long_options);
428
423
} /* usage */
431
426
static void short_usage(void)
432
427
{
433
428
  short_usage_sub();
434
 
  printf(_("For more options, use %s --help\n"), internal::my_progname);
 
429
  printf(_("For more options, use %s --help\n"), my_progname);
435
430
}
436
431
 
437
432
static void write_header(FILE *sql_file, char *db_name)
441
436
    fputs("<?xml version=\"1.0\"?>\n", sql_file);
442
437
    /*
443
438
      Schema reference.  Allows use of xsi:nil for NULL values and
444
 
xsi:type to define an element's data type.
 
439
      xsi:type to define an element's data type.
445
440
    */
446
441
    fputs("<drizzledump ", sql_file);
447
442
    fputs("xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"",
466
461
    }
467
462
    if (opt_set_charset)
468
463
      fprintf(sql_file,
469
 
              "\nSET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION;\n");
 
464
"\nSET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION;\n");
470
465
 
471
466
    if (path == NULL)
472
467
    {
473
 
      fprintf(md_result_file,"SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;\nSET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;\n");
 
468
      fprintf(md_result_file,"\
 
469
SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;\n\
 
470
SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;\n\
 
471
");
474
472
    }
475
473
    check_io(sql_file);
476
474
  }
488
486
  {
489
487
    if (path == NULL)
490
488
    {
491
 
      fprintf(md_result_file,"SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;\nSET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;\n");
 
489
      fprintf(md_result_file,"\
 
490
SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;\n\
 
491
SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;\n");
492
492
    }
493
493
    if (opt_set_charset)
494
494
      fprintf(sql_file, "SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION;\n");
497
497
      if (opt_dump_date)
498
498
      {
499
499
        char time_str[20];
500
 
        internal::get_date(time_str, GETDATE_DATE_TIME, 0);
 
500
        get_date(time_str, GETDATE_DATE_TIME, 0);
501
501
        fprintf(sql_file, "-- Dump completed on %s\n",
502
502
                time_str);
503
503
      }
509
509
} /* write_footer */
510
510
 
511
511
 
512
 
static int get_one_option(int optid, const struct option *, char *argument)
 
512
extern "C" bool get_one_option(int optid, const struct my_option *, char *argument);
 
513
 
 
514
extern "C" bool get_one_option(int optid, const struct my_option *, char *argument)
513
515
{
514
516
  char *endchar= NULL;
515
517
  uint64_t temp_drizzle_port= 0;
521
523
    if (strlen(endchar) != 0)
522
524
    {
523
525
      fprintf(stderr, _("Non-integer value supplied for port.  If you are trying to enter a password please use --password instead.\n"));
524
 
      return EXIT_ARGUMENT_INVALID;
 
526
      exit(EX_USAGE);
525
527
    }
526
528
    /* If the port number is > 65535 it is not a valid port
527
 
     *        This also helps with potential data loss casting unsigned long to a
528
 
     *               uint32_t. */
 
529
 *        This also helps with potential data loss casting unsigned long to a
 
530
 *               uint32_t. */
529
531
    if ((temp_drizzle_port == 0) || (temp_drizzle_port > 65535))
530
532
    {
531
533
      fprintf(stderr, _("Value supplied for port is not valid.\n"));
532
 
      return EXIT_ARGUMENT_INVALID;
 
534
      exit(EX_USAGE);
533
535
    }
534
536
    else
535
537
    {
546
548
      if (opt_password == NULL)
547
549
      {
548
550
        fprintf(stderr, _("Memory allocation error while copying password. "
549
 
                          "Aborting.\n"));
550
 
        return EXIT_OUT_OF_MEMORY;
 
551
                        "Aborting.\n"));
 
552
        exit(ENOMEM);
551
553
      }
552
554
      while (*argument)
553
555
      {
584
586
        a crash even if the input destination buffer is large enough
585
587
        to hold the output.
586
588
      */
587
 
      fprintf(stderr, _("Input filename too long: %s"), argument);
588
 
      return EXIT_ARGUMENT_INVALID;
 
589
      die(EX_USAGE, _("Input filename too long: %s"), argument);
589
590
    }
590
591
 
591
592
    break;
592
593
  case 'V': print_version(); exit(0);
593
594
  case 'X':
594
 
            opt_xml= 1;
595
 
            extended_insert= opt_drop=
596
 
              opt_disable_keys= opt_autocommit= opt_create_db= 0;
597
 
            break;
 
595
    opt_xml= 1;
 
596
    extended_insert= opt_drop=
 
597
      opt_disable_keys= opt_autocommit= opt_create_db= 0;
 
598
    break;
598
599
  case 'I':
599
600
  case '?':
600
 
            usage();
601
 
            exit(0);
 
601
    usage();
 
602
    exit(0);
602
603
  case (int) OPT_OPTIMIZE:
603
 
            extended_insert= opt_drop= quick= create_options=
604
 
              opt_disable_keys= opt_set_charset= 1;
605
 
            break;
 
604
    extended_insert= opt_drop= quick= create_options=
 
605
      opt_disable_keys= opt_set_charset= 1;
 
606
    break;
606
607
  case (int) OPT_SKIP_OPTIMIZATION:
607
 
            extended_insert= opt_drop= quick= create_options=
608
 
              opt_disable_keys= opt_set_charset= 0;
609
 
            break;
 
608
    extended_insert= opt_drop= quick= create_options=
 
609
      opt_disable_keys= opt_set_charset= 0;
 
610
    break;
610
611
  case (int) OPT_COMPACT:
611
 
            if (opt_compact)
612
 
            {
613
 
              opt_comments= opt_drop= opt_disable_keys= 0;
614
 
              opt_set_charset= 0;
615
 
            }
 
612
  if (opt_compact)
 
613
  {
 
614
    opt_comments= opt_drop= opt_disable_keys= 0;
 
615
    opt_set_charset= 0;
 
616
  }
616
617
  case (int) OPT_TABLES:
617
 
            opt_databases=0;
618
 
            break;
 
618
    opt_databases=0;
 
619
    break;
619
620
  case (int) OPT_IGNORE_TABLE:
620
 
            {
621
 
              if (!strchr(argument, '.'))
622
 
              {
623
 
                fprintf(stderr, _("Illegal use of option --ignore-table=<database>.<table>\n"));
624
 
                return EXIT_ARGUMENT_INVALID;
625
 
              }
626
 
              string tmpptr(argument);
627
 
              ignore_table.insert(tmpptr); 
628
 
              break;
629
 
            }
 
621
  {
 
622
    if (!strchr(argument, '.'))
 
623
    {
 
624
      fprintf(stderr, _("Illegal use of option --ignore-table=<database>.<table>\n"));
 
625
      exit(1);
 
626
    }
 
627
    string tmpptr(argument);
 
628
    ignore_table.insert(tmpptr); 
 
629
    break;
 
630
  }
630
631
  case (int) OPT_COMPATIBLE:
631
 
            {
632
 
              char buff[255];
633
 
              char *end= compatible_mode_normal_str;
634
 
              uint32_t i;
635
 
              uint32_t mode;
636
 
              uint32_t error_len;
 
632
    {
 
633
      char buff[255];
 
634
      char *end= compatible_mode_normal_str;
 
635
      uint32_t i;
 
636
      uint32_t mode;
 
637
      uint32_t error_len;
637
638
 
638
 
              opt_quoted= 1;
639
 
              opt_set_charset= 0;
640
 
              opt_compatible_mode_str= argument;
641
 
              opt_compatible_mode= find_set(&compatible_mode_typelib,
642
 
                                            argument, strlen(argument),
643
 
                                            &err_ptr, &error_len);
644
 
              if (error_len)
645
 
              {
646
 
                strncpy(buff, err_ptr, min((uint32_t)sizeof(buff), error_len+1));
647
 
                fprintf(stderr, _("Invalid mode to --compatible: %s\n"), buff);
648
 
                return EXIT_ARGUMENT_INVALID;
649
 
              }
650
 
              mode= opt_compatible_mode;
651
 
              for (i= 0, mode= opt_compatible_mode; mode; mode>>= 1, i++)
652
 
              {
653
 
                if (mode & 1)
654
 
                {
655
 
                  uint32_t len = strlen(compatible_mode_names[i]);
656
 
                  end= strcpy(end, compatible_mode_names[i]) + len;
657
 
                  end= strcpy(end, ",")+1;
658
 
                }
659
 
              }
660
 
              if (end!=compatible_mode_normal_str)
661
 
                end[-1]= 0;
662
 
            }
 
639
      opt_quoted= 1;
 
640
      opt_set_charset= 0;
 
641
      opt_compatible_mode_str= argument;
 
642
      opt_compatible_mode= find_set(&compatible_mode_typelib,
 
643
                                    argument, strlen(argument),
 
644
                                    &err_ptr, &error_len);
 
645
      if (error_len)
 
646
      {
 
647
        strncpy(buff, err_ptr, min((uint32_t)sizeof(buff), error_len+1));
 
648
        fprintf(stderr, _("Invalid mode to --compatible: %s\n"), buff);
 
649
        exit(1);
 
650
      }
 
651
      mode= opt_compatible_mode;
 
652
      for (i= 0, mode= opt_compatible_mode; mode; mode>>= 1, i++)
 
653
      {
 
654
        if (mode & 1)
 
655
        {
 
656
          uint32_t len = strlen(compatible_mode_names[i]);
 
657
          end= strcpy(end, compatible_mode_names[i]) + len;
 
658
          end= strcpy(end, ",")+1;
 
659
        }
 
660
      }
 
661
      if (end!=compatible_mode_normal_str)
 
662
        end[-1]= 0;
 
663
    }
663
664
  }
664
665
  return 0;
665
666
}
669
670
  int ho_error;
670
671
 
671
672
  md_result_file= stdout;
672
 
  internal::load_defaults("drizzle",load_default_groups,argc,argv);
 
673
  load_defaults("drizzle",load_default_groups,argc,argv);
673
674
  defaults_argv= *argv;
674
675
 
675
676
  if ((ho_error= handle_options(argc, argv, my_long_options, get_one_option)))
679
680
                fields_terminated))
680
681
  {
681
682
    fprintf(stderr,
682
 
            _("%s: You must use option --tab with --fields-...\n"), internal::my_progname);
 
683
            _("%s: You must use option --tab with --fields-...\n"), my_progname);
683
684
    return(EX_USAGE);
684
685
  }
685
686
 
686
687
  if (opt_single_transaction && opt_lock_all_tables)
687
688
  {
688
689
    fprintf(stderr, _("%s: You can't use --single-transaction and "
689
 
                      "--lock-all-tables at the same time.\n"), internal::my_progname);
 
690
            "--lock-all-tables at the same time.\n"), my_progname);
690
691
    return(EX_USAGE);
691
692
  }
692
693
  if (enclosed && opt_enclosed)
693
694
  {
694
 
    fprintf(stderr, _("%s: You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.\n"), internal::my_progname);
 
695
    fprintf(stderr, _("%s: You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.\n"), my_progname);
695
696
    return(EX_USAGE);
696
697
  }
697
698
  if ((opt_databases || opt_alldbs) && path)
698
699
  {
699
700
    fprintf(stderr,
700
701
            _("%s: --databases or --all-databases can't be used with --tab.\n"),
701
 
            internal::my_progname);
 
702
            my_progname);
702
703
    return(EX_USAGE);
703
704
  }
704
705
  if ((*argc < 1 && !opt_alldbs) || (*argc > 0 && opt_alldbs))
713
714
 
714
715
 
715
716
/*
716
 
 ** DB_error -- prints DRIZZLE error message and exits the program.
 
717
** DB_error -- prints DRIZZLE error message and exits the program.
717
718
*/
718
719
static void DB_error(drizzle_result_st *res, drizzle_return_t ret,
719
720
                     const char *when)
722
723
  {
723
724
    maybe_die(EX_DRIZZLEERR, _("Got error: %s (%d) %s"),
724
725
              drizzle_result_error(res),
725
 
              drizzle_result_error_code(res),
726
 
              when);
 
726
              drizzle_result_error_code(res),
 
727
              when);
727
728
    drizzle_result_free(res);
728
729
  }
729
730
  else
738
739
  Prints out an error message and kills the process.
739
740
 
740
741
  SYNOPSIS
741
 
  die()
742
 
  error_num   - process return value
743
 
  fmt_reason  - a format string for use by vsnprintf.
744
 
  ...         - variable arguments for above fmt_reason string
 
742
    die()
 
743
    error_num   - process return value
 
744
    fmt_reason  - a format string for use by vsnprintf.
 
745
    ...         - variable arguments for above fmt_reason string
745
746
 
746
747
  DESCRIPTION
747
 
  This call prints out the formatted error message to stderr and then
748
 
  terminates the process.
 
748
    This call prints out the formatted error message to stderr and then
 
749
    terminates the process.
749
750
*/
750
751
static void die(int error_num, const char* fmt_reason, ...)
751
752
{
755
756
  vsnprintf(buffer, sizeof(buffer), fmt_reason, args);
756
757
  va_end(args);
757
758
 
758
 
  fprintf(stderr, "%s: %s\n", internal::my_progname, buffer);
 
759
  fprintf(stderr, "%s: %s\n", my_progname, buffer);
759
760
  fflush(stderr);
760
761
 
761
762
  ignore_errors= 0; /* force the exit */
767
768
  Prints out an error message and maybe kills the process.
768
769
 
769
770
  SYNOPSIS
770
 
  maybe_die()
771
 
  error_num   - process return value
772
 
  fmt_reason  - a format string for use by vsnprintf.
773
 
  ...         - variable arguments for above fmt_reason string
 
771
    maybe_die()
 
772
    error_num   - process return value
 
773
    fmt_reason  - a format string for use by vsnprintf.
 
774
    ...         - variable arguments for above fmt_reason string
774
775
 
775
776
  DESCRIPTION
776
 
  This call prints out the formatted error message to stderr and then
777
 
  terminates the process, unless the --force command line option is used.
 
777
    This call prints out the formatted error message to stderr and then
 
778
    terminates the process, unless the --force command line option is used.
778
779
 
779
 
  This call should be used for non-fatal errors (such as database
780
 
  errors) that the code may still be able to continue to the next unit
781
 
  of work.
 
780
    This call should be used for non-fatal errors (such as database
 
781
    errors) that the code may still be able to continue to the next unit
 
782
    of work.
782
783
 
783
784
*/
784
785
static void maybe_die(int error_num, const char* fmt_reason, ...)
789
790
  vsnprintf(buffer, sizeof(buffer), fmt_reason, args);
790
791
  va_end(args);
791
792
 
792
 
  fprintf(stderr, "%s: %s\n", internal::my_progname, buffer);
 
793
  fprintf(stderr, "%s: %s\n", my_progname, buffer);
793
794
  fflush(stderr);
794
795
 
795
796
  maybe_exit(error_num);
802
803
  some.
803
804
 
804
805
  SYNOPSIS
805
 
  drizzleclient_query_with_error_report()
806
 
  drizzle_con       connection to use
807
 
  res             if non zero, result will be put there with
808
 
  drizzleclient_store_result()
809
 
  query           query to send to server
 
806
    drizzleclient_query_with_error_report()
 
807
    drizzle_con       connection to use
 
808
    res             if non zero, result will be put there with
 
809
                    drizzleclient_store_result()
 
810
    query           query to send to server
810
811
 
811
812
  RETURN VALUES
812
 
  0               query sending and (if res!=0) result reading went ok
813
 
  1               error
 
813
    0               query sending and (if res!=0) result reading went ok
 
814
    1               error
814
815
*/
815
816
 
816
817
static int drizzleclient_query_with_error_report(drizzle_con_st *con,
857
858
  Open a new .sql file to dump the table or view into
858
859
 
859
860
  SYNOPSIS
860
 
  open_sql_file_for_table
861
 
  name      name of the table or view
 
861
    open_sql_file_for_table
 
862
    name      name of the table or view
862
863
 
863
864
  RETURN VALUES
864
 
  0        Failed to open file
865
 
  > 0      Handle of the open file
 
865
    0        Failed to open file
 
866
    > 0      Handle of the open file
866
867
*/
867
868
static FILE* open_sql_file_for_table(const char* table)
868
869
{
869
870
  FILE* res;
870
871
  char filename[FN_REFLEN], tmp_path[FN_REFLEN];
871
 
  internal::convert_dirname(tmp_path,path,NULL);
872
 
  res= fopen(internal::fn_format(filename, table, tmp_path, ".sql", 4), "w");
 
872
  convert_dirname(tmp_path,path,NULL);
 
873
  res= fopen(fn_format(filename, table, tmp_path, ".sql", 4), "w");
873
874
 
874
875
  return res;
875
876
}
881
882
    fclose(md_result_file);
882
883
  free(opt_password);
883
884
  if (defaults_argv)
884
 
    internal::free_defaults(defaults_argv);
885
 
  internal::my_end();
 
885
    free_defaults(defaults_argv);
 
886
  my_end();
886
887
}
887
888
 
888
889
 
912
913
  drizzle_con_create(&drizzle, &dcon);
913
914
  drizzle_con_set_tcp(&dcon, host, opt_drizzle_port);
914
915
  drizzle_con_set_auth(&dcon, user, passwd);
915
 
  if (opt_mysql)
916
 
    drizzle_con_add_options(&dcon, DRIZZLE_CON_MYSQL);
917
916
  ret= drizzle_con_connect(&dcon);
918
917
  if (ret != DRIZZLE_RETURN_OK)
919
918
  {
926
925
 
927
926
 
928
927
/*
929
 
 ** dbDisconnect -- disconnects from the host.
 
928
** dbDisconnect -- disconnects from the host.
930
929
*/
931
930
static void dbDisconnect(char *host)
932
931
{
1003
1002
  Quote a table name so it can be used in "SHOW TABLES LIKE <tabname>"
1004
1003
 
1005
1004
  SYNOPSIS
1006
 
  quote_for_like()
1007
 
  name     name of the table
1008
 
  buff     quoted name of the table
 
1005
    quote_for_like()
 
1006
    name     name of the table
 
1007
    buff     quoted name of the table
1009
1008
 
1010
1009
  DESCRIPTION
1011
 
  Quote \, _, ' and % characters
1012
 
 
1013
 
Note: Because DRIZZLE uses the C escape syntax in strings
1014
 
(for example, '\n' to represent newline), you must double
1015
 
any '\' that you use in your LIKE  strings. For example, to
1016
 
search for '\n', specify it as '\\n'. To search for '\', specify
1017
 
it as '\\\\' (the backslashes are stripped once by the parser
1018
 
and another time when the pattern match is done, leaving a
1019
 
single backslash to be matched).
1020
 
 
1021
 
Example: "t\1" => "t\\\\1"
 
1010
    Quote \, _, ' and % characters
 
1011
 
 
1012
    Note: Because DRIZZLE uses the C escape syntax in strings
 
1013
    (for example, '\n' to represent newline), you must double
 
1014
    any '\' that you use in your LIKE  strings. For example, to
 
1015
    search for '\n', specify it as '\\n'. To search for '\', specify
 
1016
    it as '\\\\' (the backslashes are stripped once by the parser
 
1017
    and another time when the pattern match is done, leaving a
 
1018
    single backslash to be matched).
 
1019
 
 
1020
    Example: "t\1" => "t\\\\1"
1022
1021
 
1023
1022
*/
1024
1023
static char *quote_for_like(const char *name, char *buff)
1047
1046
  Quote and print a string.
1048
1047
 
1049
1048
  SYNOPSIS
1050
 
  print_quoted_xml()
1051
 
  xml_file    - output file
1052
 
  str         - string to print
1053
 
  len         - its length
 
1049
    print_quoted_xml()
 
1050
    xml_file    - output file
 
1051
    str         - string to print
 
1052
    len         - its length
1054
1053
 
1055
1054
  DESCRIPTION
1056
 
  Quote '<' '>' '&' '\"' chars and print a string to the xml_file.
 
1055
    Quote '<' '>' '&' '\"' chars and print a string to the xml_file.
1057
1056
*/
1058
1057
 
1059
1058
static void print_quoted_xml(FILE *xml_file, const char *str, uint32_t len)
1072
1071
    case '&':
1073
1072
      fputs("&amp;", xml_file);
1074
1073
      break;
1075
 
      case '\"':
1076
 
        fputs("&quot;", xml_file);
 
1074
    case '\"':
 
1075
      fputs("&quot;", xml_file);
1077
1076
      break;
1078
1077
    default:
1079
1078
      fputc(*str, xml_file);
1088
1087
  Print xml tag. Optionally add attribute(s).
1089
1088
 
1090
1089
  SYNOPSIS
1091
 
  print_xml_tag(xml_file, sbeg, send, tag_name, first_attribute_name,
1092
 
  ..., attribute_name_n, attribute_value_n, NULL)
1093
 
  xml_file              - output file
1094
 
  sbeg                  - line beginning
1095
 
  line_end              - line ending
1096
 
  tag_name              - XML tag name.
1097
 
  first_attribute_name  - tag and first attribute
1098
 
  first_attribute_value - (Implied) value of first attribute
1099
 
  attribute_name_n      - attribute n
1100
 
  attribute_value_n     - value of attribute n
 
1090
    print_xml_tag(xml_file, sbeg, send, tag_name, first_attribute_name,
 
1091
                    ..., attribute_name_n, attribute_value_n, NULL)
 
1092
    xml_file              - output file
 
1093
    sbeg                  - line beginning
 
1094
    line_end              - line ending
 
1095
    tag_name              - XML tag name.
 
1096
    first_attribute_name  - tag and first attribute
 
1097
    first_attribute_value - (Implied) value of first attribute
 
1098
    attribute_name_n      - attribute n
 
1099
    attribute_value_n     - value of attribute n
1101
1100
 
1102
1101
  DESCRIPTION
1103
 
  Print XML tag with any number of attribute="value" pairs to the xml_file.
 
1102
    Print XML tag with any number of attribute="value" pairs to the xml_file.
1104
1103
 
1105
 
  Format is:
1106
 
  sbeg<tag_name first_attribute_name="first_attribute_value" ...
1107
 
  attribute_name_n="attribute_value_n">send
 
1104
    Format is:
 
1105
      sbeg<tag_name first_attribute_name="first_attribute_value" ...
 
1106
      attribute_name_n="attribute_value_n">send
1108
1107
  NOTE
1109
 
  Additional arguments must be present in attribute/value pairs.
1110
 
  The last argument should be the null character pointer.
1111
 
  All attribute_value arguments MUST be NULL terminated strings.
1112
 
  All attribute_value arguments will be quoted before output.
 
1108
    Additional arguments must be present in attribute/value pairs.
 
1109
    The last argument should be the null character pointer.
 
1110
    All attribute_value arguments MUST be NULL terminated strings.
 
1111
    All attribute_value arguments will be quoted before output.
1113
1112
*/
1114
1113
 
1115
1114
static void print_xml_tag(FILE * xml_file, const char* sbeg,
1152
1151
  Print xml tag with for a field that is null
1153
1152
 
1154
1153
  SYNOPSIS
1155
 
  print_xml_null_tag()
1156
 
  xml_file    - output file
1157
 
  sbeg        - line beginning
1158
 
  stag_atr    - tag and attribute
1159
 
  sval        - value of attribute
1160
 
  line_end        - line ending
 
1154
    print_xml_null_tag()
 
1155
    xml_file    - output file
 
1156
    sbeg        - line beginning
 
1157
    stag_atr    - tag and attribute
 
1158
    sval        - value of attribute
 
1159
    line_end        - line ending
1161
1160
 
1162
1161
  DESCRIPTION
1163
 
  Print tag with one attribute to the xml_file. Format is:
1164
 
  <stag_atr="sval" xsi:nil="true"/>
 
1162
    Print tag with one attribute to the xml_file. Format is:
 
1163
      <stag_atr="sval" xsi:nil="true"/>
1165
1164
  NOTE
1166
 
  sval MUST be a NULL terminated string.
1167
 
  sval string will be qouted before output.
 
1165
    sval MUST be a NULL terminated string.
 
1166
    sval string will be qouted before output.
1168
1167
*/
1169
1168
 
1170
1169
static void print_xml_null_tag(FILE * xml_file, const char* sbeg,
1186
1185
  Print xml tag with many attributes.
1187
1186
 
1188
1187
  SYNOPSIS
1189
 
  print_xml_row()
1190
 
  xml_file    - output file
1191
 
  row_name    - xml tag name
1192
 
  tableRes    - query result
1193
 
  row         - result row
 
1188
    print_xml_row()
 
1189
    xml_file    - output file
 
1190
    row_name    - xml tag name
 
1191
    tableRes    - query result
 
1192
    row         - result row
1194
1193
 
1195
1194
  DESCRIPTION
1196
 
  Print tag with many attribute to the xml_file. Format is:
1197
 
  \t\t<row_name Atr1="Val1" Atr2="Val2"... />
 
1195
    Print tag with many attribute to the xml_file. Format is:
 
1196
      \t\t<row_name Atr1="Val1" Atr2="Val2"... />
1198
1197
  NOTE
1199
 
  All atributes and values will be quoted before output.
 
1198
    All atributes and values will be quoted before output.
1200
1199
*/
1201
1200
 
1202
1201
static void print_xml_row(FILE *xml_file, const char *row_name,
1231
1230
  Print hex value for blob data.
1232
1231
 
1233
1232
  SYNOPSIS
1234
 
  print_blob_as_hex()
1235
 
  output_file         - output file
1236
 
  str                 - string to print
1237
 
  len                 - its length
 
1233
    print_blob_as_hex()
 
1234
    output_file         - output file
 
1235
    str                 - string to print
 
1236
    len                 - its length
1238
1237
 
1239
1238
  DESCRIPTION
1240
 
  Print hex value for blob data.
 
1239
    Print hex value for blob data.
1241
1240
*/
1242
1241
 
1243
1242
static void print_blob_as_hex(FILE *output_file, const char *str, uint32_t len)
1244
1243
{
1245
 
  /* sakaik got the idea to to provide blob's in hex notation. */
1246
 
  const char *ptr= str, *end= ptr + len;
1247
 
  for (; ptr < end ; ptr++)
1248
 
    fprintf(output_file, "%02X", *((unsigned char *)ptr));
1249
 
  check_io(output_file);
 
1244
    /* sakaik got the idea to to provide blob's in hex notation. */
 
1245
    const char *ptr= str, *end= ptr + len;
 
1246
    for (; ptr < end ; ptr++)
 
1247
      fprintf(output_file, "%02X", *((unsigned char *)ptr));
 
1248
    check_io(output_file);
1250
1249
}
1251
1250
 
1252
1251
/*
1255
1254
  be dumping.
1256
1255
 
1257
1256
  ARGS
1258
 
  table       - table name
1259
 
  db          - db name
1260
 
  table_type  - table type, e.g. "MyISAM" or "InnoDB", but also "VIEW"
1261
 
  ignore_flag - what we must particularly ignore - see IGNORE_ defines above
1262
 
  num_fields  - number of fields in the table
 
1257
    table       - table name
 
1258
    db          - db name
 
1259
    table_type  - table type, e.g. "MyISAM" or "InnoDB", but also "VIEW"
 
1260
    ignore_flag - what we must particularly ignore - see IGNORE_ defines above
 
1261
    num_fields  - number of fields in the table
1263
1262
 
1264
1263
  RETURN
1265
 
  true if success, false if error
 
1264
    true if success, false if error
1266
1265
*/
1267
1266
 
1268
1267
static bool get_table_structure(char *table, char *db, char *table_type,
1286
1285
  {
1287
1286
    delayed= 0;
1288
1287
    verbose_msg(_("-- Warning: Unable to use delayed inserts for table '%s' "
1289
 
                  "because it's of type %s\n"), table, table_type);
 
1288
                "because it's of type %s\n"), table, table_type);
1290
1289
  }
1291
1290
 
1292
1291
  complete_insert= 0;
1342
1341
      }
1343
1342
      if (opt_drop)
1344
1343
      {
1345
 
        /*
1346
 
          Even if the "table" is a view, we do a DROP TABLE here.
1347
 
        */
 
1344
      /*
 
1345
        Even if the "table" is a view, we do a DROP TABLE here.
 
1346
       */
1348
1347
        fprintf(sql_file, "DROP TABLE IF EXISTS %s;\n", opt_quoted_table);
1349
1348
        check_io(sql_file);
1350
1349
      }
1414
1413
  else
1415
1414
  {
1416
1415
    verbose_msg(_("%s: Warning: Can't set SQL_QUOTE_SHOW_CREATE option (%s)\n"),
1417
 
                internal::my_progname, drizzle_con_error(&dcon));
 
1416
                my_progname, drizzle_con_error(&dcon));
1418
1417
 
1419
1418
    snprintf(query_buff, sizeof(query_buff), "show fields from %s",
1420
1419
             result_table);
1442
1441
        fprintf(sql_file, "CREATE TABLE %s (\n", result_table);
1443
1442
      else
1444
1443
        print_xml_tag(sql_file, "\t", "\n", "table_structure", "name=", table,
1445
 
                      NULL);
 
1444
                NULL);
1446
1445
      check_io(sql_file);
1447
1446
    }
1448
1447
 
1521
1520
      if (drizzleclient_query_with_error_report(&dcon, &result, buff, false))
1522
1521
      {
1523
1522
        fprintf(stderr, _("%s: Can't get keys for table %s\n"),
1524
 
                internal::my_progname, result_table);
 
1523
                my_progname, result_table);
1525
1524
        if (path)
1526
1525
          fclose(sql_file);
1527
1526
        return false;
1705
1704
 
1706
1705
/*
1707
1706
 
1708
 
  SYNOPSIS
 
1707
 SYNOPSIS
1709
1708
  dump_table()
1710
1709
 
1711
1710
  dump_table saves database contents as a series of INSERT statements.
1712
1711
 
1713
1712
  ARGS
1714
 
  table - table name
1715
 
  db    - db name
 
1713
   table - table name
 
1714
   db    - db name
1716
1715
 
1717
 
  RETURNS
1718
 
  void
 
1716
   RETURNS
 
1717
    void
1719
1718
*/
1720
1719
 
1721
1720
 
1755
1754
 
1756
1755
  /*
1757
1756
    If the table type is a merge table or any type that has to be
1758
 
    _completely_ ignored and no data dumped
 
1757
     _completely_ ignored and no data dumped
1759
1758
  */
1760
1759
  if (ignore_flag & IGNORE_DATA)
1761
1760
  {
1762
1761
    verbose_msg(_("-- Warning: Skipping data for table '%s' because " \
1763
 
                  "it's of type %s\n"), table, table_type);
 
1762
                "it's of type %s\n"), table, table_type);
1764
1763
    return;
1765
1764
  }
1766
1765
  /* Check that there are any fields in the table */
1787
1786
      Convert the path to native os format
1788
1787
      and resolve to the full filepath.
1789
1788
    */
1790
 
    internal::convert_dirname(tmp_path,path,NULL);
1791
 
    internal::my_load_path(tmp_path, tmp_path, NULL);
1792
 
    internal::fn_format(filename, table, tmp_path, ".txt", MYF(MY_UNPACK_FILENAME));
 
1789
    convert_dirname(tmp_path,path,NULL);
 
1790
    my_load_path(tmp_path, tmp_path, NULL);
 
1791
    fn_format(filename, table, tmp_path, ".txt", MYF(MY_UNPACK_FILENAME));
1793
1792
 
1794
1793
    /* Must delete the file that 'INTO OUTFILE' will write to */
1795
 
    internal::my_delete(filename, MYF(0));
 
1794
    my_delete(filename, MYF(0));
1796
1795
 
1797
1796
    /* now build the query string */
1798
1797
 
1883
1882
    if (drizzle_result_column_count(&result) != num_fields)
1884
1883
    {
1885
1884
      fprintf(stderr,_("%s: Error in field count for table: %s !  Aborting.\n"),
1886
 
              internal::my_progname, result_table);
 
1885
              my_progname, result_table);
1887
1886
      error= EX_CONSCHECK;
1888
1887
      drizzle_result_free(&result);
1889
1888
      goto err;
1893
1892
    if (opt_disable_keys)
1894
1893
    {
1895
1894
      fprintf(md_result_file, "ALTER TABLE %s DISABLE KEYS;\n",
1896
 
              opt_quoted_table);
 
1895
              opt_quoted_table);
1897
1896
      check_io(md_result_file);
1898
1897
    }
1899
1898
 
1903
1902
    init_length=(uint32_t) insert_pat.length()+4;
1904
1903
    if (opt_xml)
1905
1904
      print_xml_tag(md_result_file, "\t", "\n", "table_data", "name=", table,
1906
 
                    NULL);
 
1905
              NULL);
1907
1906
    if (opt_autocommit)
1908
1907
    {
1909
1908
      fprintf(md_result_file, "set autocommit=0;\n");
1926
1925
        if (ret != DRIZZLE_RETURN_OK)
1927
1926
        {
1928
1927
          fprintf(stderr,
1929
 
                  _("%s: Error reading rows for table: %s (%d:%s) ! Aborting.\n"),
1930
 
                  internal::my_progname, result_table, ret, drizzle_con_error(&dcon));
 
1928
                _("%s: Error reading rows for table: %s (%d:%s) ! Aborting.\n"),
 
1929
                  my_progname, result_table, ret, drizzle_con_error(&dcon));
1931
1930
          drizzle_result_free(&result);
1932
1931
          goto err;
1933
1932
        }
1965
1964
 
1966
1965
        if (!(column= drizzle_column_next(&result)))
1967
1966
          die(EX_CONSCHECK,
1968
 
              _("Not enough fields from table %s! Aborting.\n"),
1969
 
              result_table);
 
1967
                      _("Not enough fields from table %s! Aborting.\n"),
 
1968
                      result_table);
1970
1969
 
1971
1970
        /*
1972
 
          63 is my_charset_bin. If charsetnr is not 63,
1973
 
          we have not a BLOB but a TEXT column.
1974
 
          we'll dump in hex only BLOB columns.
 
1971
           63 is my_charset_bin. If charsetnr is not 63,
 
1972
           we have not a BLOB but a TEXT column.
 
1973
           we'll dump in hex only BLOB columns.
1975
1974
        */
1976
1975
        is_blob= (opt_hex_blob && drizzle_column_charset(column) == 63 &&
1977
1976
                  (drizzle_column_type(column) == DRIZZLE_COLUMN_TYPE_VARCHAR ||
2022
2021
                /* change any strings ("inf", "-inf", "nan") into NULL */
2023
2022
                char *ptr= row[i];
2024
2023
                if (my_isalpha(charset_info, *ptr) || (*ptr == '-' &&
2025
 
                                                       my_isalpha(charset_info, ptr[1])))
 
2024
                    my_isalpha(charset_info, ptr[1])))
2026
2025
                  extended_row.append( "NULL");
2027
2026
                else
2028
2027
                {
2079
2078
              if (opt_xml)
2080
2079
              {
2081
2080
                print_xml_tag(md_result_file, "\t\t", "", "field", "name=",
2082
 
                              drizzle_column_name(column), NULL);
 
2081
                        drizzle_column_name(column), NULL);
2083
2082
                fputs(!my_isalpha(charset_info, *ptr) ? ptr: "NULL",
2084
2083
                      md_result_file);
2085
2084
                fputs("</field>\n", md_result_file);
2142
2141
 
2143
2142
    /* XML - close table tag and supress regular output */
2144
2143
    if (opt_xml)
2145
 
      fputs("\t</table_data>\n", md_result_file);
 
2144
        fputs("\t</table_data>\n", md_result_file);
2146
2145
    else if (extended_insert && row_break)
2147
2146
      fputs(";\n", md_result_file);             /* If not empty table */
2148
2147
    fflush(md_result_file);
2232
2231
 
2233
2232
 
2234
2233
/*
2235
 
  Table Specific database initalization.
 
2234
Table Specific database initalization.
2236
2235
 
2237
 
  SYNOPSIS
 
2236
SYNOPSIS
2238
2237
  init_dumping_tables
2239
2238
  qdatabase      quoted name of the database
2240
2239
 
2241
 
  RETURN VALUES
 
2240
RETURN VALUES
2242
2241
  0        Success.
2243
2242
  1        Failure.
2244
2243
*/
2301
2300
    return 1;
2302
2301
 
2303
2302
  if (drizzle_select_db(&dcon, &result, database, &ret) == NULL ||
2304
 
      ret != DRIZZLE_RETURN_OK)
 
2303
        ret != DRIZZLE_RETURN_OK)
2305
2304
  {
2306
2305
    DB_error(&result, ret, _("when executing 'SELECT INTO OUTFILE'"));
2307
2306
    return 1;                   /* If --force */
2400
2399
  different case (e.g.  T1 vs t1)
2401
2400
 
2402
2401
  RETURN
2403
 
  pointer to the table name
2404
 
  0 if error
 
2402
    pointer to the table name
 
2403
    0 if error
2405
2404
*/
2406
2405
 
2407
 
static char *get_actual_table_name(const char *old_table_name,
2408
 
                                   drizzled::memory::Root *root)
 
2406
static char *get_actual_table_name(const char *old_table_name, MEM_ROOT *root)
2409
2407
{
2410
2408
  char *name= 0;
2411
2409
  drizzle_result_st result;
2429
2427
    size_t *lengths;
2430
2428
    /*
2431
2429
      Return first row
2432
 
      TODO-> Return all matching rows
 
2430
      TODO: Return all matching rows
2433
2431
    */
2434
2432
    row= drizzle_row_next(&result);
2435
2433
    lengths= drizzle_row_field_sizes(&result);
2443
2441
 
2444
2442
static int dump_selected_tables(char *db, char **table_names, int tables)
2445
2443
{
2446
 
  drizzled::memory::Root root;
 
2444
  MEM_ROOT root;
2447
2445
  char **dump_tables, **pos, **end;
2448
2446
  drizzle_result_st result;
2449
2447
  drizzle_return_t ret;
2452
2450
  if (init_dumping(db, init_dumping_tables))
2453
2451
    return(1);
2454
2452
 
2455
 
  init_alloc_root(&root, 8192);
 
2453
  init_alloc_root(&root, 8192, 0);
2456
2454
  if (!(dump_tables= pos= (char**) alloc_root(&root, tables * sizeof(char *))))
2457
 
    die(EX_EOM, _("alloc_root failure."));
 
2455
     die(EX_EOM, _("alloc_root failure."));
2458
2456
 
2459
2457
  for (; tables > 0 ; tables-- , table_names++)
2460
2458
  {
2512
2510
    We do first a FLUSH TABLES. If a long update is running, the FLUSH TABLES
2513
2511
    will wait but will not stall the whole mysqld, and when the long update is
2514
2512
    done the FLUSH TABLES WITH READ LOCK will start and succeed quickly. So,
2515
 
    FLUSH TABLES is to lower the probability of a stage where both drizzled
 
2513
    FLUSH TABLES is to lower the probability of a stage where both mysqldump
2516
2514
    and most client connections are stalled. Of course, if a second long
2517
2515
    update starts between the two FLUSHes, we have that bad stall.
2518
2516
  */
2519
2517
  return
2520
2518
    ( drizzleclient_query_with_error_report(drizzle_con, 0, "FLUSH TABLES", false) ||
2521
2519
      drizzleclient_query_with_error_report(drizzle_con, 0,
2522
 
                                            "FLUSH TABLES WITH READ LOCK", false) );
 
2520
                                    "FLUSH TABLES WITH READ LOCK", false) );
2523
2521
}
2524
2522
 
2525
2523
static int do_unlock_tables(drizzle_con_st *drizzle_con)
2530
2528
static int start_transaction(drizzle_con_st *drizzle_con)
2531
2529
{
2532
2530
  return (drizzleclient_query_with_error_report(drizzle_con, 0,
2533
 
                                                "SET SESSION TRANSACTION ISOLATION "
2534
 
                                                "LEVEL REPEATABLE READ", false) ||
 
2531
                                        "SET SESSION TRANSACTION ISOLATION "
 
2532
                                        "LEVEL REPEATABLE READ", false) ||
2535
2533
          drizzleclient_query_with_error_report(drizzle_con, 0,
2536
 
                                                "START TRANSACTION "
2537
 
                                                "WITH CONSISTENT SNAPSHOT", false));
 
2534
                                        "START TRANSACTION "
 
2535
                                        "WITH CONSISTENT SNAPSHOT", false));
2538
2536
}
2539
2537
 
2540
2538
 
2541
2539
static uint32_t find_set(TYPELIB *lib, const char *x, uint32_t length,
2542
 
                         char **err_pos, uint32_t *err_len)
 
2540
                      char **err_pos, uint32_t *err_len)
2543
2541
{
2544
2542
  const char *end= x + length;
2545
2543
  uint32_t found= 0;
2645
2643
 
2646
2644
  ARGS
2647
2645
 
2648
 
  check_if_ignore_table()
2649
 
  table_name                  Table name to check
2650
 
  table_type                  Type of table
 
2646
    check_if_ignore_table()
 
2647
    table_name                  Table name to check
 
2648
    table_type                  Type of table
2651
2649
 
2652
2650
  GLOBAL VARIABLES
2653
 
  drizzle                       Drizzle connection
2654
 
  verbose                     Write warning messages
 
2651
    drizzle                       Drizzle connection
 
2652
    verbose                     Write warning messages
2655
2653
 
2656
2654
  RETURN
2657
 
  char (bit value)            See IGNORE_ values at top
 
2655
    char (bit value)            See IGNORE_ values at top
2658
2656
*/
2659
2657
 
2660
2658
char check_if_ignore_table(const char *table_name, char *table_type)
2690
2688
  }
2691
2689
  /*
2692
2690
    If the table type matches any of these, we do support delayed inserts.
2693
 
    Note-> we do not want to skip dumping this table if if is not one of
 
2691
    Note: we do not want to skip dumping this table if if is not one of
2694
2692
    these types, but we do want to use delayed inserts in the dump if
2695
2693
    the table type is _NOT_ one of these types
2696
 
  */
 
2694
    */
2697
2695
  {
2698
2696
    strncpy(table_type, row[1], DRIZZLE_MAX_TABLE_SIZE-1);
2699
2697
    if (opt_delayed)
2714
2712
  Get string of comma-separated primary key field names
2715
2713
 
2716
2714
  SYNOPSIS
2717
 
  char *primary_key_fields(const char *table_name)
2718
 
  RETURNS     pointer to allocated buffer (must be freed by caller)
2719
 
  table_name  quoted table name
 
2715
    char *primary_key_fields(const char *table_name)
 
2716
    RETURNS     pointer to allocated buffer (must be freed by caller)
 
2717
    table_name  quoted table name
2720
2718
 
2721
2719
  DESCRIPTION
2722
 
  Use SHOW KEYS FROM table_name, allocate a buffer to hold the
2723
 
  field names, and then build that string and return the pointer
2724
 
  to that buffer.
 
2720
    Use SHOW KEYS FROM table_name, allocate a buffer to hold the
 
2721
    field names, and then build that string and return the pointer
 
2722
    to that buffer.
2725
2723
 
2726
 
  Returns NULL if there is no PRIMARY or UNIQUE key on the table,
2727
 
  or if there is some failure.  It is better to continue to dump
2728
 
  the table unsorted, rather than exit without dumping the data.
 
2724
    Returns NULL if there is no PRIMARY or UNIQUE key on the table,
 
2725
    or if there is some failure.  It is better to continue to dump
 
2726
    the table unsorted, rather than exit without dumping the data.
2729
2727
*/
2730
2728
 
2731
2729
static char *primary_key_fields(const char *table_name)
2748
2746
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
2749
2747
    {
2750
2748
      fprintf(stderr, _("Warning: Couldn't read keys from table %s;"
2751
 
                        " records are NOT sorted (%s)\n"),
 
2749
              " records are NOT sorted (%s)\n"),
2752
2750
              table_name, drizzle_result_error(&res));
2753
2751
      drizzle_result_free(&res);
2754
2752
    }
2755
2753
    else
2756
2754
    {
2757
2755
      fprintf(stderr, _("Warning: Couldn't read keys from table %s;"
2758
 
                        " records are NOT sorted (%s)\n"),
 
2756
              " records are NOT sorted (%s)\n"),
2759
2757
              table_name, drizzle_con_error(&dcon));
2760
2758
    }
2761
2759
 
2765
2763
  if (drizzle_result_buffer(&res) != DRIZZLE_RETURN_OK)
2766
2764
  {
2767
2765
    fprintf(stderr, _("Warning: Couldn't read keys from table %s;"
2768
 
                      " records are NOT sorted (%s)\n"),
 
2766
            " records are NOT sorted (%s)\n"),
2769
2767
            table_name, drizzle_con_error(&dcon));
2770
2768
    return result;
2771
2769
  }
2775
2773
   * Note that SHOW KEYS is ordered:  a PRIMARY key is always the first
2776
2774
   * row, and UNIQUE keys come before others.  So we only need to check
2777
2775
   * the first key, not all keys.
2778
 
 */
 
2776
   */
2779
2777
  if ((row= drizzle_row_next(&res)) && atoi(row[1]) == 0)
2780
2778
  {
2781
2779
    /* Key is unique */
2791
2789
  {
2792
2790
    char *end;
2793
2791
    /* result (terminating \0 is already in result_length) */
2794
 
 
2795
 
    size_t result_length_alloc= result_length + 10;
2796
 
    result= (char *)malloc(result_length_alloc);
 
2792
    result= (char *)malloc(result_length + 10);
2797
2793
    if (!result)
2798
2794
    {
2799
2795
      fprintf(stderr, _("Error: Not enough memory to store ORDER BY clause\n"));
2804
2800
    row= drizzle_row_next(&res);
2805
2801
    quoted_field= quote_name(row[4], buff, 0);
2806
2802
    end= strcpy(result, quoted_field) + strlen(quoted_field);
2807
 
    result_length_alloc -= strlen(quoted_field);
2808
2803
    while ((row= drizzle_row_next(&res)) && atoi(row[3]) > 1)
2809
2804
    {
2810
2805
      quoted_field= quote_name(row[4], buff, 0);
2811
 
      end+= snprintf(end, result_length_alloc, ",%s",quoted_field);
2812
 
      result_length_alloc -= strlen(quoted_field);
 
2806
      end+= sprintf(end,",%s",quoted_field);
2813
2807
    }
2814
2808
  }
2815
2809
 
2844
2838
  if ((opt_lock_all_tables) && do_flush_tables_read_lock(&dcon))
2845
2839
    goto err;
2846
2840
  if (opt_single_transaction && start_transaction(&dcon))
2847
 
    goto err;
 
2841
      goto err;
2848
2842
  if (opt_lock_all_tables)
2849
2843
  {
2850
2844
    if (drizzleclient_query_with_error_report(&dcon, &result, "FLUSH LOGS", false))