开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mysqldump.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：82k
源码类别：

MySQL数据库

开发平台：

Visual C++

mysqldump.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB
  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; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* mysqldump.c  - Dump a tables contents and format to an ASCII file
  18. **
  19. ** The author's original notes follow :-
  20. **
  21. ** AUTHOR: Igor Romanenko (igor@frog.kiev.ua)
  22. ** DATE:   December 3, 1994
  23. ** WARRANTY: None, expressed, impressed, implied
  24. **     or other
  25. ** STATUS: Public domain
  26. ** Adapted and optimized for MySQL by
  27. ** Michael Widenius, Sinisa Milivojevic, Jani Tolonen
  28. ** -w --where added 9/10/98 by Jim Faucette
  29. ** slave code by David Saez Padros <david@ols.es>
  30. ** master/autocommit code by Brian Aker <brian@tangent.org>
  31. ** SSL by
  32. ** Andrei Errapart <andreie@no.spam.ee>
  33. ** Tõnu Samuel  <tonu@please.do.not.remove.this.spam.ee>
  34. ** XML by Gary Huntress <ghuntress@mediaone.net> 10/10/01, cleaned up
  35. ** and adapted to mysqldump 05/11/01 by Jani Tolonen
  36. ** Added --single-transaction option 06/06/2002 by Peter Zaitsev
  37. ** 10 Jun 2003: SET NAMES and --no-set-names by Alexander Barkov
  38. */
  40. #define DUMP_VERSION "10.9"
  42. #include <my_global.h>
  43. #include <my_sys.h>
  44. #include <m_string.h>
  45. #include <m_ctype.h>
  46. #include <hash.h>
  48. #include "client_priv.h"
  49. #include "mysql.h"
  50. #include "mysql_version.h"
  51. #include "mysqld_error.h"
  53. /* Exit codes */
  55. #define EX_USAGE 1
  56. #define EX_MYSQLERR 2
  57. #define EX_CONSCHECK 3
  58. #define EX_EOM 4
  59. #define EX_EOF 5 /* ferror for output file was got */
  60. #define EX_ILLEGAL_TABLE 6
  62. /* index into 'show fields from table' */
  64. #define SHOW_FIELDNAME  0
  65. #define SHOW_TYPE  1
  66. #define SHOW_NULL  2
  67. #define SHOW_DEFAULT  4
  68. #define SHOW_EXTRA  5
  70. /* Size of buffer for dump's select query */
  71. #define QUERY_LENGTH 1536
  73. static char *add_load_option(char *ptr, const char *object,
  74.      const char *statement);
  75. static ulong find_set(TYPELIB *lib, const char *x, uint length,
  76.       char **err_pos, uint *err_len);
  78. static char *field_escape(char *to,const char *from,uint length);
  79. static my_bool  verbose=0,tFlag=0,dFlag=0,quick= 1, extended_insert= 1,
  80. lock_tables=1,ignore_errors=0,flush_logs=0,
  81. opt_drop=1,opt_keywords=0,opt_lock=1,opt_compress=0,
  82.                 opt_delayed=0,create_options=1,opt_quoted=0,opt_databases=0,
  83.                 opt_alldbs=0,opt_create_db=0,opt_lock_all_tables=0,
  84.                 opt_set_charset=0,
  85. opt_autocommit=0,opt_disable_keys=1,opt_xml=0,
  86. opt_delete_master_logs=0, tty_password=0,
  87. opt_single_transaction=0, opt_comments= 0, opt_compact= 0,
  88. opt_hex_blob=0, opt_order_by_primary=0, opt_ignore=0,
  89.                 opt_complete_insert= 0, opt_drop_database= 0;
  90. static ulong opt_max_allowed_packet, opt_net_buffer_length;
  91. static MYSQL mysql_connection,*sock=0;
  92. static my_bool insert_pat_inited=0;
  93. static DYNAMIC_STRING insert_pat;
  94. static char  *opt_password=0,*current_user=0,
  95.              *current_host=0,*path=0,*fields_terminated=0,
  96.              *lines_terminated=0, *enclosed=0, *opt_enclosed=0, *escaped=0,
  97.              *where=0, *order_by=0,
  98.              *opt_compatible_mode_str= 0,
  99.              *err_ptr= 0;
  100. static char compatible_mode_normal_str[255];
  101. static ulong opt_compatible_mode= 0;
  102. #define MYSQL_OPT_MASTER_DATA_EFFECTIVE_SQL 1
  103. #define MYSQL_OPT_MASTER_DATA_COMMENTED_SQL 2
  104. static uint     opt_mysql_port= 0, err_len= 0, opt_master_data;
  105. static my_string opt_mysql_unix_port=0;
  106. static int   first_error=0;
  107. static DYNAMIC_STRING extended_row;
  108. #include <sslopt-vars.h>
  109. FILE  *md_result_file;
  110. #ifdef HAVE_SMEM
  111. static char *shared_memory_base_name=0;
  112. #endif
  113. static uint opt_protocol= 0;
  114. /*
  115.   Constant for detection of default value of default_charset.
  116.   If default_charset is equal to mysql_universal_client_charset, then
  117.   it is the default value which assigned at the very beginning of main().
  118. */
  119. static const char *mysql_universal_client_charset=
  120.   MYSQL_UNIVERSAL_CLIENT_CHARSET;
  121. static char *default_charset;
  122. static CHARSET_INFO *charset_info= &my_charset_latin1;
  123. const char *default_dbug_option="d:t:o,/tmp/mysqldump.trace";
  125. const char *compatible_mode_names[]=
  126. {
  127.   "MYSQL323", "MYSQL40", "POSTGRESQL", "ORACLE", "MSSQL", "DB2",
  128.   "MAXDB", "NO_KEY_OPTIONS", "NO_TABLE_OPTIONS", "NO_FIELD_OPTIONS",
  129.   "ANSI",
  130.   NullS
  131. };
  132. #define MASK_ANSI_QUOTES 
  133. (
  134.  (1<<2)  | /* POSTGRESQL */
  135.  (1<<3)  | /* ORACLE     */
  136.  (1<<4)  | /* MSSQL      */
  137.  (1<<5)  | /* DB2        */
  138.  (1<<6)  | /* MAXDB      */
  139.  (1<<10)   /* ANSI       */
  140. )
  141. TYPELIB compatible_mode_typelib= {array_elements(compatible_mode_names) - 1,
  142.   "", compatible_mode_names, NULL};
  144. HASH ignore_table;
  146. static struct my_option my_long_options[] =
  147. {
  148.   {"all", 'a', "Deprecated. Use --create-options instead.",
  149.    (gptr*) &create_options, (gptr*) &create_options, 0, GET_BOOL, NO_ARG, 1,
  150.    0, 0, 0, 0, 0},
  151.   {"all-databases", 'A',
  152.    "Dump all the databases. This will be same as --databases with all databases selected.",
  153.    (gptr*) &opt_alldbs, (gptr*) &opt_alldbs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
  154.    0, 0},
  155.   {"add-drop-database", OPT_DROP_DATABASE, "Add a 'DROP DATABASE' before each create.",
  156.    (gptr*) &opt_drop_database, (gptr*) &opt_drop_database, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,
  157.    0},
  158.   {"add-drop-table", OPT_DROP, "Add a 'drop table' before each create.",
  159.    (gptr*) &opt_drop, (gptr*) &opt_drop, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0,
  160.    0},
  161.   {"add-locks", OPT_LOCKS, "Add locks around insert statements.",
  162.    (gptr*) &opt_lock, (gptr*) &opt_lock, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0,
  163.    0},
  164.   {"allow-keywords", OPT_KEYWORDS,
  165.    "Allow creation of column names that are keywords.", (gptr*) &opt_keywords,
  166.    (gptr*) &opt_keywords, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  167. #ifdef __NETWARE__
  168.   {"auto-close", OPT_AUTO_CLOSE, "Auto close the screen on exit for Netware.",
  169.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  170. #endif
  171.   {"character-sets-dir", OPT_CHARSETS_DIR,
  172.    "Directory where character sets are.", (gptr*) &charsets_dir,
  173.    (gptr*) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  174.   {"comments", 'i', "Write additional information.",
  175.    (gptr*) &opt_comments, (gptr*) &opt_comments, 0, GET_BOOL, NO_ARG,
  176.    1, 0, 0, 0, 0, 0},
  177.   {"compatible", OPT_COMPATIBLE,
  178.    "Change the dump to be compatible with a given mode. By default tables are dumped in a format optimized for MySQL. Legal modes are: ansi, mysql323, mysql40, postgresql, oracle, mssql, db2, maxdb, no_key_options, no_table_options, no_field_options. One can use several modes separated by commas. Note: Requires MySQL server version 4.1.0 or higher. This option is ignored with earlier server versions.",
  179.    (gptr*) &opt_compatible_mode_str, (gptr*) &opt_compatible_mode_str, 0,
  180.    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  181.   {"compact", OPT_COMPACT,
  182.    "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",
  183.    (gptr*) &opt_compact, (gptr*) &opt_compact, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
  184.    0, 0},
  185.   {"complete-insert", 'c', "Use complete insert statements.",
  186.    (gptr*) &opt_complete_insert, (gptr*) &opt_complete_insert, 0, GET_BOOL,
  187.    NO_ARG, 0, 0, 0, 0, 0, 0},
  188.   {"compress", 'C', "Use compression in server/client protocol.",
  189.    (gptr*) &opt_compress, (gptr*) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
  190.    0, 0, 0},
  191.   {"create-options", OPT_CREATE_OPTIONS,
  192.    "Include all MySQL specific create options.",
  193.    (gptr*) &create_options, (gptr*) &create_options, 0, GET_BOOL, NO_ARG, 1,
  194.    0, 0, 0, 0, 0},
  195.   {"databases", 'B',
  196.    "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.",
  197.    (gptr*) &opt_databases, (gptr*) &opt_databases, 0, GET_BOOL, NO_ARG, 0, 0,
  198.    0, 0, 0, 0},
  199. #ifdef DBUG_OFF
  200.   {"debug", '#', "This is a non-debug version. Catch this and exit",
  201.    0,0, 0, GET_DISABLED, OPT_ARG, 0, 0, 0, 0, 0, 0},
  202. #else
  203.   {"debug", '#', "Output debug log", (gptr*) &default_dbug_option,
  204.    (gptr*) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  205. #endif
  206.   {"default-character-set", OPT_DEFAULT_CHARSET,
  207.    "Set the default character set.", (gptr*) &default_charset,
  208.    (gptr*) &default_charset, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  209.   {"delayed-insert", OPT_DELAYED, "Insert rows with INSERT DELAYED.",
  210.    (gptr*) &opt_delayed, (gptr*) &opt_delayed, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
  211.    0, 0},
  212.   {"delete-master-logs", OPT_DELETE_MASTER_LOGS,
  213.    "Delete logs on master after backup. This automatically enables --master-data.",
  214.    (gptr*) &opt_delete_master_logs, (gptr*) &opt_delete_master_logs, 0,
  215.    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  216.   {"disable-keys", 'K',
  217.    "'/*!40000 ALTER TABLE tb_name DISABLE KEYS */; and '/*!40000 ALTER TABLE tb_name ENABLE KEYS */; will be put in the output.", (gptr*) &opt_disable_keys,
  218.    (gptr*) &opt_disable_keys, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
  219.   {"extended-insert", 'e',
  220.    "Allows utilization of the new, much faster INSERT syntax.",
  221.    (gptr*) &extended_insert, (gptr*) &extended_insert, 0, GET_BOOL, NO_ARG,
  222.    1, 0, 0, 0, 0, 0},
  223.   {"fields-terminated-by", OPT_FTB,
  224.    "Fields in the textfile are terminated by ...", (gptr*) &fields_terminated,
  225.    (gptr*) &fields_terminated, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  226.   {"fields-enclosed-by", OPT_ENC,
  227.    "Fields in the importfile are enclosed by ...", (gptr*) &enclosed,
  228.    (gptr*) &enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0 ,0, 0},
  229.   {"fields-optionally-enclosed-by", OPT_O_ENC,
  230.    "Fields in the i.file are opt. enclosed by ...", (gptr*) &opt_enclosed,
  231.    (gptr*) &opt_enclosed, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0 ,0, 0},
  232.   {"fields-escaped-by", OPT_ESC, "Fields in the i.file are escaped by ...",
  233.    (gptr*) &escaped, (gptr*) &escaped, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  234.   {"first-slave", 'x', "Deprecated, renamed to --lock-all-tables.",
  235.    (gptr*) &opt_lock_all_tables, (gptr*) &opt_lock_all_tables, 0, GET_BOOL, NO_ARG,
  236.    0, 0, 0, 0, 0, 0},
  237.   {"flush-logs", 'F', "Flush logs file in server before starting dump. "
  238.    "Note that if you dump many databases at once (using the option "
  239.    "--databases= or --all-databases), the logs will be flushed for "
  240.    "each database dumped. The exception is when using --lock-all-tables "
  241.    "or --master-data: "
  242.    "in this case the logs will be flushed only once, corresponding "
  243.    "to the moment all tables are locked. So if you want your dump and "
  244.    "the log flush to happen at the same exact moment you should use "
  245.    "--lock-all-tables or --master-data with --flush-logs",
  246.    (gptr*) &flush_logs, (gptr*) &flush_logs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
  247.    0, 0},
  248.   {"force", 'f', "Continue even if we get an sql-error.",
  249.    (gptr*) &ignore_errors, (gptr*) &ignore_errors, 0, GET_BOOL, NO_ARG,
  250.    0, 0, 0, 0, 0, 0},
  251.   {"help", '?', "Display this help message and exit.", 0, 0, 0, GET_NO_ARG,
  252.    NO_ARG, 0, 0, 0, 0, 0, 0},
  253.   {"hex-blob", OPT_HEXBLOB, "Dump binary strings (BINARY, "
  254.     "VARBINARY, BLOB) in hexadecimal format.",
  255.    (gptr*) &opt_hex_blob, (gptr*) &opt_hex_blob, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  256.   {"host", 'h', "Connect to host.", (gptr*) &current_host,
  257.    (gptr*) &current_host, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  258.   {"ignore-table", OPT_IGNORE_TABLE,
  259.    "Do not dump the specified table. To specify more than one table to ignore, "
  260.    "use the directive multiple times, once for each table.  Each table must "
  261.    "be specified with both database and table names, e.g. --ignore-table=database.table",
  262.    0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  263.   {"insert-ignore", OPT_INSERT_IGNORE, "Insert rows with INSERT IGNORE.",
  264.    (gptr*) &opt_ignore, (gptr*) &opt_ignore, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
  265.    0, 0},
  266.   {"lines-terminated-by", OPT_LTB, "Lines in the i.file are terminated by ...",
  267.    (gptr*) &lines_terminated, (gptr*) &lines_terminated, 0, GET_STR,
  268.    REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  269.   {"lock-all-tables", 'x', "Locks all tables across all databases. This " 
  270.    "is achieved by taking a global read lock for the duration of the whole "
  271.    "dump. Automatically turns --single-transaction and --lock-tables off.",
  272.    (gptr*) &opt_lock_all_tables, (gptr*) &opt_lock_all_tables, 0, GET_BOOL, NO_ARG,
  273.    0, 0, 0, 0, 0, 0},
  274.   {"lock-tables", 'l', "Lock all tables for read.", (gptr*) &lock_tables,
  275.    (gptr*) &lock_tables, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
  276.   {"master-data", OPT_MASTER_DATA,
  277.    "This causes the binary log position and filename to be appended to the "
  278.    "output. If equal to 1, will print it as a CHANGE MASTER command; if equal"
  279.    " to 2, that command will be prefixed with a comment symbol. "
  280.    "This option will turn --lock-all-tables on, unless "
  281.    "--single-transaction is specified too (in which case a "
  282.    "global read lock is only taken a short time at the beginning of the dump "
  283.    "- don't forget to read about --single-transaction below). In all cases "
  284.    "any action on logs will happen at the exact moment of the dump."
  285.    "Option automatically turns --lock-tables off.",
  286.    (gptr*) &opt_master_data, (gptr*) &opt_master_data, 0,
  287.    GET_UINT, OPT_ARG, 0, 0, MYSQL_OPT_MASTER_DATA_COMMENTED_SQL, 0, 0, 0},
  288.   {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET, "",
  289.     (gptr*) &opt_max_allowed_packet, (gptr*) &opt_max_allowed_packet, 0,
  290.     GET_ULONG, REQUIRED_ARG, 24*1024*1024, 4096, 
  291.    (longlong) 2L*1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},
  292.   {"net_buffer_length", OPT_NET_BUFFER_LENGTH, "",
  293.     (gptr*) &opt_net_buffer_length, (gptr*) &opt_net_buffer_length, 0,
  294.     GET_ULONG, REQUIRED_ARG, 1024*1024L-1025, 4096, 16*1024L*1024L,
  295.    MALLOC_OVERHEAD-1024, 1024, 0},
  296.   {"no-autocommit", OPT_AUTOCOMMIT,
  297.    "Wrap tables with autocommit/commit statements.",
  298.    (gptr*) &opt_autocommit, (gptr*) &opt_autocommit, 0, GET_BOOL, NO_ARG,
  299.    0, 0, 0, 0, 0, 0},
  300.   {"no-create-db", 'n',
  301.    "'CREATE DATABASE /*!32312 IF NOT EXISTS*/ db_name;' will not be put in the output. The above line will be added otherwise, if --databases or --all-databases option was given.}.",
  302.    (gptr*) &opt_create_db, (gptr*) &opt_create_db, 0, GET_BOOL, NO_ARG, 0, 0,
  303.    0, 0, 0, 0},
  304.   {"no-create-info", 't', "Don't write table creation info.",
  305.    (gptr*) &tFlag, (gptr*) &tFlag, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  306.   {"no-data", 'd', "No row information.", (gptr*) &dFlag, (gptr*) &dFlag, 0,
  307.    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  308.   {"no-set-names", 'N',
  309.    "Deprecated. Use --skip-set-charset instead.",
  310.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  311.   {"opt", OPT_OPTIMIZE,
  312.    "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.",
  313.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  314.   {"order-by-primary", OPT_ORDER_BY_PRIMARY,
  315.    "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.",
  316.    (gptr*) &opt_order_by_primary, (gptr*) &opt_order_by_primary, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  317.   {"password", 'p',
  318.    "Password to use when connecting to server. If password is not given it's solicited on the tty.",
  319.    0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  320. #ifdef __WIN__
  321.   {"pipe", 'W', "Use named pipes to connect to server.", 0, 0, 0, GET_NO_ARG,
  322.    NO_ARG, 0, 0, 0, 0, 0, 0},
  323. #endif
  324.   {"port", 'P', "Port number to use for connection.", (gptr*) &opt_mysql_port,
  325.    (gptr*) &opt_mysql_port, 0, GET_UINT, REQUIRED_ARG, MYSQL_PORT, 0, 0, 0, 0,
  326.    0},
  327.   {"protocol", OPT_MYSQL_PROTOCOL, "The protocol of connection (tcp,socket,pipe,memory).",
  328.    0, 0, 0, GET_STR,  REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  329.   {"quick", 'q', "Don't buffer query, dump directly to stdout.",
  330.    (gptr*) &quick, (gptr*) &quick, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
  331.   {"quote-names",'Q', "Quote table and column names with backticks (`).",
  332.    (gptr*) &opt_quoted, (gptr*) &opt_quoted, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0,
  333.    0, 0},
  334.   {"result-file", 'r',
  335.    "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).",
  336.    0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  337.   {"set-charset", OPT_SET_CHARSET,
  338.    "Add 'SET NAMES default_character_set' to the output. Enabled by default; suppress with --skip-set-charset.",
  339.    (gptr*) &opt_set_charset, (gptr*) &opt_set_charset, 0, GET_BOOL, NO_ARG, 1,
  340.    0, 0, 0, 0, 0},
  341.   {"set-variable", 'O',
  342.    "Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value.",
  343.    0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  344. #ifdef HAVE_SMEM
  345.   {"shared-memory-base-name", OPT_SHARED_MEMORY_BASE_NAME,
  346.    "Base name of shared memory.", (gptr*) &shared_memory_base_name, (gptr*) &shared_memory_base_name,
  347.    0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  348. #endif
  349.   /*
  350.     Note that the combination --single-transaction --master-data
  351.     will give bullet-proof binlog position only if server >=4.1.3. That's the
  352.     old "FLUSH TABLES WITH READ LOCK does not block commit" fixed bug.
  353.   */
  354.   {"single-transaction", OPT_TRANSACTION,
  355.    "Creates a consistent snapshot by dumping all tables in a single "
  356.    "transaction. Works ONLY for tables stored in storage engines which "
  357.    "support multiversioning (currently only InnoDB does); the dump is NOT "
  358.    "guaranteed to be consistent for other storage engines. Option "
  359.    "automatically turns off --lock-tables.",
  360.    (gptr*) &opt_single_transaction, (gptr*) &opt_single_transaction, 0,
  361.    GET_BOOL, NO_ARG,  0, 0, 0, 0, 0, 0},
  362.   {"skip-opt", OPT_SKIP_OPTIMIZATION,
  363.    "Disable --opt. Disables --add-drop-table, --add-locks, --create-options, --quick, --extended-insert, --lock-tables, --set-charset, and --disable-keys.",
  364.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  365.   {"socket", 'S', "Socket file to use for connection.",
  366.    (gptr*) &opt_mysql_unix_port, (gptr*) &opt_mysql_unix_port, 0, GET_STR,
  367.    REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  368. #include <sslopt-longopts.h>
  369.   {"tab",'T',
  370.    "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.",
  371.    (gptr*) &path, (gptr*) &path, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  372.   {"tables", OPT_TABLES, "Overrides option --databases (-B).",
  373.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  374. #ifndef DONT_ALLOW_USER_CHANGE
  375.   {"user", 'u', "User for login if not current user.",
  376.    (gptr*) &current_user, (gptr*) &current_user, 0, GET_STR, REQUIRED_ARG,
  377.    0, 0, 0, 0, 0, 0},
  378. #endif
  379.   {"verbose", 'v', "Print info about the various stages.",
  380.    (gptr*) &verbose, (gptr*) &verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  381.   {"version",'V', "Output version information and exit.", 0, 0, 0,
  382.    GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  383.   {"where", 'w', "Dump only selected records; QUOTES mandatory!",
  384.    (gptr*) &where, (gptr*) &where, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  385.   {"xml", 'X', "Dump a database as well formed XML.", 0, 0, 0, GET_NO_ARG,
  386.    NO_ARG, 0, 0, 0, 0, 0, 0},
  387.   { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
  388. };
  390. static const char *load_default_groups[]= { "mysqldump","client",0 };
  392. static void safe_exit(int error);
  393. static void write_header(FILE *sql_file, char *db_name);
  394. static void print_value(FILE *file, MYSQL_RES  *result, MYSQL_ROW row,
  395. const char *prefix,const char *name,
  396. int string_value);
  397. static int dump_selected_tables(char *db, char **table_names, int tables);
  398. static int dump_all_tables_in_db(char *db);
  399. static int init_dumping(char *);
  400. static int dump_databases(char **);
  401. static int dump_all_databases();
  402. static char *quote_name(const char *name, char *buff, my_bool force);
  403. static const char *check_if_ignore_table(const char *table_name);
  404. static char *primary_key_fields(const char *table_name);
  406. #include <help_start.h>
  408. /*
  409.   exit with message if ferror(file)
  410.   
  411.   SYNOPSIS
  412.     check_io()
  413.     file - checked file
  414. */
  416. void check_io(FILE *file)
  417. {
  418.   if (ferror(file))
  419.   {
  420.     fprintf(stderr, "%s: Got errno %d on writen", my_progname, errno);
  421.     safe_exit(EX_EOF);
  422.   }
  423. }
  425. static void print_version(void)
  426. {
  427.   printf("%s  Ver %s Distrib %s, for %s (%s)n",my_progname,DUMP_VERSION,
  428.          MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
  429.   NETWARE_SET_SCREEN_MODE(1);
  430. } /* print_version */
  433. static void short_usage_sub(void)
  434. {
  435.   printf("Usage: %s [OPTIONS] database [tables]n", my_progname);
  436.   printf("OR     %s [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...]n",
  437.  my_progname);
  438.   printf("OR     %s [OPTIONS] --all-databases [OPTIONS]n", my_progname);
  439.   NETWARE_SET_SCREEN_MODE(1);
  440. }
  443. static void usage(void)
  444. {
  445.   print_version();
  446.   puts("By Igor Romanenko, Monty, Jani & Sinisa");
  447.   puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,nand you are welcome to modify and redistribute it under the GPL licensen");
  448.   puts("Dumping definition and data mysql database or table");
  449.   short_usage_sub();
  450.   print_defaults("my",load_default_groups);
  451.   my_print_help(my_long_options);
  452.   my_print_variables(my_long_options);
  453. } /* usage */
  456. static void short_usage(void)
  457. {
  458.   short_usage_sub();
  459.   printf("For more options, use %s --helpn", my_progname);
  460. }
  462. #include <help_end.h>
  465. static void write_header(FILE *sql_file, char *db_name)
  466. {
  467.   if (opt_xml)
  468.   {
  469.     fputs("<?xml version="1.0"?>n", sql_file);
  470.     fputs("<mysqldump ", sql_file);
  471.     fputs("xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"",
  472.           sql_file);
  473.     fputs(">n", sql_file);
  474.     check_io(sql_file);
  475.   }
  476.   else if (!opt_compact)
  477.   {
  478.     if (opt_comments)
  479.     {
  480.       fprintf(sql_file, "-- MySQL dump %sn--n", DUMP_VERSION);
  481.       fprintf(sql_file, "-- Host: %s    Database: %sn",
  482.       current_host ? current_host : "localhost", db_name ? db_name :
  483.       "");
  484.       fputs("-- ------------------------------------------------------n",
  485.     sql_file);
  486.       fprintf(sql_file, "-- Server versiont%sn",
  487.       mysql_get_server_info(&mysql_connection));
  488.     }
  489.     if (opt_set_charset)
  490.       fprintf(sql_file,
  491. "n/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;"
  492. "n/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;"
  493. "n/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;"
  494. "n/*!40101 SET NAMES %s */;n",default_charset);
  495.     if (!path)
  496.     {
  497.       fprintf(md_result_file,"
  498. /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;n
  499. /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;n
  500. ");
  501.     }
  502.     fprintf(sql_file,
  503.     "/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='%s%s%s' */;n"
  504.     "/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;n",
  505.     path?"":"NO_AUTO_VALUE_ON_ZERO",compatible_mode_normal_str[0]==0?"":",",
  506.     compatible_mode_normal_str);
  507.     check_io(sql_file);
  508.   }
  509. } /* write_header */
  512. static void write_footer(FILE *sql_file)
  513. {
  514.   if (opt_xml)
  515.   {
  516.     fputs("</mysqldump>n", sql_file);
  517.     check_io(sql_file);
  518.   }
  519.   else if (!opt_compact)
  520.   {
  521.     fprintf(sql_file,"n/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;n");
  522.     if (!path)
  523.     {
  524.       fprintf(md_result_file,"
  525. /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;n
  526. /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;n");
  527.     }
  528.     if (opt_set_charset)
  529.       fprintf(sql_file,
  530. "/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;n"
  531. "/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;n"
  532. "/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;n");
  533.     fprintf(sql_file,
  534.     "/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;n");
  535.     fputs("n", sql_file);
  536.     check_io(sql_file);
  537.   }
  538. } /* write_footer */
  540. static void free_table_ent(char *key)
  542. {
  543.   my_free((gptr) key, MYF(0));
  544. }
  547. byte* get_table_key(const char *entry, uint *length,
  548. my_bool not_used __attribute__((unused)))
  549. {
  550.   *length= strlen(entry);
  551.   return (byte*) entry;
  552. }
  555. void init_table_rule_hash(HASH* h)
  556. {
  557.   if (hash_init(h, charset_info, 16, 0, 0,
  558.                 (hash_get_key) get_table_key,
  559.                 (hash_free_key) free_table_ent, 0))
  560.     exit(EX_EOM);
  561. }
  563. static my_bool
  564. get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
  565.        char *argument)
  566. {
  567.   switch (optid) {
  568. #ifdef __NETWARE__
  569.   case OPT_AUTO_CLOSE:
  570.     setscreenmode(SCR_AUTOCLOSE_ON_EXIT);
  571.     break;
  572. #endif
  573.   case 'p':
  574.     if (argument)
  575.     {
  576.       char *start=argument;
  577.       my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
  578.       opt_password=my_strdup(argument,MYF(MY_FAE));
  579.       while (*argument) *argument++= 'x'; /* Destroy argument */
  580.       if (*start)
  581. start[1]=0; /* Cut length of argument */
  582.       tty_password= 0;
  583.     }
  584.     else
  585.       tty_password=1;
  586.     break;
  587.   case 'r':
  588.     if (!(md_result_file = my_fopen(argument, O_WRONLY | FILE_BINARY,
  589.     MYF(MY_WME))))
  590.       exit(1);
  591.     break;
  592.   case 'W':
  593. #ifdef __WIN__
  594.     opt_protocol = MYSQL_PROTOCOL_PIPE;
  595. #endif
  596.     break;
  597.   case 'N':
  598.     opt_set_charset= 0;
  599.     break;
  600.   case 'T':
  601.     opt_disable_keys=0;
  602.     break;
  603.   case '#':
  604.     DBUG_PUSH(argument ? argument : default_dbug_option);
  605.     break;
  606. #include <sslopt-case.h>
  607.   case 'V': print_version(); exit(0);
  608.   case 'X':
  609.     opt_xml = 1;
  610.     extended_insert= opt_drop= opt_lock= 
  611.       opt_disable_keys= opt_autocommit= opt_create_db= 0;
  612.     break;
  613.   case 'I':
  614.   case '?':
  615.     usage();
  616.     exit(0);
  617.   case (int) OPT_MASTER_DATA:
  618.     if (!argument) /* work like in old versions */
  619.       opt_master_data= MYSQL_OPT_MASTER_DATA_EFFECTIVE_SQL;
  620.     break;
  621.   case (int) OPT_OPTIMIZE:
  622.     extended_insert= opt_drop= opt_lock= quick= create_options=
  623.       opt_disable_keys= lock_tables= opt_set_charset= 1;
  624.     break;
  625.   case (int) OPT_SKIP_OPTIMIZATION:
  626.     extended_insert= opt_drop= opt_lock= quick= create_options=
  627.       opt_disable_keys= lock_tables= opt_set_charset= 0;
  628.     break;
  629.   case (int) OPT_COMPACT:
  630.   if (opt_compact)
  631.   {
  632.     opt_comments= opt_drop= opt_disable_keys= opt_lock= 0;
  633.     opt_set_charset= 0;
  634.   }
  635.   case (int) OPT_TABLES:
  636.     opt_databases=0;
  637.     break;
  638.   case (int) OPT_IGNORE_TABLE:
  639.   {
  640.     if (!strchr(argument, '.'))
  641.     {
  642.       fprintf(stderr, "Illegal use of option --ignore-table=<database>.<table>n");
  643.       exit(1);
  644.     }
  645.     if (!hash_inited(&ignore_table))
  646.       init_table_rule_hash(&ignore_table);
  648.     if (my_hash_insert(&ignore_table, (byte*)my_strdup(argument, MYF(0))))
  649.       exit(EX_EOM);
  650.     break;
  651.   }
  652.   case (int) OPT_COMPATIBLE:
  653.     {
  654.       char buff[255];
  655.       char *end= compatible_mode_normal_str;
  656.       int i;
  657.       ulong mode;
  659.       opt_quoted= 1;
  660.       opt_set_charset= 0;
  661.       opt_compatible_mode_str= argument;
  662.       opt_compatible_mode= find_set(&compatible_mode_typelib,
  663.     argument, strlen(argument),
  664.     &err_ptr, &err_len);
  665.       if (err_len)
  666.       {
  667. strmake(buff, err_ptr, min(sizeof(buff), err_len));
  668. fprintf(stderr, "Invalid mode to --compatible: %sn", buff);
  669. exit(1);
  670.       }
  671. #if !defined(DBUG_OFF)
  672.       {
  673. uint size_for_sql_mode= 0;
  674. const char **ptr;
  675. for (ptr= compatible_mode_names; *ptr; ptr++)
  676.   size_for_sql_mode+= strlen(*ptr);
  677. size_for_sql_mode+= sizeof(compatible_mode_names)-1;
  678. DBUG_ASSERT(sizeof(compatible_mode_normal_str)>=size_for_sql_mode);
  679.       }
  680. #endif
  681.       mode= opt_compatible_mode;
  682.       for (i= 0, mode= opt_compatible_mode; mode; mode>>= 1, i++)
  683.       {
  684. if (mode & 1)
  685. {
  686.   end= strmov(end, compatible_mode_names[i]);
  687.   end= strmov(end, ",");
  688. }
  689.       }
  690.       if (end!=compatible_mode_normal_str)
  691. end[-1]= 0;
  692.       /* 
  693.         Set charset to the default compiled value if it hasn't
  694.         been reset yet by --default-character-set=xxx.
  695.       */
  696.       if (default_charset == mysql_universal_client_charset)
  697.         default_charset= (char*) MYSQL_DEFAULT_CHARSET_NAME;
  698.       break;
  699.     }
  700.   case (int) OPT_MYSQL_PROTOCOL:
  701.     {
  702.       if ((opt_protocol= find_type(argument, &sql_protocol_typelib,0)) <= 0)
  703.       {
  704. fprintf(stderr, "Unknown option to protocol: %sn", argument);
  705. exit(1);
  706.       }
  707.       break;
  708.     }
  709.   }
  710.   return 0;
  711. }
  713. static int get_options(int *argc, char ***argv)
  714. {
  715.   int ho_error;
  716.   MYSQL_PARAMETERS *mysql_params= mysql_get_parameters();
  718.   opt_max_allowed_packet= *mysql_params->p_max_allowed_packet;
  719.   opt_net_buffer_length= *mysql_params->p_net_buffer_length;
  721.   md_result_file= stdout;
  722.   load_defaults("my",load_default_groups,argc,argv);
  724.   if ((ho_error=handle_options(argc, argv, my_long_options, get_one_option)))
  725.     exit(ho_error);
  727.   *mysql_params->p_max_allowed_packet= opt_max_allowed_packet;
  728.   *mysql_params->p_net_buffer_length= opt_net_buffer_length;
  730.   if (opt_delayed)
  731.     opt_lock=0; /* Can't have lock with delayed */
  732.   if (!path && (enclosed || opt_enclosed || escaped || lines_terminated ||
  733. fields_terminated))
  734.   {
  735.     fprintf(stderr,
  736.     "%s: You must use option --tab with --fields-...n", my_progname);
  737.     return(1);
  738.   }
  740.   /* Ensure consistency of the set of binlog & locking options */
  741.   if (opt_delete_master_logs && !opt_master_data)
  742.     opt_master_data= MYSQL_OPT_MASTER_DATA_COMMENTED_SQL;
  743.   if (opt_single_transaction && opt_lock_all_tables)
  744.   {
  745.     fprintf(stderr, "%s: You can't use --single-transaction and "
  746.             "--lock-all-tables at the same time.n", my_progname);
  747.     return(1);
  748.   }  
  749.   if (opt_master_data)
  750.     opt_lock_all_tables= !opt_single_transaction;
  751.   if (opt_single_transaction || opt_lock_all_tables)
  752.     lock_tables= 0;
  753.   if (enclosed && opt_enclosed)
  754.   {
  755.     fprintf(stderr, "%s: You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.n", my_progname);
  756.     return(1);
  757.   }
  758.   if ((opt_databases || opt_alldbs) && path)
  759.   {
  760.     fprintf(stderr,
  761.     "%s: --databases or --all-databases can't be used with --tab.n",
  762.     my_progname);
  763.     return(1);
  764.   }
  765.   if (strcmp(default_charset, charset_info->csname) &&
  766.       !(charset_info= get_charset_by_csname(default_charset, 
  767.        MY_CS_PRIMARY, MYF(MY_WME))))
  768.     exit(1);
  769.   if ((*argc < 1 && !opt_alldbs) || (*argc > 0 && opt_alldbs))
  770.   {
  771.     short_usage();
  772.     return 1;
  773.   }
  774.   if (tty_password)
  775.     opt_password=get_tty_password(NullS);
  776.   return(0);
  777. } /* get_options */
  780. /*
  781. ** DBerror -- prints mysql error message and exits the program.
  782. */
  783. static void DBerror(MYSQL *mysql, const char *when)
  784. {
  785.   DBUG_ENTER("DBerror");
  786.   my_printf_error(0,"Got error: %d: %s %s", MYF(0),
  787.   mysql_errno(mysql), mysql_error(mysql), when);
  788.   safe_exit(EX_MYSQLERR);
  789.   DBUG_VOID_RETURN;
  790. } /* DBerror */
  793. /*
  794.   Sends a query to server, optionally reads result, prints error message if
  795.   some.
  797.   SYNOPSIS
  798.     mysql_query_with_error_report()
  799.     mysql_con       connection to use
  800.     res             if non zero, result will be put there with mysql_store_result
  801.     query           query to send to server
  803.   RETURN VALUES
  804.     0               query sending and (if res!=0) result reading went ok
  805.     1               error
  806. */
  807.   
  808. static int mysql_query_with_error_report(MYSQL *mysql_con, MYSQL_RES **res,
  809.                                          const char *query)
  810. {
  811.   if (mysql_query(mysql_con, query) ||
  812.       (res && !((*res)= mysql_store_result(mysql_con))))
  813.   {
  814.     my_printf_error(0, "%s: Couldn't execute '%s': %s (%d)",
  815.                     MYF(0), my_progname, query,
  816.                     mysql_error(mysql_con), mysql_errno(mysql_con));
  817.     return 1;
  818.   }
  819.   return 0;
  820. }
  823. static void safe_exit(int error)
  824. {
  825.   if (!first_error)
  826.     first_error= error;
  827.   if (ignore_errors)
  828.     return;
  829.   if (sock)
  830.     mysql_close(sock);
  831.   exit(error);
  832. }
  833. /* safe_exit */
  836. /*
  837. ** dbConnect -- connects to the host and selects DB.
  838. */
  839. static int dbConnect(char *host, char *user,char *passwd)
  840. {
  841.   char buff[20+FN_REFLEN];
  842.   DBUG_ENTER("dbConnect");
  843.   if (verbose)
  844.   {
  845.     fprintf(stderr, "-- Connecting to %s...n", host ? host : "localhost");
  846.   }
  847.   mysql_init(&mysql_connection);
  848.   if (opt_compress)
  849.     mysql_options(&mysql_connection,MYSQL_OPT_COMPRESS,NullS);
  850. #ifdef HAVE_OPENSSL
  851.   if (opt_use_ssl)
  852.     mysql_ssl_set(&mysql_connection, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
  853.   opt_ssl_capath, opt_ssl_cipher);
  854. #endif
  855.   if (opt_protocol)
  856.     mysql_options(&mysql_connection,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);
  857. #ifdef HAVE_SMEM
  858.   if (shared_memory_base_name)
  859.     mysql_options(&mysql_connection,MYSQL_SHARED_MEMORY_BASE_NAME,shared_memory_base_name);
  860. #endif
  861.   mysql_options(&mysql_connection, MYSQL_SET_CHARSET_NAME, default_charset);
  862.   if (!(sock= mysql_real_connect(&mysql_connection,host,user,passwd,
  863.          NULL,opt_mysql_port,opt_mysql_unix_port,
  864.          0)))
  865.   {
  866.     DBerror(&mysql_connection, "when trying to connect");
  867.     return 1;
  868.   }
  869.   /*
  870.     Don't dump SET NAMES with a pre-4.1 server (bug#7997).
  871.   */
  872.   if (mysql_get_server_version(&mysql_connection) < 40100)
  873.     opt_set_charset= 0;
  874.   /*
  875.     As we're going to set SQL_MODE, it would be lost on reconnect, so we
  876.     cannot reconnect.
  877.   */
  878.   sock->reconnect= 0;
  879.   my_snprintf(buff, sizeof(buff), "/*!40100 SET @@SQL_MODE='%s' */",
  880.       compatible_mode_normal_str);
  881.   if (mysql_query_with_error_report(sock, 0, buff))
  882.   {
  883.     mysql_close(sock);
  884.     safe_exit(EX_MYSQLERR);
  885.     return 1;
  886.   }
  887.   return 0;
  888. } /* dbConnect */
  891. /*
  892. ** dbDisconnect -- disconnects from the host.
  893. */
  894. static void dbDisconnect(char *host)
  895. {
  896.   if (verbose)
  897.     fprintf(stderr, "-- Disconnecting from %s...n", host ? host : "localhost");
  898.   mysql_close(sock);
  899. } /* dbDisconnect */
  902. static void unescape(FILE *file,char *pos,uint length)
  903. {
  904.   char *tmp;
  905.   DBUG_ENTER("unescape");
  906.   if (!(tmp=(char*) my_malloc(length*2+1, MYF(MY_WME))))
  907.   {
  908.     ignore_errors=0; /* Fatal error */
  909.     safe_exit(EX_MYSQLERR); /* Force exit */
  910.   }
  911.   mysql_real_escape_string(&mysql_connection, tmp, pos, length);
  912.   fputc(''', file);
  913.   fputs(tmp, file);
  914.   fputc(''', file);
  915.   check_io(file);
  916.   my_free(tmp, MYF(MY_WME));
  917.   DBUG_VOID_RETURN;
  918. } /* unescape */
  921. static my_bool test_if_special_chars(const char *str)
  922. {
  923. #if MYSQL_VERSION_ID >= 32300
  924.   for ( ; *str ; str++)
  925.     if (!my_isvar(charset_info,*str) && *str != '$')
  926.       return 1;
  927. #endif
  928.   return 0;
  929. } /* test_if_special_chars */
  933. static char *quote_name(const char *name, char *buff, my_bool force)
  934. {
  935.   char *to= buff;
  936.   char qtype= (opt_compatible_mode & MASK_ANSI_QUOTES) ? '"' : '`';
  938.   if (!force && !opt_quoted && !test_if_special_chars(name))
  939.     return (char*) name;
  940.   *to++= qtype;
  941.   while (*name)
  942.   {
  943.     if (*name == qtype)
  944.       *to++= qtype;
  945.     *to++= *name++;
  946.   }
  947.   to[0]= qtype;
  948.   to[1]= 0;
  949.   return buff;
  950. } /* quote_name */
  953. /*
  954.   Quote a table name so it can be used in "SHOW TABLES LIKE <tabname>"
  956.   SYNOPSIS
  957.     quote_for_like()
  958.     name     name of the table
  959.     buff     quoted name of the table
  961.   DESCRIPTION
  962.     Quote , _, ' and % characters
  964.     Note: Because MySQL uses the C escape syntax in strings
  965.     (for example, 'n' to represent newline), you must double
  966.     any '' that you use in your LIKE  strings. For example, to
  967.     search for 'n', specify it as '\n'. To search for '', specify
  968.     it as '\\' (the backslashes are stripped once by the parser
  969.     and another time when the pattern match is done, leaving a
  970.     single backslash to be matched).
  972.     Example: "t1" => "t\\1"
  974. */
  975. static char *quote_for_like(const char *name, char *buff)
  976. {
  977.   char *to= buff;
  978.   *to++= ''';
  979.   while (*name)
  980.   {
  981.     if (*name == '\')
  982.     {
  983.       *to++='\';
  984.       *to++='\';
  985.       *to++='\';
  986.     }
  987.     else if (*name == ''' || *name == '_'  || *name == '%')
  988.       *to++= '\';
  989.     *to++= *name++;
  990.   }
  991.   to[0]= ''';
  992.   to[1]= 0;
  993.   return buff;
  994. }
  997. /*
  998.   Quote and print a string.
  999.   
  1000.   SYNOPSIS
  1001.     print_quoted_xml()
  1002.     output - output file
  1003.     str - string to print
  1004.     len - its length
  1005.     
  1006.   DESCRIPTION
  1007.     Quote '<' '>' '&' '"' chars and print a string to the xml_file.
  1008. */
  1010. static void print_quoted_xml(FILE *xml_file, const char *str, ulong len)
  1011. {
  1012.   const char *end;
  1013.   
  1014.   for (end= str + len; str != end; str++)
  1015.   {
  1016.     switch (*str) {
  1017.     case '<':
  1018.       fputs("&lt;", xml_file);
  1019.       break;
  1020.     case '>':
  1021.       fputs("&gt;", xml_file);
  1022.       break;
  1023.     case '&':
  1024.       fputs("&amp;", xml_file);
  1025.       break;
  1026.     case '"':
  1027.       fputs("&quot;", xml_file);
  1028.       break;
  1029.     default:
  1030.       fputc(*str, xml_file);
  1031.       break;
  1032.     }
  1033.   }
  1034.   check_io(xml_file);
  1035. }
  1038. /*
  1039.   Print xml tag with one attribute.
  1040.   
  1041.   SYNOPSIS
  1042.     print_xml_tag1()
  1043.     xml_file - output file
  1044.     sbeg - line beginning
  1045.     stag_atr - tag and attribute
  1046.     sval - value of attribute
  1047.     send - line ending
  1048.     
  1049.   DESCRIPTION
  1050.     Print tag with one attribute to the xml_file. Format is:
  1051.       sbeg<stag_atr="sval">send
  1052.   NOTE
  1053.     sval MUST be a NULL terminated string.
  1054.     sval string will be qouted before output.
  1055. */
  1057. static void print_xml_tag1(FILE * xml_file, const char* sbeg,
  1058.    const char* stag_atr, const char* sval,
  1059.    const char* send)
  1060. {
  1061.   fputs(sbeg, xml_file);
  1062.   fputs("<", xml_file);
  1063.   fputs(stag_atr, xml_file);
  1064.   fputs(""", xml_file);
  1065.   print_quoted_xml(xml_file, sval, strlen(sval));
  1066.   fputs("">", xml_file);
  1067.   fputs(send, xml_file);
  1068.   check_io(xml_file);
  1069. }
  1072. /*
  1073.   Print xml tag with for a field that is null
  1075.   SYNOPSIS
  1076.     print_xml_null_tag()
  1077.     xml_file - output file
  1078.     sbeg - line beginning
  1079.     stag_atr - tag and attribute
  1080.     sval - value of attribute
  1081.     send - line ending
  1083.   DESCRIPTION
  1084.     Print tag with one attribute to the xml_file. Format is:
  1085.       <stag_atr="sval" xsi:nil="true"/>
  1086.   NOTE
  1087.     sval MUST be a NULL terminated string.
  1088.     sval string will be qouted before output.
  1089. */
  1091. static void print_xml_null_tag(FILE * xml_file, const char* sbeg,
  1092.                                const char* stag_atr, const char* sval,
  1093.                                const char* send)
  1094. {
  1095.   fputs(sbeg, xml_file);
  1096.   fputs("<", xml_file);
  1097.   fputs(stag_atr, xml_file);
  1098.   fputs(""", xml_file);
  1099.   print_quoted_xml(xml_file, sval, strlen(sval));
  1100.   fputs("" xsi:nil="true" />", xml_file);
  1101.   fputs(send, xml_file);
  1102.   check_io(xml_file);
  1103. }
  1106. /*
  1107.   Print xml tag with many attributes.
  1109.   SYNOPSIS
  1110.     print_xml_row()
  1111.     xml_file - output file
  1112.     row_name - xml tag name
  1113.     tableRes - query result
  1114.     row - result row
  1115.     
  1116.   DESCRIPTION
  1117.     Print tag with many attribute to the xml_file. Format is:
  1118.       tt<row_name Atr1="Val1" Atr2="Val2"... />
  1119.   NOTE
  1120.     All atributes and values will be quoted before output.
  1121. */
  1123. static void print_xml_row(FILE *xml_file, const char *row_name,
  1124.   MYSQL_RES *tableRes, MYSQL_ROW *row)
  1125. {
  1126.   uint i;
  1127.   MYSQL_FIELD *field;
  1128.   ulong *lengths= mysql_fetch_lengths(tableRes);
  1129.   
  1130.   fprintf(xml_file, "tt<%s", row_name);
  1131.   check_io(xml_file);
  1132.   mysql_field_seek(tableRes, 0);
  1133.   for (i= 0; (field= mysql_fetch_field(tableRes)); i++)
  1134.   {
  1135.     if ((*row)[i])
  1136.     {
  1137.       fputc(' ', xml_file);
  1138.       print_quoted_xml(xml_file, field->name, field->name_length);
  1139.       fputs("="", xml_file);
  1140.       print_quoted_xml(xml_file, (*row)[i], lengths[i]);
  1141.       fputc('"', xml_file);
  1142.       check_io(xml_file);
  1143.     }
  1144.   }
  1145.   fputs(" />n", xml_file);
  1146.   check_io(xml_file);
  1147. }
  1150. /*
  1151.   getTableStructure -- retrievs database structure, prints out corresponding
  1152.   CREATE statement and fills out insert_pat.
  1154.   RETURN
  1155.     number of fields in table, 0 if error
  1156. */
  1158. static uint getTableStructure(char *table, char* db)
  1159. {
  1160.   MYSQL_RES  *tableRes;
  1161.   MYSQL_ROW  row;
  1162.   my_bool    init=0;
  1163.   uint       numFields;
  1164.   char      *result_table, *opt_quoted_table;
  1165.   const char *insert_option;
  1166.   char      name_buff[NAME_LEN+3],table_buff[NAME_LEN*2+3];
  1167.   char      table_buff2[NAME_LEN*2+3];
  1168.   char       query_buff[512];
  1169.   FILE       *sql_file = md_result_file;
  1170.   int        len;
  1171.   DBUG_ENTER("getTableStructure");
  1172.   DBUG_PRINT("enter", ("db: %s, table: %s", db, table));
  1174.   if (!insert_pat_inited)
  1175.   {
  1176.     insert_pat_inited= init_dynamic_string(&insert_pat, "", 1024, 1024);
  1177.   }
  1178.   else
  1179.     dynstr_set(&insert_pat, "");
  1181.   insert_option= ((opt_delayed && opt_ignore) ? " DELAYED IGNORE " : 
  1182.                   opt_delayed ? " DELAYED " :
  1183.                   opt_ignore ? " IGNORE " : "");
  1185.   if (verbose)
  1186.     fprintf(stderr, "-- Retrieving table structure for table %s...n", table);
  1188.   len= my_snprintf(query_buff, sizeof(query_buff),
  1189.                    "SET OPTION SQL_QUOTE_SHOW_CREATE=%d",
  1190.                    (opt_quoted || opt_keywords));
  1191.   if (!create_options)
  1192.     strmov(query_buff+len, "/*!40102 ,SQL_MODE=concat(@@sql_mode, _utf8 ',NO_KEY_OPTIONS,NO_TABLE_OPTIONS,NO_FIELD_OPTIONS') */");
  1194.   result_table=     quote_name(table, table_buff, 1);
  1195.   opt_quoted_table= quote_name(table, table_buff2, 0);
  1197.   if (opt_order_by_primary)
  1198.     order_by = primary_key_fields(opt_quoted_table);
  1200.   if (!opt_xml && !mysql_query_with_error_report(sock, 0, query_buff))
  1201.   {
  1202.     /* using SHOW CREATE statement */
  1203.     if (!tFlag)
  1204.     {
  1205.       /* Make an sql-file, if path was given iow. option -T was given */
  1206.       char buff[20+FN_REFLEN];
  1208.       my_snprintf(buff, sizeof(buff), "show create table %s", result_table);
  1209.       if (mysql_query_with_error_report(sock, 0, buff))
  1210.       {
  1211.         safe_exit(EX_MYSQLERR);
  1212.         DBUG_RETURN(0);
  1213.       }
  1215.       if (path)
  1216.       {
  1217.         char filename[FN_REFLEN], tmp_path[FN_REFLEN];
  1218.         convert_dirname(tmp_path,path,NullS);
  1219.         sql_file= my_fopen(fn_format(filename, table, tmp_path, ".sql", 4),
  1220.  O_WRONLY, MYF(MY_WME));
  1221.         if (!sql_file) /* If file couldn't be opened */
  1222.         {
  1223.   safe_exit(EX_MYSQLERR);
  1224.   DBUG_RETURN(0);
  1225.         }
  1226.         write_header(sql_file, db);
  1227.       }
  1228.       if (!opt_xml && opt_comments)
  1229.       {
  1230.         fprintf(sql_file, "n--n-- Table structure for table %sn--nn",
  1231. result_table);
  1232. check_io(sql_file);
  1233.       }
  1234.       if (opt_drop)
  1235.       {
  1236.         fprintf(sql_file, "DROP TABLE IF EXISTS %s;n", opt_quoted_table);
  1237. check_io(sql_file);
  1238.       }
  1240.       tableRes=mysql_store_result(sock);
  1241.       row=mysql_fetch_row(tableRes);
  1242.       fprintf(sql_file, "%s;n", row[1]);
  1243.       check_io(sql_file);
  1244.       mysql_free_result(tableRes);
  1245.     }
  1246.     my_snprintf(query_buff, sizeof(query_buff), "show fields from %s",
  1247. result_table);
  1248.     if (mysql_query_with_error_report(sock, &tableRes, query_buff))
  1249.     {
  1250.       if (path)
  1251. my_fclose(sql_file, MYF(MY_WME));
  1252.       safe_exit(EX_MYSQLERR);
  1253.       DBUG_RETURN(0);
  1254.     }
  1256.     dynstr_append_mem(&insert_pat, "INSERT ", 7);
  1257.     dynstr_append(&insert_pat, insert_option);
  1258.     dynstr_append_mem(&insert_pat, "INTO ", 5);
  1259.     dynstr_append(&insert_pat, opt_quoted_table);
  1260.     if (opt_complete_insert)
  1261.     {
  1262.       dynstr_append_mem(&insert_pat, " (", 2);
  1263.     }
  1264.     else
  1265.     {
  1266.       dynstr_append_mem(&insert_pat, " VALUES ", 8);
  1267.       if (!extended_insert)
  1268.         dynstr_append_mem(&insert_pat, "(", 1);
  1269.     }
  1271.     while ((row=mysql_fetch_row(tableRes)))
  1272.     {
  1273.       if (init)
  1274.       {
  1275.         if (opt_complete_insert)
  1276.           dynstr_append_mem(&insert_pat, ", ", 2);
  1277.       }
  1278.       init=1;
  1279.       if (opt_complete_insert)
  1280.         dynstr_append(&insert_pat,
  1281.                       quote_name(row[SHOW_FIELDNAME], name_buff, 0));
  1282.     }
  1283.     numFields = (uint) mysql_num_rows(tableRes);
  1284.     mysql_free_result(tableRes);
  1285.   }
  1286.   else
  1287.   {
  1288.     if (verbose)
  1289.       fprintf(stderr,
  1290.               "%s: Warning: Can't set SQL_QUOTE_SHOW_CREATE option (%s)n",
  1291.               my_progname, mysql_error(sock));
  1293.     my_snprintf(query_buff, sizeof(query_buff), "show fields from %s",
  1294. result_table);
  1295.     if (mysql_query_with_error_report(sock, &tableRes, query_buff))
  1296.     {
  1297.       safe_exit(EX_MYSQLERR);
  1298.       DBUG_RETURN(0);
  1299.     }
  1301.     /* Make an sql-file, if path was given iow. option -T was given */
  1302.     if (!tFlag)
  1303.     {
  1304.       if (path)
  1305.       {
  1306.         char filename[FN_REFLEN], tmp_path[FN_REFLEN];
  1307.         convert_dirname(tmp_path,path,NullS);
  1308.         sql_file= my_fopen(fn_format(filename, table, tmp_path, ".sql", 4),
  1309.  O_WRONLY, MYF(MY_WME));
  1310.         if (!sql_file) /* If file couldn't be opened */
  1311.         {
  1312.   safe_exit(EX_MYSQLERR);
  1313.   DBUG_RETURN(0);
  1314.         }
  1315.         write_header(sql_file, db);
  1316.       }
  1317.       if (!opt_xml && opt_comments)
  1318. fprintf(sql_file, "n--n-- Table structure for table %sn--nn",
  1319. result_table);
  1320.       if (opt_drop)
  1321.         fprintf(sql_file, "DROP TABLE IF EXISTS %s;n",result_table);
  1322.       if (!opt_xml)
  1323. fprintf(sql_file, "CREATE TABLE %s (n", result_table);
  1324.       else
  1325.         print_xml_tag1(sql_file, "t", "table_structure name=", table, "n");
  1326.       check_io(sql_file);
  1327.     }
  1329.     dynstr_append_mem(&insert_pat, "INSERT ", 7);
  1330.     dynstr_append(&insert_pat, insert_option);
  1331.     dynstr_append_mem(&insert_pat, "INTO ", 5);
  1332.     dynstr_append(&insert_pat, result_table);
  1333.     if (opt_complete_insert)
  1334.     {
  1335.       dynstr_append_mem(&insert_pat, " (", 2);
  1336.     }
  1337.     else
  1338.     {
  1339.       dynstr_append_mem(&insert_pat, " VALUES ", 8);
  1340.       if (!extended_insert)
  1341.         dynstr_append_mem(&insert_pat, "(", 1);
  1342.     }
  1344.     while ((row=mysql_fetch_row(tableRes)))
  1345.     {
  1346.       ulong *lengths=mysql_fetch_lengths(tableRes);
  1347.       if (init)
  1348.       {
  1349.         if (!opt_xml && !tFlag)
  1350. {
  1351.   fputs(",n",sql_file);
  1352.   check_io(sql_file);
  1353. }
  1354.         if (opt_complete_insert)
  1355.           dynstr_append_mem(&insert_pat, ", ", 2);
  1356.       }
  1357.       init=1;
  1358.       if (opt_complete_insert)
  1359.         dynstr_append(&insert_pat,
  1360.                       quote_name(row[SHOW_FIELDNAME], name_buff, 0));
  1361.       if (!tFlag)
  1362.       {
  1363. if (opt_xml)
  1364. {
  1365.   print_xml_row(sql_file, "field", tableRes, &row);
  1366.   continue;
  1367. }
  1369.         if (opt_keywords)
  1370.   fprintf(sql_file, "  %s.%s %s", result_table,
  1371.   quote_name(row[SHOW_FIELDNAME],name_buff, 0),
  1372.   row[SHOW_TYPE]);
  1373.         else
  1374.   fprintf(sql_file, "  %s %s", quote_name(row[SHOW_FIELDNAME],
  1375.   name_buff, 0),
  1376.   row[SHOW_TYPE]);
  1377.         if (row[SHOW_DEFAULT])
  1378.         {
  1379.   fputs(" DEFAULT ", sql_file);
  1380.   unescape(sql_file, row[SHOW_DEFAULT], lengths[SHOW_DEFAULT]);
  1381.         }
  1382.         if (!row[SHOW_NULL][0])
  1383.   fputs(" NOT NULL", sql_file);
  1384.         if (row[SHOW_EXTRA][0])
  1385.   fprintf(sql_file, " %s",row[SHOW_EXTRA]);
  1386. check_io(sql_file);
  1387.       }
  1388.     }
  1389.     numFields = (uint) mysql_num_rows(tableRes);
  1390.     mysql_free_result(tableRes);
  1391.     if (!tFlag)
  1392.     {
  1393.       /* Make an sql-file, if path was given iow. option -T was given */
  1394.       char buff[20+FN_REFLEN];
  1395.       uint keynr,primary_key;
  1396.       my_snprintf(buff, sizeof(buff), "show keys from %s", result_table);
  1397.       if (mysql_query_with_error_report(sock, &tableRes, buff))
  1398.       {
  1399.         if (path)
  1400.   my_fclose(sql_file, MYF(MY_WME));
  1401.         safe_exit(EX_MYSQLERR);
  1402.         DBUG_RETURN(0);
  1403.       }
  1405.       /* Find first which key is primary key */
  1406.       keynr=0;
  1407.       primary_key=INT_MAX;
  1408.       while ((row=mysql_fetch_row(tableRes)))
  1409.       {
  1410.         if (atoi(row[3]) == 1)
  1411.         {
  1412.   keynr++;
  1413. #ifdef FORCE_PRIMARY_KEY
  1414.   if (atoi(row[1]) == 0 && primary_key == INT_MAX)
  1415.     primary_key=keynr;
  1416. #endif
  1417.   if (!strcmp(row[2],"PRIMARY"))
  1418.   {
  1419.     primary_key=keynr;
  1420.     break;
  1421.   }
  1422.         }
  1423.       }
  1424.       mysql_data_seek(tableRes,0);
  1425.       keynr=0;
  1426.       while ((row=mysql_fetch_row(tableRes)))
  1427.       {
  1428. if (opt_xml)
  1429. {
  1430.   print_xml_row(sql_file, "key", tableRes, &row);
  1431.   continue;
  1432. }
  1433.         
  1434.         if (atoi(row[3]) == 1)
  1435.         {
  1436.   if (keynr++)
  1437.     putc(')', sql_file);
  1438.   if (atoi(row[1]))       /* Test if duplicate key */
  1439.     /* Duplicate allowed */
  1440.     fprintf(sql_file, ",n  KEY %s (",quote_name(row[2],name_buff,0));
  1441.   else if (keynr == primary_key)
  1442.     fputs(",n  PRIMARY KEY (",sql_file); /* First UNIQUE is primary */
  1443.   else
  1444.     fprintf(sql_file, ",n  UNIQUE %s (",quote_name(row[2],name_buff,
  1445.     0));
  1446.         }
  1447.         else
  1448.   putc(',', sql_file);
  1449.         fputs(quote_name(row[4], name_buff, 0), sql_file);
  1450.         if (row[7])
  1451.   fprintf(sql_file, " (%s)",row[7]);      /* Sub key */
  1452. check_io(sql_file);
  1453.       }
  1454.       if (!opt_xml)
  1455.       {
  1456. if (keynr)
  1457.   putc(')', sql_file);
  1458. fputs("n)",sql_file);
  1459. check_io(sql_file);
  1460.       }
  1462.       /* Get MySQL specific create options */
  1463.       if (create_options)
  1464.       {
  1465. char show_name_buff[FN_REFLEN];
  1467. /* Check memory for quote_for_like() */
  1468. DBUG_ASSERT(2*sizeof(table) < sizeof(show_name_buff));
  1469.         my_snprintf(buff, sizeof(buff), "show table status like %s",
  1470.     quote_for_like(table, show_name_buff));
  1472.         if (mysql_query_with_error_report(sock, &tableRes, buff))
  1473.         {
  1474.   if (mysql_errno(sock) != ER_PARSE_ERROR)
  1475.   { /* If old MySQL version */
  1476.     if (verbose)
  1477.       fprintf(stderr,
  1478.       "-- Warning: Couldn't get status information for table %s (%s)n",
  1479.       result_table,mysql_error(sock));
  1480.   }
  1481.         }
  1482.         else if (!(row=mysql_fetch_row(tableRes)))
  1483.         {
  1484.   fprintf(stderr,
  1485.   "Error: Couldn't read status information for table %s (%s)n",
  1486.   result_table,mysql_error(sock));
  1487.         }
  1488.         else
  1489.         {
  1490.   if (opt_xml)
  1491.   {
  1492.     print_xml_row(sql_file, "options", tableRes, &row);
  1493.   }
  1494.   else
  1495.   {
  1496.     fputs("/*!",sql_file);
  1497.     print_value(sql_file,tableRes,row,"engine=","Engine",0);
  1498.     print_value(sql_file,tableRes,row,"","Create_options",0);
  1499.     print_value(sql_file,tableRes,row,"comment=","Comment",1);
  1500.     fputs(" */",sql_file);
  1501.     check_io(sql_file);
  1502.   }
  1503.         }
  1504.         mysql_free_result(tableRes); /* Is always safe to free */
  1505.       }
  1506.       if (!opt_xml)
  1507. fputs(";n", sql_file);
  1508.       else
  1509. fputs("t</table_structure>n", sql_file);
  1510.       check_io(sql_file);
  1511.     }
  1512.   }
  1513.   if (opt_complete_insert)
  1514.   {
  1515.     dynstr_append_mem(&insert_pat, ") VALUES ", 9);
  1516.     if (!extended_insert)
  1517.       dynstr_append_mem(&insert_pat, "(", 1);
  1518.   }
  1519.   if (sql_file != md_result_file)
  1520.   {
  1521.     fputs("n", sql_file);
  1522.     write_footer(sql_file);
  1523.     my_fclose(sql_file, MYF(MY_WME));
  1524.   }
  1525.   DBUG_RETURN(numFields);
  1526. } /* getTableStructure */
  1529. static char *add_load_option(char *ptr,const char *object,
  1530.      const char *statement)
  1531. {
  1532.   if (object)
  1533.   {
  1534.     /* Don't escape hex constants */
  1535.     if (object[0] == '0' && (object[1] == 'x' || object[1] == 'X'))
  1536.       ptr= strxmov(ptr," ",statement," ",object,NullS);
  1537.     else
  1538.     {
  1539.       /* char constant; escape */
  1540.       ptr= strxmov(ptr," ",statement," '",NullS);
  1541.       ptr= field_escape(ptr,object,(uint) strlen(object));
  1542.       *ptr++= ''';
  1543.     }
  1544.   }
  1545.   return ptr;
  1546. } /* add_load_option */
  1549. /*
  1550. ** Allow the user to specify field terminator strings like:
  1551. ** "'", "", "\" (escaped backslash), "t" (tab), "n" (newline)
  1552. ** This is done by doubleing ' and add a end - if needed to avoid
  1553. ** syntax errors from the SQL parser.
  1554. */
  1556. static char *field_escape(char *to,const char *from,uint length)
  1557. {
  1558.   const char *end;
  1559.   uint end_backslashes=0;
  1561.   for (end= from+length; from != end; from++)
  1562.   {
  1563.     *to++= *from;
  1564.     if (*from == '\')
  1565.       end_backslashes^=1;    /* find odd number of backslashes */
  1566.     else
  1567.     {
  1568.       if (*from == ''' && !end_backslashes)
  1569. *to++= *from;      /* We want a duplicate of "'" for MySQL */
  1570.       end_backslashes=0;
  1571.     }
  1572.   }
  1573.   /* Add missing backslashes if user has specified odd number of backs.*/
  1574.   if (end_backslashes)
  1575.     *to++= '\';
  1576.   return to;
  1577. } /* field_escape */
  1580. static char *alloc_query_str(ulong size)
  1581. {
  1582.   char *query;
  1584.   if (!(query= (char*) my_malloc(size, MYF(MY_WME))))
  1585.   {
  1586.     ignore_errors= 0;    /* Fatal error */
  1587.     safe_exit(EX_MYSQLERR); /* Force exit */
  1588.   }
  1589.   return query;
  1590. }
  1592. /*
  1593. ** dumpTable saves database contents as a series of INSERT statements.
  1594. */
  1595. static void dumpTable(uint numFields, char *table)
  1596. {
  1597.   char query_buf[QUERY_LENGTH], *end, buff[256],table_buff[NAME_LEN+3];
  1598.   char *result_table, table_buff2[NAME_LEN*2+3], *opt_quoted_table;
  1599.   char *query= query_buf;
  1600.   MYSQL_RES *res;
  1601.   MYSQL_FIELD *field;
  1602.   MYSQL_ROW row;
  1603.   ulong rownr, row_break, total_length, init_length;
  1604.   const char    *table_type;
  1605.   int error= 0;
  1607.   result_table= quote_name(table,table_buff, 1);
  1608.   opt_quoted_table= quote_name(table, table_buff2, 0);
  1610.   /* Check table type */
  1611.   if ((table_type= check_if_ignore_table(table)))
  1612.   {
  1613.     if (verbose)
  1614.       fprintf(stderr,
  1615.       "-- Skipping data for table '%s' because it's of type %sn",
  1616.       table, table_type);
  1617.     return;
  1618.   }
  1620.   if (verbose)
  1621.     fprintf(stderr, "-- Sending SELECT query...n");
  1622.   if (path)
  1623.   {
  1624.     char filename[FN_REFLEN], tmp_path[FN_REFLEN];
  1625.     convert_dirname(tmp_path,path,NullS);
  1626.     my_load_path(tmp_path, tmp_path, NULL);
  1627.     fn_format(filename, table, tmp_path, ".txt", 4);
  1628.     my_delete(filename, MYF(0)); /* 'INTO OUTFILE' doesn't work, if
  1629.     filename wasn't deleted */
  1630.     to_unix_path(filename);
  1631.     my_snprintf(query, QUERY_LENGTH, 
  1632. "SELECT /*!40001 SQL_NO_CACHE */ * INTO OUTFILE '%s'",
  1633. filename);
  1634.     end= strend(query);
  1636.     if (fields_terminated || enclosed || opt_enclosed || escaped)
  1637.       end= strmov(end, " FIELDS");
  1638.     end= add_load_option(end, fields_terminated, " TERMINATED BY");
  1639.     end= add_load_option(end, enclosed, " ENCLOSED BY");
  1640.     end= add_load_option(end, opt_enclosed, " OPTIONALLY ENCLOSED BY");
  1641.     end= add_load_option(end, escaped, " ESCAPED BY");
  1642.     end= add_load_option(end, lines_terminated, " LINES TERMINATED BY");
  1643.     *end= '';
  1645.     my_snprintf(buff, sizeof(buff), " FROM %s", result_table);
  1646.     end= strmov(end,buff);
  1647.     if (where || order_by)
  1648.     {
  1649.       query = alloc_query_str((ulong) ((end - query) + 1 +
  1650.                              (where ? strlen(where) + 7 : 0) +
  1651.                              (order_by ? strlen(order_by) + 10 : 0)));
  1652.       end = strmov(query, query_buf);
  1654.       if (where)
  1655.         end = strxmov(end, " WHERE ", where, NullS);
  1656.       if (order_by)
  1657.         end = strxmov(end, " ORDER BY ", order_by, NullS);
  1658.     }
  1659.     if (mysql_real_query(sock, query, (uint) (end - query)))
  1660.     {
  1661.       DBerror(sock, "when executing 'SELECT INTO OUTFILE'");
  1662.       return;
  1663.     }
  1664.   }
  1665.   else
  1666.   {
  1667.     if (!opt_xml && opt_comments)
  1668.     {
  1669.       fprintf(md_result_file,"n--n-- Dumping data for table %sn--n",
  1670.       result_table);
  1671.       check_io(md_result_file);
  1672.     }
  1673.     my_snprintf(query, QUERY_LENGTH,
  1674. "SELECT /*!40001 SQL_NO_CACHE */ * FROM %s",
  1675. result_table);
  1676.     if (where || order_by)
  1677.     {
  1678.       query = alloc_query_str((ulong) (strlen(query) + 1 +
  1679.                              (where ? strlen(where) + 7 : 0) +
  1680.                              (order_by ? strlen(order_by) + 10 : 0)));
  1681.       end = strmov(query, query_buf);
  1683.       if (where)
  1684.       {
  1685.         if (!opt_xml && opt_comments)
  1686.         {
  1687.           fprintf(md_result_file, "-- WHERE:  %sn", where);
  1688.           check_io(md_result_file);
  1689.         }
  1690.         end = strxmov(end, " WHERE ", where, NullS);
  1691.       }
  1692.       if (order_by)
  1693.       {
  1694.         if (!opt_xml && opt_comments)
  1695.         {
  1696.           fprintf(md_result_file, "-- ORDER BY:  %sn", order_by);
  1697.           check_io(md_result_file);
  1698.         }
  1699.         end = strxmov(end, " ORDER BY ", order_by, NullS);
  1700.       }
  1701.     }
  1702.     if (!opt_xml && !opt_compact)
  1703.     {
  1704.       fputs("n", md_result_file);
  1705.       check_io(md_result_file);
  1706.     }
  1707.     if (mysql_query_with_error_report(sock, 0, query))
  1708.       DBerror(sock, "when retrieving data from server");
  1709.     if (quick)
  1710.       res=mysql_use_result(sock);
  1711.     else
  1712.       res=mysql_store_result(sock);
  1713.     if (!res)
  1714.       DBerror(sock, "when retrieving data from server");
  1715.     if (verbose)
  1716.       fprintf(stderr, "-- Retrieving rows...n");
  1717.     if (mysql_num_fields(res) != numFields)
  1718.     {
  1719.       fprintf(stderr,"%s: Error in field count for table: %s !  Aborting.n",
  1720.       my_progname, result_table);
  1721.       error= EX_CONSCHECK;
  1722.       goto err;
  1723.     }
  1725.     if (opt_disable_keys)
  1726.     {
  1727.       fprintf(md_result_file, "n/*!40000 ALTER TABLE %s DISABLE KEYS */;n",
  1728.       opt_quoted_table);
  1729.       check_io(md_result_file);
  1730.     }
  1731.     if (opt_lock)
  1732.     {
  1733.       fprintf(md_result_file,"LOCK TABLES %s WRITE;n", opt_quoted_table);
  1734.       check_io(md_result_file);
  1735.     }
  1737.     total_length= opt_net_buffer_length; /* Force row break */
  1738.     row_break=0;
  1739.     rownr=0;
  1740.     init_length=(uint) insert_pat.length+4;
  1741.     if (opt_xml)
  1742.       print_xml_tag1(md_result_file, "t", "table_data name=", table, "n");
  1744.     if (opt_autocommit)
  1745.     {
  1746.       fprintf(md_result_file, "set autocommit=0;n");
  1747.       check_io(md_result_file);
  1748.     }
  1750.     while ((row=mysql_fetch_row(res)))
  1751.     {
  1752.       uint i;
  1753.       ulong *lengths=mysql_fetch_lengths(res);
  1754.       rownr++;
  1755.       if (!extended_insert && !opt_xml)
  1756.       {
  1757. fputs(insert_pat.str,md_result_file);
  1758. check_io(md_result_file);
  1759.       }
  1760.       mysql_field_seek(res,0);
  1762.       if (opt_xml)
  1763.       {
  1764.         fputs("t<row>n", md_result_file);
  1765. check_io(md_result_file);
  1766.       }
  1768.       for (i = 0; i < mysql_num_fields(res); i++)
  1769.       {
  1770.         int is_blob;
  1771. if (!(field = mysql_fetch_field(res)))
  1772. {
  1773.   my_snprintf(query, QUERY_LENGTH,
  1774.       "%s: Not enough fields from table %s! Aborting.n",
  1775.       my_progname, result_table);
  1776.   fputs(query,stderr);
  1777.   error= EX_CONSCHECK;
  1778.   goto err;
  1779. }
  1781. /*
  1782.    63 is my_charset_bin. If charsetnr is not 63,
  1783.    we have not a BLOB but a TEXT column. 
  1784.    we'll dump in hex only BLOB columns.
  1785. */
  1786.         is_blob= (opt_hex_blob && field->charsetnr == 63 &&
  1787.                   (field->type == FIELD_TYPE_STRING ||
  1788.                    field->type == FIELD_TYPE_VAR_STRING ||
  1789.                    field->type == FIELD_TYPE_BLOB ||
  1790.                    field->type == FIELD_TYPE_LONG_BLOB ||
  1791.                    field->type == FIELD_TYPE_MEDIUM_BLOB ||
  1792.                    field->type == FIELD_TYPE_TINY_BLOB)) ? 1 : 0;
  1793. if (extended_insert)
  1794. {
  1795.   ulong length = lengths[i];
  1796.   if (i == 0)
  1797.     dynstr_set(&extended_row,"(");
  1798.   else
  1799.     dynstr_append(&extended_row,",");
  1801.   if (row[i])
  1802.   {
  1803.     if (length)
  1804.     {
  1805.       if (!IS_NUM_FIELD(field))
  1806.       {
  1807.         /*
  1808.           "length * 2 + 2" is OK for both HEX and non-HEX modes:
  1809.           - In HEX mode we need exactly 2 bytes per character
  1810.           plus 2 bytes for '0x' prefix.
  1811.           - In non-HEX mode we need up to 2 bytes per character,
  1812.           plus 2 bytes for leading and trailing ''' characters.
  1813.         */
  1814. if (dynstr_realloc(&extended_row,length * 2+2))
  1815. {
  1816.   fputs("Aborting dump (out of memory)",stderr);
  1817.   error= EX_EOM;
  1818.   goto err;
  1819. }
  1820.                 if (opt_hex_blob && is_blob)
  1821.                 {
  1822.                   dynstr_append(&extended_row, "0x");
  1823.                   extended_row.length+= mysql_hex_string(extended_row.str + 
  1824.                                                          extended_row.length,
  1825.                                                          row[i], length);
  1826.                   extended_row.str[extended_row.length]= '';
  1827.                 }
  1828.                 else
  1829.                 {
  1830.                   dynstr_append(&extended_row,"'");
  1831.                   extended_row.length +=
  1832.                   mysql_real_escape_string(&mysql_connection,
  1833.                                            &extended_row.str[extended_row.length],
  1834.                                            row[i],length);
  1835.                   extended_row.str[extended_row.length]='';
  1836.                   dynstr_append(&extended_row,"'");
  1837.                 }
  1838.       }
  1839.       else
  1840.       {
  1841. /* change any strings ("inf", "-inf", "nan") into NULL */
  1842. char *ptr = row[i];
  1843. if (my_isalpha(charset_info, *ptr) || (*ptr == '-' &&
  1844.     my_isalpha(charset_info, ptr[1])))
  1845.   dynstr_append(&extended_row, "NULL");
  1846. else
  1847. {
  1848.   if (field->type == FIELD_TYPE_DECIMAL)
  1849.   {
  1850.     /* add " signs around */
  1851.     dynstr_append(&extended_row, "'");
  1852.     dynstr_append(&extended_row, ptr);
  1853.     dynstr_append(&extended_row, "'");
  1854.   }
  1855.   else
  1856.     dynstr_append(&extended_row, ptr);
  1857. }
  1858.       }
  1859.     }
  1860.     else
  1861.       dynstr_append(&extended_row,"''");
  1862.   }
  1863.   else if (dynstr_append(&extended_row,"NULL"))
  1864.   {
  1865.     fputs("Aborting dump (out of memory)",stderr);
  1866.     error= EX_EOM;
  1867.     goto err;
  1868.   }
  1869. }
  1870. else
  1871. {
  1872.   if (i && !opt_xml)
  1873.   {
  1874.     fputc(',', md_result_file);
  1875.     check_io(md_result_file);
  1876.   }
  1877.   if (row[i])
  1878.   {
  1879.     if (!IS_NUM_FIELD(field))
  1880.     {
  1881.       if (opt_xml)
  1882.       {
  1883.         print_xml_tag1(md_result_file, "tt", "field name=",
  1884.       field->name, "");
  1885. print_quoted_xml(md_result_file, row[i], lengths[i]);
  1886. fputs("</field>n", md_result_file);
  1887.       }
  1888.       else if (opt_hex_blob && is_blob)
  1889.               {
  1890.                 /* sakaik got the idea to to provide blob's in hex notation. */
  1891.                 char *ptr= row[i], *end= ptr+ lengths[i];
  1892.                 fputs("0x", md_result_file);
  1893.                 for (; ptr < end ; ptr++)
  1894.   fprintf(md_result_file, "%02X", *((uchar *)ptr));
  1895.               }
  1896.               else
  1897.                 unescape(md_result_file, row[i], lengths[i]);
  1898.     }
  1899.     else
  1900.     {
  1901.       /* change any strings ("inf", "-inf", "nan") into NULL */
  1902.       char *ptr = row[i];
  1903.       if (opt_xml)
  1904.       {
  1905.         print_xml_tag1(md_result_file, "tt", "field name=",
  1906.        field->name, "");
  1907. fputs(!my_isalpha(charset_info, *ptr) ? ptr: "NULL",
  1908.       md_result_file);
  1909. fputs("</field>n", md_result_file);
  1910.       }
  1911.       else if (my_isalpha(charset_info, *ptr) ||
  1912.        (*ptr == '-' && my_isalpha(charset_info, ptr[1])))
  1913.         fputs("NULL", md_result_file);
  1914.       else if (field->type == FIELD_TYPE_DECIMAL)
  1915.       {
  1916. /* add " signs around */
  1917. fputc(''', md_result_file);
  1918. fputs(ptr, md_result_file);
  1919. fputc(''', md_result_file);
  1920.       }
  1921.       else
  1922. fputs(ptr, md_result_file);
  1923.     }
  1924.   }
  1925.   else
  1926.           {
  1927.             /* The field value is NULL */
  1928.             if (!opt_xml)
  1929.               fputs("NULL", md_result_file);
  1930.             else
  1931.               print_xml_null_tag(md_result_file, "tt", "field name=",
  1932.                                  field->name, "n");
  1933.           }
  1934.           check_io(md_result_file);
  1935. }
  1936.       }
  1938.       if (opt_xml)
  1939.       {
  1940.         fputs("t</row>n", md_result_file);
  1941. check_io(md_result_file);
  1942.       }
  1944.       if (extended_insert)
  1945.       {
  1946. ulong row_length;
  1947. dynstr_append(&extended_row,")");
  1948.         row_length = 2 + extended_row.length;
  1949.         if (total_length + row_length < opt_net_buffer_length)
  1950.         {
  1951.   total_length += row_length;
  1952.   fputc(',',md_result_file); /* Always row break */
  1953.   fputs(extended_row.str,md_result_file);
  1954. }
  1955.         else
  1956.         {
  1957.   if (row_break)
  1958.     fputs(";n", md_result_file);
  1959.   row_break=1; /* This is first row */
  1961.           fputs(insert_pat.str,md_result_file);
  1962.           fputs(extended_row.str,md_result_file);
  1963.   total_length = row_length+init_length;
  1964.         }
  1965. check_io(md_result_file);
  1966.       }
  1967.       else if (!opt_xml)
  1968.       {
  1969. fputs(");n", md_result_file);
  1970. check_io(md_result_file);
  1971.       }
  1972.     }
  1974.     /* XML - close table tag and supress regular output */
  1975.     if (opt_xml)
  1976. fputs("t</table_data>n", md_result_file);
  1977.     else if (extended_insert && row_break)
  1978.       fputs(";n", md_result_file); /* If not empty table */
  1979.     fflush(md_result_file);
  1980.     check_io(md_result_file);
  1981.     if (mysql_errno(sock))
  1982.     {
  1983.       my_snprintf(query, QUERY_LENGTH,
  1984.   "%s: Error %d: %s when dumping table %s at row: %ldn",
  1985.   my_progname,
  1986.   mysql_errno(sock),
  1987.   mysql_error(sock),
  1988.   result_table,
  1989.   rownr);
  1990.       fputs(query,stderr);
  1991.       error= EX_CONSCHECK;
  1992.       goto err;
  1993.     }
  1994.     if (opt_lock)
  1995.     {
  1996.       fputs("UNLOCK TABLES;n", md_result_file);
  1997.       check_io(md_result_file);
  1998.     }
  1999.     if (opt_disable_keys)
  2000.     {
  2001.       fprintf(md_result_file,"/*!40000 ALTER TABLE %s ENABLE KEYS */;n",
  2002.       opt_quoted_table);
  2003.       check_io(md_result_file);
  2004.     }
  2005.     if (opt_autocommit)
  2006.     {
  2007.       fprintf(md_result_file, "commit;n");
  2008.       check_io(md_result_file);
  2009.     }
  2010.     mysql_free_result(res);
  2011.     if (query != query_buf)
  2012.       my_free(query, MYF(MY_ALLOW_ZERO_PTR));
  2013.   } 
  2014.   return;
  2016. err:
  2017.   if (query != query_buf)
  2018.     my_free(query, MYF(MY_ALLOW_ZERO_PTR));
  2019.   safe_exit(error);
  2020.   return;
  2021. } /* dumpTable */
  2024. static char *getTableName(int reset)
  2025. {
  2026.   static MYSQL_RES *res = NULL;
  2027.   MYSQL_ROW    row;
  2029.   if (!res)
  2030.   {
  2031.     if (!(res = mysql_list_tables(sock,NullS)))
  2032.       return(NULL);
  2033.   }
  2034.   if ((row = mysql_fetch_row(res)))
  2035.     return((char*) row[0]);
  2037.   if (reset)
  2038.     mysql_data_seek(res,0);      /* We want to read again */
  2039.   else
  2040.   {
  2041.     mysql_free_result(res);
  2042.     res = NULL;
  2043.   }
  2044.   return(NULL);
  2045. } /* getTableName */
  2048. static int dump_all_databases()
  2049. {
  2050.   MYSQL_ROW row;
  2051.   MYSQL_RES *tableres;
  2052.   int result=0;
  2054.   if (mysql_query_with_error_report(sock, &tableres, "SHOW DATABASES"))
  2055.     return 1;
  2056.   while ((row = mysql_fetch_row(tableres)))
  2057.   {
  2058.     if (dump_all_tables_in_db(row[0]))
  2059.       result=1;
  2060.   }
  2061.   return result;
  2062. }
  2063. /* dump_all_databases */
  2066. static int dump_databases(char **db_names)
  2067. {
  2068.   int result=0;
  2069.   for ( ; *db_names ; db_names++)
  2070.   {
  2071.     if (dump_all_tables_in_db(*db_names))
  2072.       result=1;
  2073.   }
  2074.   return result;
  2075. } /* dump_databases */
  2078. static int init_dumping(char *database)
  2079. {
  2080.   if (mysql_select_db(sock, database))
  2081.   {
  2082.     DBerror(sock, "when selecting the database");
  2083.     return 1; /* If --force */
  2084.   }
  2085.   if (!path && !opt_xml)
  2086.   {
  2087.     if (opt_databases || opt_alldbs)
  2088.     {
  2089.       /*
  2090. length of table name * 2 (if name contains quotes), 2 quotes and 0
  2091.       */
  2092.       char quoted_database_buf[64*2+3];
  2093.       char *qdatabase= quote_name(database,quoted_database_buf,opt_quoted);
  2094.       if (opt_comments)
  2095.       {
  2096. fprintf(md_result_file,"n--n-- Current Database: %sn--n", qdatabase);
  2097. check_io(md_result_file);
  2098.       }
  2099.       if (!opt_create_db)
  2100.       {
  2101.         char qbuf[256];
  2102.         MYSQL_ROW row;
  2103.         MYSQL_RES *dbinfo;
  2105.         my_snprintf(qbuf, sizeof(qbuf), 
  2106.     "SHOW CREATE DATABASE IF NOT EXISTS %s",
  2107.     qdatabase);
  2109.         if (mysql_query(sock, qbuf) || !(dbinfo = mysql_store_result(sock)))
  2110.         {
  2111.           /* Old server version, dump generic CREATE DATABASE */
  2112.           if (opt_drop_database)
  2113.             fprintf(md_result_file,
  2114.                     "n/*!40000 DROP DATABASE IF EXISTS %s;*/n",
  2115.                     qdatabase);
  2116.   fprintf(md_result_file,
  2117.   "nCREATE DATABASE /*!32312 IF NOT EXISTS*/ %s;n",
  2118.   qdatabase);
  2119. }
  2120. else
  2121.         {
  2122.           if (opt_drop_database)
  2123.             fprintf(md_result_file,
  2124.                     "n/*!40000 DROP DATABASE IF EXISTS %s*/;n",
  2125.                     qdatabase);
  2126.   row = mysql_fetch_row(dbinfo);
  2127.   if (row[1])
  2128.   {
  2129.     fprintf(md_result_file,"n%s;n",row[1]);
  2130.           }
  2131. }
  2132.       }
  2133.       fprintf(md_result_file,"nUSE %s;n", qdatabase);
  2134.       check_io(md_result_file);
  2135.     }
  2136.   }
  2137.   if (extended_insert && init_dynamic_string(&extended_row, "", 1024, 1024))
  2138.     exit(EX_EOM);
  2139.   return 0;
  2140. } /* init_dumping */
  2143. my_bool include_table(byte* hash_key, uint len)
  2144. {
  2145.   if (hash_search(&ignore_table, (byte*) hash_key, len))
  2146.     return FALSE;
  2148.   return TRUE;
  2149. }
  2152. static int dump_all_tables_in_db(char *database)
  2153. {
  2154.   char *table;
  2155.   uint numrows;
  2156.   char table_buff[NAME_LEN*2+3];
  2158.   char hash_key[2*NAME_LEN+2];  /* "db.tablename" */
  2159.   char *afterdot;
  2161.   afterdot= strmov(hash_key, database);
  2162.   *afterdot++= '.';
  2164.   if (init_dumping(database))
  2165.     return 1;
  2166.   if (opt_xml)
  2167.     print_xml_tag1(md_result_file, "", "database name=", database, "n");
  2168.   if (lock_tables)
  2169.   {
  2170.     DYNAMIC_STRING query;
  2171.     init_dynamic_string(&query, "LOCK TABLES ", 256, 1024);
  2172.     for (numrows= 0 ; (table= getTableName(1)) ; numrows++)
  2173.     {
  2174.       dynstr_append(&query, quote_name(table, table_buff, 1));
  2175.       dynstr_append(&query, " READ /*!32311 LOCAL */,");
  2176.     }
  2177.     if (numrows && mysql_real_query(sock, query.str, query.length-1))
  2178.       DBerror(sock, "when using LOCK TABLES");
  2179.             /* We shall continue here, if --force was given */
  2180.     dynstr_free(&query);
  2181.   }
  2182.   if (flush_logs)
  2183.   {
  2184.     if (mysql_refresh(sock, REFRESH_LOG))
  2185.       DBerror(sock, "when doing refresh");
  2186.            /* We shall continue here, if --force was given */
  2187.   }
  2188.   while ((table= getTableName(0)))
  2189.   {
  2190.     char *end= strmov(afterdot, table);
  2191.     if (include_table(hash_key, end - hash_key))
  2192.     {
  2193.       numrows = getTableStructure(table, database);
  2194.       if (!dFlag && numrows > 0)
  2195. dumpTable(numrows,table);
  2196.       my_free(order_by, MYF(MY_ALLOW_ZERO_PTR));
  2197.       order_by= 0;
  2198.     }
  2199.   }
  2200.   if (opt_xml)
  2201.   {
  2202.     fputs("</database>n", md_result_file);
  2203.     check_io(md_result_file);
  2204.   }
  2205.   if (lock_tables)
  2206.     mysql_query_with_error_report(sock, 0, "UNLOCK TABLES");
  2207.   return 0;
  2208. } /* dump_all_tables_in_db */
  2211. /*
  2212.   get_actual_table_name -- executes a SHOW TABLES LIKE '%s' to get the actual 
  2213.   table name from the server for the table name given on the command line.  
  2214.   we do this because the table name given on the command line may be a 
  2215.   different case (e.g.  T1 vs t1)
  2216.   
  2217.   RETURN
  2218.     int - 0 if a tablename was retrieved.  1 if not
  2219. */
  2221. static int get_actual_table_name(const char *old_table_name, 
  2222.                                   char *new_table_name, 
  2223.                                   int buf_size)
  2224. {
  2225.   int retval;
  2226.   MYSQL_RES  *tableRes;
  2227.   MYSQL_ROW  row;
  2228.   char query[50 + 2*NAME_LEN];
  2229.   char show_name_buff[FN_REFLEN];
  2230.   DBUG_ENTER("get_actual_table_name");
  2231.   DBUG_PRINT("enter", ("old_table_name: %s", old_table_name));
  2233.   /* Check memory for quote_for_like() */
  2234.   DBUG_ASSERT(2*sizeof(old_table_name) < sizeof(show_name_buff));
  2235.   my_snprintf(query, sizeof(query), "SHOW TABLES LIKE %s", 
  2236.       quote_for_like(old_table_name, show_name_buff));
  2238.   if (mysql_query_with_error_report(sock, 0, query))
  2239.   {
  2240.     safe_exit(EX_MYSQLERR);
  2241.   }
  2243.   tableRes= mysql_store_result( sock );
  2244.   retval = 1;
  2245.   if (tableRes != NULL)
  2246.   {
  2247.     my_ulonglong numRows= mysql_num_rows(tableRes);
  2248.     if (numRows > 0)
  2249.     {
  2250.       row= mysql_fetch_row( tableRes );
  2251.       strmake(new_table_name, row[0], buf_size-1);
  2252.       retval= 0;
  2253.       DBUG_PRINT("info", ("new_table_name: %s", new_table_name));
  2254.     }
  2255.     mysql_free_result(tableRes);
  2256.   }
  2257.   DBUG_PRINT("exit", ("retval: %d", retval));
  2258.   DBUG_RETURN(retval);
  2259. }
  2262. static int dump_selected_tables(char *db, char **table_names, int tables)
  2263. {
  2264.   uint numrows, i;
  2265.   char table_buff[NAME_LEN*+3];
  2266.   char new_table_name[NAME_LEN];
  2267.   DYNAMIC_STRING lock_tables_query;
  2268.   HASH dump_tables;
  2269.   DBUG_ENTER("dump_selected_tables");
  2271.   if (init_dumping(db))
  2272.     return 1;
  2274.   /* Init hash table for storing the actual name of tables to dump */
  2275.   if (hash_init(&dump_tables, charset_info, 16, 0, 0,
  2276.                 (hash_get_key) get_table_key, (hash_free_key) free_table_ent,
  2277.                 0))
  2278.     exit(EX_EOM);
  2280.   init_dynamic_string(&lock_tables_query, "LOCK TABLES ", 256, 1024);
  2281.   for (; tables > 0 ; tables-- , table_names++)
  2282.   {
  2284.     /* the table name passed on commandline may be wrong case */
  2285.     if (!get_actual_table_name(*table_names,
  2286.                                new_table_name, sizeof(new_table_name) ))
  2287.     {
  2288.       /* Add found table name to lock_tables_query */
  2289.       if (lock_tables)
  2290.       {
  2291.         dynstr_append(&lock_tables_query,
  2292.                       quote_name(new_table_name, table_buff, 1));
  2293.         dynstr_append(&lock_tables_query, " READ /*!32311 LOCAL */,");
  2294.       }
  2296.       /* Add found table name to dump_tables list */
  2297.       if (my_hash_insert(&dump_tables,
  2298.                          (byte*)my_strdup(new_table_name, MYF(0))))
  2299.         exit(EX_EOM);
  2301.     }
  2302.     else
  2303.     {
  2304.        my_printf_error(0,"Couldn't find table: "%s"n", MYF(0),
  2305.                        *table_names);
  2306.        safe_exit(EX_ILLEGAL_TABLE);
  2307.        /* We shall countinue here, if --force was given */
  2308.     }
  2309.   }
  2311.   if (lock_tables)
  2312.   {
  2313.     if (mysql_real_query(sock, lock_tables_query.str,
  2314.                          lock_tables_query.length-1))
  2315.       DBerror(sock, "when doing LOCK TABLES");
  2316.        /* We shall countinue here, if --force was given */
  2317.   }
  2318.   dynstr_free(&lock_tables_query);
  2319.   if (flush_logs)
  2320.   {
  2321.     if (mysql_refresh(sock, REFRESH_LOG))
  2322.       DBerror(sock, "when doing refresh");
  2323.      /* We shall countinue here, if --force was given */
  2324.   }
  2325.   if (opt_xml)
  2326.     print_xml_tag1(md_result_file, "", "database name=", db, "n");
  2328.   /* Dump each selected table */
  2329.   for (i= 0 ; i < dump_tables.records ; i++)
  2330.   {
  2331.     const char *table_name= hash_element(&dump_tables, i);
  2332.     DBUG_PRINT("info",("Dumping table %s", table_name));
  2333.     numrows= getTableStructure((char*) table_name, db);
  2334.     if (!dFlag && numrows > 0)
  2335.       dumpTable(numrows, (char*) table_name);
  2336.   }
  2337.   hash_free(&dump_tables);
  2338.   my_free(order_by, MYF(MY_ALLOW_ZERO_PTR));
  2339.   order_by= 0;
  2340.   if (opt_xml)
  2341.   {
  2342.     fputs("</database>n", md_result_file);
  2343.     check_io(md_result_file);
  2344.   }
  2345.   if (lock_tables)
  2346.     mysql_query_with_error_report(sock, 0, "UNLOCK TABLES");
  2347.   DBUG_RETURN(0);
  2348. } /* dump_selected_tables */
  2351. static int do_show_master_status(MYSQL *mysql_con)
  2352. {
  2353.   MYSQL_ROW row;
  2354.   MYSQL_RES *master;
  2355.   const char *comment_prefix=
  2356.     (opt_master_data == MYSQL_OPT_MASTER_DATA_COMMENTED_SQL) ? "-- " : "";
  2357.   if (mysql_query_with_error_report(mysql_con, &master, "SHOW MASTER STATUS"))
  2358.   {
  2359.     my_printf_error(0, "Error: Couldn't execute 'SHOW MASTER STATUS': %s",
  2360.                     MYF(0), mysql_error(mysql_con));
  2361.     return 1;
  2362.   }
  2363.   else
  2364.   {
  2365.     row = mysql_fetch_row(master);
  2366.     if (row && row[0] && row[1])
  2367.     {
  2368.       /* SHOW MASTER STATUS reports file and position */
  2369.       if (opt_comments)
  2370.         fprintf(md_result_file,
  2371.                 "n--n-- Position to start replication or point-in-time "
  2372.                 "recovery fromn--nn");
  2373.       fprintf(md_result_file,
  2374.               "%sCHANGE MASTER TO MASTER_LOG_FILE='%s', MASTER_LOG_POS=%s;n",
  2375.               comment_prefix, row[0], row[1]); 
  2376.       check_io(md_result_file);
  2377.     }
  2378.     else if (!ignore_errors)
  2379.     {
  2380.       /* SHOW MASTER STATUS reports nothing and --force is not enabled */
  2381.       my_printf_error(0, "Error: Binlogging on server not active", 
  2382.       MYF(0));
  2383.       mysql_free_result(master);
  2384.       return 1;
  2385.     }
  2386.     mysql_free_result(master);
  2387.   }
  2388.   return 0;
  2389. }
  2392. static int do_flush_tables_read_lock(MYSQL *mysql_con)
  2393. {
  2394.   /*
  2395.     We do first a FLUSH TABLES. If a long update is running, the FLUSH TABLES
  2396.     will wait but will not stall the whole mysqld, and when the long update is
  2397.     done the FLUSH TABLES WITH READ LOCK will start and succeed quickly. So,
  2398.     FLUSH TABLES is to lower the probability of a stage where both mysqldump
  2399.     and most client connections are stalled. Of course, if a second long
  2400.     update starts between the two FLUSHes, we have that bad stall.
  2401.   */
  2402.   return 
  2403.     ( mysql_query_with_error_report(mysql_con, 0, "FLUSH TABLES") ||
  2404.       mysql_query_with_error_report(mysql_con, 0,
  2405.                                     "FLUSH TABLES WITH READ LOCK") );
  2406. }
  2409. static int do_unlock_tables(MYSQL *mysql_con)
  2410. {
  2411.   return mysql_query_with_error_report(mysql_con, 0, "UNLOCK TABLES");
  2412. }
  2415. static int do_reset_master(MYSQL *mysql_con)
  2416. {
  2417.   return mysql_query_with_error_report(mysql_con, 0, "RESET MASTER");
  2418. }
  2421. static int start_transaction(MYSQL *mysql_con, my_bool consistent_read_now)
  2422. {
  2423.   /*
  2424.     We use BEGIN for old servers. --single-transaction --master-data will fail
  2425.     on old servers, but that's ok as it was already silently broken (it didn't
  2426.     do a consistent read, so better tell people frankly, with the error).
  2428.     We want the first consistent read to be used for all tables to dump so we
  2429.     need the REPEATABLE READ level (not anything lower, for example READ
  2430.     COMMITTED would give one new consistent read per dumped table).
  2431.   */
  2432.   return (mysql_query_with_error_report(mysql_con, 0,
  2433.                                         "SET SESSION TRANSACTION ISOLATION "
  2434.                                         "LEVEL REPEATABLE READ") ||
  2435.           mysql_query_with_error_report(mysql_con, 0,
  2436.                                         consistent_read_now ?
  2437.                                         "START TRANSACTION "
  2438.                                         "WITH CONSISTENT SNAPSHOT" :
  2439.                                         "BEGIN"));
  2440. }
  2443. static ulong find_set(TYPELIB *lib, const char *x, uint length,
  2444.       char **err_pos, uint *err_len)
  2445. {
  2446.   const char *end= x + length;
  2447.   ulong found= 0;
  2448.   uint find;
  2449.   char buff[255];
  2451.   *err_pos= 0;                  /* No error yet */
  2452.   while (end > x && my_isspace(charset_info, end[-1]))
  2453.     end--;
  2455.   *err_len= 0;
  2456.   if (x != end)
  2457.   {
  2458.     const char *start= x;
  2459.     for (;;)
  2460.     {
  2461.       const char *pos= start;
  2462.       uint var_len;
  2464.       for (; pos != end && *pos != ','; pos++) ;
  2465.       var_len= (uint) (pos - start);
  2466.       strmake(buff, start, min(sizeof(buff), var_len));
  2467.       find= find_type(buff, lib, var_len);
  2468.       if (!find)
  2469.       {
  2470.         *err_pos= (char*) start;
  2471.         *err_len= var_len;
  2472.       }
  2473.       else
  2474.         found|= ((longlong) 1 << (find - 1));
  2475.       if (pos == end)
  2476.         break;
  2477.       start= pos + 1;
  2478.     }
  2479.   }
  2480.   return found;
  2481. }
  2484. /* Print a value with a prefix on file */
  2485. static void print_value(FILE *file, MYSQL_RES  *result, MYSQL_ROW row,
  2486. const char *prefix, const char *name,
  2487. int string_value)
  2488. {
  2489.   MYSQL_FIELD *field;
  2490.   mysql_field_seek(result, 0);
  2492.   for ( ; (field = mysql_fetch_field(result)) ; row++)
  2493.   {
  2494.     if (!strcmp(field->name,name))
  2495.     {
  2496.       if (row[0] && row[0][0] && strcmp(row[0],"0")) /* Skip default */
  2497.       {
  2498. fputc(' ',file);
  2499. fputs(prefix, file);
  2500. if (string_value)
  2501.   unescape(file,row[0],(uint) strlen(row[0]));
  2502. else
  2503.   fputs(row[0], file);
  2504. check_io(file);
  2505. return;
  2506.       }
  2507.     }
  2508.   }
  2509.   return; /* This shouldn't happen */
  2510. } /* print_value */
  2513. /*
  2514.   Check if we the table is one of the table types that should be ignored:
  2515.   MRG_ISAM, MRG_MYISAM
  2517.   SYNOPSIS
  2518.     check_if_ignore_table()
  2519.     table_name Table name to check
  2521.   GLOBAL VARIABLES
  2522.     sock MySQL socket
  2523.     verbose Write warning messages
  2525.   RETURN
  2526.     0 Table should be backuped
  2527.     # Type of table (that should be skipped)
  2528. */
  2530. static const char *check_if_ignore_table(const char *table_name)
  2531. {
  2532.   char buff[FN_REFLEN+80], show_name_buff[FN_REFLEN];
  2533.   MYSQL_RES *res;
  2534.   MYSQL_ROW row;
  2535.   const char *result= 0;
  2537.   /* Check memory for quote_for_like() */
  2538.   DBUG_ASSERT(2*sizeof(table_name) < sizeof(show_name_buff));
  2539.   my_snprintf(buff, sizeof(buff), "show table status like %s",
  2540.       quote_for_like(table_name, show_name_buff));
  2541.   if (mysql_query_with_error_report(sock, &res, buff))
  2542.   {
  2543.     if (mysql_errno(sock) != ER_PARSE_ERROR)
  2544.     { /* If old MySQL version */
  2545.       if (verbose)
  2546. fprintf(stderr,
  2547. "-- Warning: Couldn't get status information for table %s (%s)n",
  2548. table_name,mysql_error(sock));
  2549.       return 0; /* assume table is ok */
  2550.     }
  2551.   }
  2552.   if (!(row= mysql_fetch_row(res)))
  2553.   {
  2554.     fprintf(stderr,
  2555.     "Error: Couldn't read status information for table %s (%s)n",
  2556.     table_name, mysql_error(sock));
  2557.     mysql_free_result(res);
  2558.     return 0; /* assume table is ok */
  2559.   }
  2560.   if (strcmp(row[1], (result= "MRG_MyISAM")) &&
  2561.       strcmp(row[1], (result= "MRG_ISAM")))
  2562.     result= 0;
  2563.   mysql_free_result(res);
  2564.   return result;
  2565. }
  2567. /*
  2568.   Get string of comma-separated primary key field names
  2570.   SYNOPSIS
  2571.     char *primary_key_fields(const char *table_name)
  2572.     RETURNS     pointer to allocated buffer (must be freed by caller)
  2573.     table_name  quoted table name
  2575.   DESCRIPTION
  2576.     Use SHOW KEYS FROM table_name, allocate a buffer to hold the
  2577.     field names, and then build that string and return the pointer
  2578.     to that buffer.
  2580.     Returns NULL if there is no PRIMARY or UNIQUE key on the table,
  2581.     or if there is some failure.  It is better to continue to dump
  2582.     the table unsorted, rather than exit without dumping the data.
  2583. */
  2584. static char *primary_key_fields(const char *table_name)
  2585. {
  2586.   MYSQL_RES  *res = NULL;
  2587.   MYSQL_ROW  row;
  2588.   /* SHOW KEYS FROM + table name * 2 (escaped) + 2 quotes +  */
  2589.   char show_keys_buff[15 + 64 * 2 + 3];
  2590.   uint result_length = 0;
  2591.   char *result = 0;
  2593.   my_snprintf(show_keys_buff, sizeof(show_keys_buff), 
  2594.       "SHOW KEYS FROM %s", table_name);
  2595.   if (mysql_query(sock, show_keys_buff) ||
  2596.       !(res = mysql_store_result(sock)))
  2597.   {
  2598.     fprintf(stderr, "Warning: Couldn't read keys from table %s;"
  2599.             " records are NOT sorted (%s)n",
  2600.             table_name, mysql_error(sock));
  2601.     /* Don't exit, because it's better to print out unsorted records */
  2602.     goto cleanup;
  2603.   }
  2605.   /*
  2606.    * Figure out the length of the ORDER BY clause result.
  2607.    * Note that SHOW KEYS is ordered:  a PRIMARY key is always the first
  2608.    * row, and UNIQUE keys come before others.  So we only need to check
  2609.    * the first key, not all keys.
  2610.    */
  2611.   if ((row = mysql_fetch_row(res)) && atoi(row[1]) == 0)
  2612.   {
  2613.     /* Key is unique */
  2614.     do
  2615.       result_length += strlen(row[4]) + 1;      /* + 1 for ',' or  */
  2616.     while ((row = mysql_fetch_row(res)) && atoi(row[3]) > 1);
  2617.   }
  2619.   /* Build the ORDER BY clause result */
  2620.   if (result_length) {
  2621.     char *end;
  2622.     /* result (terminating  is already in result_length) */
  2623.     result = my_malloc(result_length + 10, MYF(MY_WME));
  2624.     if (!result) {
  2625.       fprintf(stderr, "Error: Not enough memory to store ORDER BY clausen");
  2626.       goto cleanup;
  2627.     }
  2628.     mysql_data_seek(res, 0);
  2629.     row = mysql_fetch_row(res);
  2630.     end = strmov(result, row[4]);
  2631.     while ((row = mysql_fetch_row(res)) && atoi(row[3]) > 1)
  2632.       end = strxmov(end, ",", row[4], NullS);
  2633.   }
  2635. cleanup:
  2636.   if (res)
  2637.     mysql_free_result(res);
  2639.   return result;
  2640. }
  2643. int main(int argc, char **argv)
  2644. {
  2645.   compatible_mode_normal_str[0]= 0;
  2646.   default_charset= (char *)mysql_universal_client_charset;
  2647.   bzero((char*) &ignore_table, sizeof(ignore_table));
  2649.   MY_INIT("mysqldump");
  2650.   if (get_options(&argc, &argv))
  2651.   {
  2652.     my_end(0);
  2653.     exit(EX_USAGE);
  2654.   }
  2655.   if (dbConnect(current_host, current_user, opt_password))
  2656.     exit(EX_MYSQLERR);
  2657.   if (!path)
  2658.     write_header(md_result_file, *argv);
  2660.   if ((opt_lock_all_tables || opt_master_data) &&
  2661.       do_flush_tables_read_lock(sock))
  2662.     goto err;
  2663.   if (opt_single_transaction && start_transaction(sock, test(opt_master_data)))
  2664.       goto err;
  2665.   if (opt_delete_master_logs && do_reset_master(sock))
  2666.     goto err;
  2667.   if (opt_lock_all_tables || opt_master_data)
  2668.   {
  2669.     if (flush_logs && mysql_refresh(sock, REFRESH_LOG))
  2670.       goto err;
  2671.     flush_logs= 0; /* not anymore; that would not be sensible */
  2672.   }
  2673.   if (opt_master_data && do_show_master_status(sock))
  2674.     goto err;
  2675.   if (opt_single_transaction && do_unlock_tables(sock)) /* unlock but no commit! */
  2676.     goto err;
  2678.   if (opt_alldbs)
  2679.     dump_all_databases();
  2680.   else if (argc > 1 && !opt_databases)
  2681.   {
  2682.     /* Only one database and selected table(s) */
  2683.     dump_selected_tables(*argv, (argv + 1), (argc - 1));
  2684.   }
  2685.   else
  2686.   {
  2687.     /* One or more databases, all tables */
  2688.     dump_databases(argv);
  2689.   }
  2690. #ifdef HAVE_SMEM
  2691.   my_free(shared_memory_base_name,MYF(MY_ALLOW_ZERO_PTR));
  2692. #endif
  2693.   /*
  2694.     No reason to explicitely COMMIT the transaction, neither to explicitely
  2695.     UNLOCK TABLES: these will be automatically be done by the server when we
  2696.     disconnect now. Saves some code here, some network trips, adds nothing to
  2697.     server.
  2698.   */
  2699. err:
  2700.   dbDisconnect(current_host);
  2701.   if (!path)
  2702.     write_footer(md_result_file);
  2703.   if (md_result_file != stdout)
  2704.     my_fclose(md_result_file, MYF(0));
  2705.   my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));
  2706.   if (hash_inited(&ignore_table))
  2707.     hash_free(&ignore_table);
  2708.   if (extended_insert)
  2709.     dynstr_free(&extended_row);
  2710.   if (insert_pat_inited)
  2711.     dynstr_free(&insert_pat);
  2712.   my_end(0);
  2713.   return(first_error);
  2714. } /* main */