~drizzle-trunk/drizzle/development

/* Copyright (C) 2008 Drizzle Open Source Development Project

   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; version 2 of the License.

   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.

   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 */

/* drizzledump.cc  - Dump a tables contents and format to an ASCII file

**

** The author's original notes follow :-

**

** AUTHOR: Igor Romanenko (igor@frog.kiev.ua)

** DATE:   December 3, 1994

** WARRANTY: None, expressed, impressed, implied

**          or other

** STATUS: Public domain

*/

#define DUMP_VERSION "10.13"

#include "client_priv.h"

#include <string>

#include <mysys/my_sys.h>

#include <mystrings/m_string.h>

#include <mystrings/m_ctype.h>

#include <mysys/hash.h>

#include <stdarg.h>

#include <algorithm>

#include <drizzled/gettext.h>

#include <drizzled/error.h>

using namespace std;

/* Exit codes */

#define EX_USAGE 1

#define EX_DRIZZLEERR 2

#define EX_CONSCHECK 3

#define EX_EOM 4

#define EX_EOF 5 /* ferror for output file was got */

#define EX_ILLEGAL_TABLE 6

#define EX_TABLE_STATUS 7

/* 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

/* Size of buffer for dump's select query */

#define QUERY_LENGTH 1536

/* ignore table flags */

#define IGNORE_NONE 0x00 /* no ignore */

#define IGNORE_DATA 0x01 /* don't dump data for this table */

#define IGNORE_INSERT_DELAYED 0x02 /* table doesn't support INSERT DELAYED */

static void add_load_option(string &str, const char *option,

                            const char *option_value);

static uint32_t find_set(TYPELIB *lib, const char *x, uint length,

                      char **err_pos, uint *err_len);

static void field_escape(string &in, const char *from);

static bool  verbose= false, opt_no_create_info= false, opt_no_data= false,

                quick= true, extended_insert= true,

                lock_tables= true, ignore_errors= false, flush_logs= false,

                opt_drop= true, opt_keywords= false,

                opt_lock= true, opt_compress= false,

                opt_delayed= false, create_options= true, opt_quoted= false,

                opt_databases= false, opt_alldbs= false, opt_create_db= false,

                opt_lock_all_tables= false,

                opt_set_charset= false, opt_dump_date= true,

                opt_autocommit= false, opt_disable_keys= true, opt_xml= false,

                opt_delete_master_logs= false, tty_password= false,

                opt_single_transaction= false, opt_comments= false,

                opt_compact= false, opt_hex_blob= false, 

                opt_order_by_primary=false, opt_ignore= false,

                opt_complete_insert= false, opt_drop_database= false,

                opt_replace_into= false,

                opt_routines= false,

                opt_slave_apply= false,

                opt_include_master_host_port= false,

                opt_alltspcs= false;

static bool debug_info_flag= false, debug_check_flag= false;

static uint32_t opt_max_allowed_packet, opt_net_buffer_length, show_progress_size= 0;

static uint64_t total_rows= 0;

static DRIZZLE drizzle_connection, *drizzle= 0;

static string insert_pat;

static char  *opt_password= NULL, *current_user= NULL,

             *current_host= NULL, *path= NULL, *fields_terminated= NULL,

             *lines_terminated= NULL, *enclosed= NULL, *opt_enclosed= NULL,

             *escaped= NULL,

             *where= NULL, *order_by= NULL,

             *opt_compatible_mode_str= NULL,

             *err_ptr= NULL;

static char **defaults_argv= NULL;

static char compatible_mode_normal_str[255];

static uint32_t opt_compatible_mode= 0;

#define DRIZZLE_OPT_MASTER_DATA_EFFECTIVE_SQL 1

#define DRIZZLE_OPT_MASTER_DATA_COMMENTED_SQL 2

#define DRIZZLE_OPT_SLAVE_DATA_EFFECTIVE_SQL 1

#define DRIZZLE_OPT_SLAVE_DATA_COMMENTED_SQL 2

static uint32_t opt_drizzle_port= 0;

static uint opt_master_data;

static uint opt_slave_data;

static uint my_end_arg;

static int first_error= 0;

static string extended_row;

FILE *md_result_file= 0;

FILE *stderror_file= 0;

/*

  Constant for detection of default value of default_charset.

  If default_charset is equal to drizzle_universal_client_charset, then

  it is the default value which assigned at the very beginning of main().

*/

static const char *drizzle_universal_client_charset=

  DRIZZLE_UNIVERSAL_CLIENT_CHARSET;

static char *default_charset;

static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;

const char *default_dbug_option="d:t:o,/tmp/drizzledump.trace";

const char *compatible_mode_names[]=

{

  "MYSQL323", "MYSQL40", "POSTGRESQL", "ORACLE", "MSSQL", "DB2",

  "MAXDB", "NO_KEY_OPTIONS", "NO_TABLE_OPTIONS", "NO_FIELD_OPTIONS",

  "ANSI",

  NULL

};

#define MASK_ANSI_QUOTES \

(\

 (1<<2)  | /* POSTGRESQL */\

 (1<<3)  | /* ORACLE     */\

 (1<<4)  | /* MSSQL      */\

 (1<<5)  | /* DB2        */\

 (1<<6)  | /* MAXDB      */\

 (1<<10)   /* ANSI       */\

)

TYPELIB compatible_mode_typelib= {array_elements(compatible_mode_names) - 1,

                                  "", compatible_mode_names, NULL};

HASH ignore_table;

static struct my_option my_long_options[] =

{

  {"all", 'a', "Deprecated. Use --create-options instead.",

   (char**) &create_options, (char**) &create_options, 0, GET_BOOL, NO_ARG, 1,

   0, 0, 0, 0, 0},

  {"all-databases", 'A',

   "Dump all the databases. This will be same as --databases with all databases selected.",

   (char**) &opt_alldbs, (char**) &opt_alldbs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

   0, 0},

  {"all-tablespaces", 'Y',

   "Dump all the tablespaces.",

   (char**) &opt_alltspcs, (char**) &opt_alltspcs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

   0, 0},

  {"add-drop-database", OPT_DROP_DATABASE, "Add a 'DROP DATABASE' before each create.",

   (char**) &opt_drop_database, (char**) &opt_drop_database, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,

   0},

  {"add-drop-table", OPT_DROP, "Add a 'drop table' before each create.",

   (char**) &opt_drop, (char**) &opt_drop, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0,

   0},

  {"add-locks", OPT_LOCKS, "Add locks around insert statements.",

   (char**) &opt_lock, (char**) &opt_lock, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0,

   0},

  {"allow-keywords", OPT_KEYWORDS,

   "Allow creation of column names that are keywords.", (char**) &opt_keywords,

   (char**) &opt_keywords, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"apply-slave-statements", OPT_DRIZZLEDUMP_SLAVE_APPLY,

   "Adds 'STOP SLAVE' prior to 'CHANGE MASTER' and 'START SLAVE' to bottom of dump.",

   (char**) &opt_slave_apply, (char**) &opt_slave_apply, 0, GET_BOOL, NO_ARG,

   0, 0, 0, 0, 0, 0},

  {"character-sets-dir", OPT_CHARSETS_DIR,

   "Directory where character sets are.", (char**) &charsets_dir,

   (char**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"comments", 'i', "Write additional information.",

   (char**) &opt_comments, (char**) &opt_comments, 0, GET_BOOL, NO_ARG,

   1, 0, 0, 0, 0, 0},

  {"compatible", OPT_COMPATIBLE,

   "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.",

   (char**) &opt_compatible_mode_str, (char**) &opt_compatible_mode_str, 0,

   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"compact", OPT_COMPACT,

   "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",

   (char**) &opt_compact, (char**) &opt_compact, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

   0, 0},

  {"complete-insert", 'c', "Use complete insert statements.",

   (char**) &opt_complete_insert, (char**) &opt_complete_insert, 0, GET_BOOL,

   NO_ARG, 0, 0, 0, 0, 0, 0},

  {"compress", 'C', "Use compression in server/client protocol.",

   (char**) &opt_compress, (char**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,

   0, 0, 0},

  {"create-options", OPT_CREATE_OPTIONS,

   "Include all DRIZZLE specific create options.",

   (char**) &create_options, (char**) &create_options, 0, GET_BOOL, NO_ARG, 1,

   0, 0, 0, 0, 0},

  {"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.",

   (char**) &opt_databases, (char**) &opt_databases, 0, GET_BOOL, NO_ARG, 0, 0,

   0, 0, 0, 0},

  {"debug-check", OPT_DEBUG_CHECK, "Check memory and open file usage at exit.",

   (char**) &debug_check_flag, (char**) &debug_check_flag, 0,

   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"debug-info", OPT_DEBUG_INFO, "Print some debug info at exit.",

   (char**) &debug_info_flag, (char**) &debug_info_flag,

   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"default-character-set", OPT_DEFAULT_CHARSET,

   "Set the default character set.", (char**) &default_charset,

   (char**) &default_charset, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"delayed-insert", OPT_DELAYED, "Insert rows with INSERT DELAYED; ",

   (char**) &opt_delayed, (char**) &opt_delayed, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

   0, 0},

  {"delete-master-logs", OPT_DELETE_MASTER_LOGS,

   "Delete logs on master after backup. This automatically enables --master-data.",

   (char**) &opt_delete_master_logs, (char**) &opt_delete_master_logs, 0,

   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"disable-keys", 'K',

   "'ALTER TABLE tb_name DISABLE KEYS; and 'ALTER TABLE tb_name ENABLE KEYS; will be put in the output.", (char**) &opt_disable_keys,

   (char**) &opt_disable_keys, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},

  {"dump-slave", OPT_DRIZZLEDUMP_SLAVE_DATA,

   "This causes the binary log position and filename of the master to be "

   "appended to the dumped data output. Setting the value to 1, will print"

   "it as a CHANGE MASTER command in the dumped data output; 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.",

   (char**) &opt_slave_data, (char**) &opt_slave_data, 0,

   GET_UINT, OPT_ARG, 0, 0, DRIZZLE_OPT_SLAVE_DATA_COMMENTED_SQL, 0, 0, 0},

  {"extended-insert", 'e',

   "Allows utilization of the new, much faster INSERT syntax.",

   (char**) &extended_insert, (char**) &extended_insert, 0, GET_BOOL, NO_ARG,

   1, 0, 0, 0, 0, 0},

  {"fields-terminated-by", OPT_FTB,

   "Fields in the textfile are terminated by ...", (char**) &fields_terminated,

   (char**) &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 ...", (char**) &enclosed,

   (char**) &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 ...", (char**) &opt_enclosed,

   (char**) &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 ...",

   (char**) &escaped, (char**) &escaped, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"first-slave", 'x', "Deprecated, renamed to --lock-all-tables.",

   (char**) &opt_lock_all_tables, (char**) &opt_lock_all_tables, 0, GET_BOOL, NO_ARG,

   0, 0, 0, 0, 0, 0},

  {"flush-logs", 'F', "Flush logs file in server before starting dump. "

   "Note that if you dump many databases at once (using the option "

   "--databases= or --all-databases), the logs will be flushed for "

   "each database dumped. The exception is when using --lock-all-tables "

   "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",

   (char**) &flush_logs, (char**) &flush_logs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

   0, 0},

  {"force", 'f', "Continue even if we get an sql-error.",

   (char**) &ignore_errors, (char**) &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},

  {"hex-blob", OPT_HEXBLOB, "Dump binary strings (BINARY, "

    "VARBINARY, BLOB) in hexadecimal format.",

   (char**) &opt_hex_blob, (char**) &opt_hex_blob, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"host", 'h', "Connect to host.", (char**) &current_host,

   (char**) &current_host, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"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},

  {"include-master-host-port", OPT_DRIZZLEDUMP_INCLUDE_MASTER_HOST_PORT,

   "Adds 'MASTER_HOST=<host>, MASTER_PORT=<port>' to 'CHANGE MASTER TO..' in dump produced with --dump-slave.",

   (char**) &opt_include_master_host_port,

   (char**) &opt_include_master_host_port,

   0, GET_BOOL, NO_ARG,

   0, 0, 0, 0, 0, 0},

  {"insert-ignore", OPT_INSERT_IGNORE, "Insert rows with INSERT IGNORE.",

   (char**) &opt_ignore, (char**) &opt_ignore, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

   0, 0},

  {"lines-terminated-by", OPT_LTB, "Lines in the i.file are terminated by ...",

   (char**) &lines_terminated, (char**) &lines_terminated, 0, GET_STR,

   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"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.",

   (char**) &opt_lock_all_tables, (char**) &opt_lock_all_tables, 0, GET_BOOL, NO_ARG,

   0, 0, 0, 0, 0, 0},

  {"lock-tables", 'l', "Lock all tables for read.", (char**) &lock_tables,

   (char**) &lock_tables, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},

  {"master-data", OPT_MASTER_DATA,

   "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.",

   (char**) &opt_master_data, (char**) &opt_master_data, 0,

   GET_UINT, OPT_ARG, 0, 0, DRIZZLE_OPT_MASTER_DATA_COMMENTED_SQL, 0, 0, 0},

  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET, "",

    (char**) &opt_max_allowed_packet, (char**) &opt_max_allowed_packet, 0,

    GET_ULONG, REQUIRED_ARG, 24*1024*1024, 4096,

   (int64_t) 2L*1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},

  {"net_buffer_length", OPT_NET_BUFFER_LENGTH, "",

    (char**) &opt_net_buffer_length, (char**) &opt_net_buffer_length, 0,

    GET_ULONG, REQUIRED_ARG, 1024*1024L-1025, 4096, 16*1024L*1024L,

   MALLOC_OVERHEAD-1024, 1024, 0},

  {"no-autocommit", OPT_AUTOCOMMIT,

   "Wrap tables with autocommit/commit statements.",

   (char**) &opt_autocommit, (char**) &opt_autocommit, 0, GET_BOOL, NO_ARG,

   0, 0, 0, 0, 0, 0},

  {"no-create-db", 'n',

   "'CREATE DATABASE IF NOT EXISTS db_name;' will not be put in the output. The above line will be added otherwise, if --databases or --all-databases option was given.}.",

   (char**) &opt_create_db, (char**) &opt_create_db, 0, GET_BOOL, NO_ARG, 0, 0,

   0, 0, 0, 0},

  {"no-create-info", 't', "Don't write table creation info.",

   (char**) &opt_no_create_info, (char**) &opt_no_create_info, 0, GET_BOOL,

   NO_ARG, 0, 0, 0, 0, 0, 0},

  {"no-data", 'd', "No row information.", (char**) &opt_no_data,

   (char**) &opt_no_data, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"no-set-names", 'N',

   "Deprecated. Use --skip-set-charset instead.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"opt", OPT_OPTIMIZE,

   "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.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"order-by-primary", OPT_ORDER_BY_PRIMARY,

   "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.",

   (char**) &opt_order_by_primary, (char**) &opt_order_by_primary, 0, GET_BOOL, 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},

  {"port", 'p', "Port number to use for connection.", 

   0, 0, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"quick", 'q', "Don't buffer query, dump directly to stdout.",

   (char**) &quick, (char**) &quick, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},

  {"quote-names",'Q', "Quote table and column names with backticks (`).",

   (char**) &opt_quoted, (char**) &opt_quoted, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0,

   0, 0},

  {"replace", OPT_DRIZZLE_REPLACE_INTO, "Use REPLACE INTO instead of INSERT INTO.",

   (char**) &opt_replace_into, (char**) &opt_replace_into, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

   0, 0},

  {"result-file", 'r',

   "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).",

   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"routines", 'R', "Dump stored routines (functions and procedures).",

     (char**) &opt_routines, (char**) &opt_routines, 0, GET_BOOL,

     NO_ARG, 0, 0, 0, 0, 0, 0},

  /*

    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.

  */

  {"single-transaction", OPT_TRANSACTION,

   "Creates a consistent snapshot by dumping all tables in a single "

   "transaction. Works ONLY for tables stored in storage engines which "

   "support multiversioning (currently only InnoDB does); the dump is NOT "

   "guaranteed to be consistent for other storage engines. "

   "While a --single-transaction dump is in process, to ensure a valid "

   "dump file (correct table contents and binary log position), no other "

   "connection should use the following statements: ALTER TABLE, DROP "

   "TABLE, RENAME TABLE, TRUNCATE TABLE, as consistent snapshot is not "

   "isolated from them. Option automatically turns off --lock-tables.",

   (char**) &opt_single_transaction, (char**) &opt_single_transaction, 0,

   GET_BOOL, NO_ARG,  0, 0, 0, 0, 0, 0},

  {"dump-date", OPT_DUMP_DATE, "Put a dump date to the end of the output.",

   (char**) &opt_dump_date, (char**) &opt_dump_date, 0,

   GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},

  {"skip-opt", OPT_SKIP_OPTIMIZATION,

   "Disable --opt. Disables --add-drop-table, --add-locks, --create-options, --quick, --extended-insert, --lock-tables, --set-charset, and --disable-keys.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"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.",

   (char**) &path, (char**) &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},

  {"show-progress-size", OPT_SHOW_PROGRESS_SIZE, N_("Number of rows before each output progress report (requires --verbose)."),

   (char**) &show_progress_size, (char**) &show_progress_size, 0, GET_ULONG, REQUIRED_ARG,

   10000, 0, 0, 0, 0, 0},

#ifndef DONT_ALLOW_USER_CHANGE

  {"user", 'u', "User for login if not current user.",

   (char**) &current_user, (char**) &current_user, 0, GET_STR, REQUIRED_ARG,

   0, 0, 0, 0, 0, 0},

#endif

  {"verbose", 'v', "Print info about the various stages.",

   (char**) &verbose, (char**) &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!",

   (char**) &where, (char**) &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},

  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}

};

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

static void maybe_exit(int error);

static void die(int error, const char* reason, ...);

static void maybe_die(int error, const char* reason, ...);

static void write_header(FILE *sql_file, char *db_name);

static void print_value(FILE *file, DRIZZLE_RES  *result, DRIZZLE_ROW row,

                        const char *prefix,const char *name,

                        int string_value);

static const char* fetch_named_row(DRIZZLE_RES *result, DRIZZLE_ROW row, const char* name);

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_tables(char *);

static int init_dumping(char *, int init_func(char*));

static int dump_databases(char **);

static int dump_all_databases(void);

static char *quote_name(const char *name, char *buff, bool force);

char check_if_ignore_table(const char *table_name, char *table_type);

static char *primary_key_fields(const char *table_name);

/*

  Print the supplied message if in verbose mode

  SYNOPSIS

    verbose_msg()

    fmt   format specifier

    ...   variable number of parameters

*/

static void verbose_msg(const char *fmt, ...)

{

  va_list args;

  if (!verbose)

    return;

  va_start(args, fmt);

  vfprintf(stderr, fmt, args);

  va_end(args);

  return;

}

/*

  exit with message if ferror(file)

  SYNOPSIS

    check_io()

    file        - checked file

*/

static void check_io(FILE *file)

{

  if (ferror(file))

    die(EX_EOF, _("Got errno %d on write"), errno);

}

static void print_version(void)

{

  printf(_("%s  Ver %s Distrib %s, for %s (%s)\n"),my_progname,DUMP_VERSION,

         drizzle_get_client_info(),SYSTEM_TYPE,MACHINE_TYPE);

} /* print_version */

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);

}

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 DRIZZLE database or table"));

  short_usage_sub();

  print_defaults("drizzle",load_default_groups);

  my_print_help(my_long_options);

  my_print_variables(my_long_options);

} /* usage */

static void short_usage(void)

{

  short_usage_sub();

  printf(_("For more options, use %s --help\n"), my_progname);

}

static void write_header(FILE *sql_file, char *db_name)

{

  if (opt_xml)

  {

    fputs("<?xml version=\"1.0\"?>\n", sql_file);

    /*

      Schema reference.  Allows use of xsi:nil for NULL values and

      xsi:type to define an element's data type.

    */

    fputs("<drizzledump ", sql_file);

    fputs("xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"",

          sql_file);

    fputs(">\n", sql_file);

    check_io(sql_file);

  }

  else if (!opt_compact)

  {

    if (opt_comments)

    {