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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mysqldump.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：38k
源码类别：

MySQL数据库

开发平台：

Visual C++

mysqldump.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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. ** ******************************************************
  22. ** *      *
  23. ** * AUTHOR: Igor Romanenko (igor@frog.kiev.ua)      *
  24. ** * DATE:   December 3, 1994      *
  25. ** * WARRANTY: None, expressed, impressed, implied      *
  26. ** *     or other      *
  27. ** * STATUS: Public domain      *
  28. ** * Adapted and optimized for MySQL by      *
  29. ** * Michael Widenius, Sinisa Milivojevic, Jani Tolonen *
  30. ** * -w --where added 9/10/98 by Jim Faucette      *
  31. ** * slave code by David Saez Padros <david@ols.es>     *
  32. ** *      *
  33. ** ******************************************************
  34. */
  35. /* SSL by
  36. **   Andrei Errapart <andreie@no.spam.ee>
  37. **   T鮪u Samuel  <tonu@please.do.not.remove.this.spam.ee>
  38. **/
  40. #define DUMP_VERSION "8.13"
  42. #include <global.h>
  43. #include <my_sys.h>
  44. #include <m_string.h>
  45. #include <m_ctype.h>
  47. #include "mysql.h"
  48. #include "mysql_version.h"
  49. #include "mysqld_error.h"
  50. #include <getopt.h>
  52. /* Exit codes */
  54. #define EX_USAGE 1
  55. #define EX_MYSQLERR 2
  56. #define EX_CONSCHECK 3
  57. #define EX_EOM 4
  59. /* index into 'show fields from table' */
  61. #define SHOW_FIELDNAME  0
  62. #define SHOW_TYPE  1
  63. #define SHOW_NULL  2
  64. #define SHOW_DEFAULT  4
  65. #define SHOW_EXTRA  5
  66. #define QUOTE_CHAR '`'
  68. static char *add_load_option(char *ptr, const char *object,
  69.      const char *statement);
  71. static char *field_escape(char *to,const char *from,uint length);
  72. static my_bool  verbose=0,tFlag=0,cFlag=0,dFlag=0,quick=0, extended_insert = 0,
  73. lock_tables=0,ignore_errors=0,flush_logs=0,replace=0,
  74. ignore=0,opt_drop=0,opt_keywords=0,opt_lock=0,opt_compress=0,
  75.                 opt_delayed=0,create_options=0,opt_quoted=0,opt_databases=0,
  76.                 opt_alldbs=0,opt_create_db=0,opt_first_slave=0;
  77. static MYSQL  mysql_connection,*sock=0;
  78. static char  insert_pat[12 * 1024],*opt_password=0,*current_user=0,
  79.              *current_host=0,*path=0,*fields_terminated=0,
  80.              *lines_terminated=0, *enclosed=0, *opt_enclosed=0, *escaped=0,
  81.              *where=0, *default_charset;
  82. static uint     opt_mysql_port=0;
  83. static my_string opt_mysql_unix_port=0;
  84. static int   first_error=0;
  85. extern ulong net_buffer_length;
  86. static DYNAMIC_STRING extended_row;
  87. #include "sslopt-vars.h"
  89. enum options {OPT_FTB=256, OPT_LTB, OPT_ENC, OPT_O_ENC, OPT_ESC, OPT_KEYWORDS,
  90.       OPT_LOCKS, OPT_DROP, OPT_OPTIMIZE, OPT_DELAYED, OPT_TABLES,
  91.               OPT_CHARSETS_DIR, OPT_DEFAULT_CHARSET};
  93. static struct option long_options[] =
  94. {
  95.   {"all-databases",     no_argument,    0,      'A'},
  96.   {"all", no_argument,    0,  'a'},
  97.   {"add-drop-table", no_argument,    0,  OPT_DROP},
  98.   {"add-locks",     no_argument,    0, OPT_LOCKS},
  99.   {"allow-keywords", no_argument,    0,  OPT_KEYWORDS},
  100.   {"character-sets-dir",required_argument,0,    OPT_CHARSETS_DIR},
  101.   {"complete-insert", no_argument,    0,  'c'},
  102.   {"compress",          no_argument,    0,  'C'},
  103.   {"databases",         no_argument,    0,      'B'},
  104.   {"debug", optional_argument,  0, '#'},
  105.   {"default-character-set", required_argument,  0, OPT_DEFAULT_CHARSET},
  106.   {"delayed-insert", no_argument,    0,  OPT_DELAYED},
  107.   {"extended-insert",   no_argument,    0,  'e'},
  108.   {"fields-terminated-by", required_argument,   0, (int) OPT_FTB},
  109.   {"fields-enclosed-by", required_argument, 0, (int) OPT_ENC},
  110.   {"fields-optionally-enclosed-by", required_argument, 0, (int) OPT_O_ENC},
  111.   {"fields-escaped-by", required_argument, 0, (int) OPT_ESC},
  112.   {"first-slave", no_argument,    0, 'x'},
  113.   {"flush-logs", no_argument,    0, 'F'},
  114.   {"force",     no_argument,    0, 'f'},
  115.   {"help",    no_argument,    0, '?'},
  116.   {"host",     required_argument, 0, 'h'},
  117.   {"lines-terminated-by", required_argument,    0, (int) OPT_LTB},
  118.   {"lock-tables",   no_argument,    0,  'l'},
  119.   {"no-create-db",      no_argument,    0,      'n'},
  120.   {"no-create-info",  no_argument,    0,  't'},
  121.   {"no-data",   no_argument,    0,  'd'},
  122.   {"opt",    no_argument,    0,  OPT_OPTIMIZE},
  123.   {"password",   optional_argument,  0, 'p'},
  124. #ifdef __WIN__
  125.   {"pipe", no_argument,     0, 'W'},
  126. #endif
  127.   {"port",     required_argument, 0, 'P'},
  128.   {"quick",     no_argument, 0, 'q'},
  129.   {"quote-names", no_argument, 0, 'Q'},
  130.   {"set-variable", required_argument, 0, 'O'},
  131.   {"socket",    required_argument, 0, 'S'},
  132. #include "sslopt-longopts.h"
  133.   {"tab",     required_argument, 0, 'T'},
  134.   {"tables",            no_argument,            0, OPT_TABLES},
  135. #ifndef DONT_ALLOW_USER_CHANGE
  136.   {"user",     required_argument, 0, 'u'},
  137. #endif
  138.   {"verbose",     no_argument, 0, 'v'},
  139.   {"version",     no_argument,     0, 'V'},
  140.   {"where", required_argument,  0, 'w'},
  141.   {0, 0, 0, 0}
  142. };
  144. static const char *load_default_groups[]= { "mysqldump","client",0 };
  146. CHANGEABLE_VAR changeable_vars[] = {
  147.   { "max_allowed_packet", (long*) &max_allowed_packet,24*1024*1024,4096,
  148.     24*1024L*1024L,MALLOC_OVERHEAD,1024},
  149.   { "net_buffer_length", (long*) &net_buffer_length,1024*1024L-1025,4096,
  150.     24*1024L*1024L,MALLOC_OVERHEAD,1024},
  151.   { 0, 0, 0, 0, 0, 0, 0}
  152. };
  154. static void safe_exit(int error);
  155. static void write_heder(FILE *sql_file, char *db_name);
  156. static void print_value(FILE *file, MYSQL_RES  *result, MYSQL_ROW row,
  157. const char *prefix,const char *name,
  158. int string_value);
  159. static int dump_selected_tables(char *db, char **table_names, int tables);
  160. static int dump_all_tables_in_db(char *db);
  161. static int init_dumping(char *);
  162. static int dump_databases(char **);
  163. static int dump_all_databases();
  164. static char *quote_name(char *name, char *buff);
  166. static void print_version(void)
  167. {
  168.   printf("%s  Ver %s Distrib %s, for %s (%s)n",my_progname,DUMP_VERSION,
  169.    MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
  170. } /* print_version */
  173. static void usage(void)
  174. {
  175.   uint i;
  176.   print_version();
  177.   puts("By Igor Romanenko, Monty, Jani & Sinisa");
  178.   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");
  179.   puts("Dumping definition and data mysql database or table");
  180.   printf("Usage: %s [OPTIONS] database [tables]n", my_progname);
  181.   printf("OR     %s [OPTIONS] --databases [OPTIONS] DB1 [DB2 DB3...]n",
  182.  my_progname);
  183.   printf("OR     %s [OPTIONS] --all-databases [OPTIONS]n", my_progname);
  184.   printf("n
  185.   -A, --all-databases   Dump all the databases. This will be same asn
  186.         --databases with all databases selected.n
  187.   -a, --all Include all MySQL specific create options.n
  188.   -#, --debug=...       Output debug log. Often this is 'd:t:o,filename`.n
  189.   --character-sets-dir=...n
  190.                         Directory where character sets aren
  191.   -?, --help Display this help message and exit.n
  192.   -B, --databases       To dump several databases. Note the difference inn
  193. usage; In this case no tables are given. All namen
  194. arguments are regarded as databasenames.n
  195. 'USE db_name;' will be included in the outputn
  196.   -c, --complete-insert Use complete insert statements.n
  197.   -C, --compress        Use compression in server/client protocol.n
  198.   --default-character-set=...n
  199.                         Set the default character setn
  200.   -e, --extended-insert Allows utilization of the new, much fastern
  201.                         INSERT syntax.n
  202.   --add-drop-table Add a 'drop table' before each create.n
  203.   --add-locks Add locks around insert statements.n
  204.   --allow-keywords Allow creation of column names that are keywords.n
  205.   --delayed-insert      Insert rows with INSERT DELAYED.n
  206.   -F, --flush-logs Flush logs file in server before starting dump.n
  207.   -f, --force Continue even if we get an sql-error.n
  208.   -h, --host=... Connect to host.n");
  209. puts("
  210.   -l, --lock-tables     Lock all tables for read.n
  211.   -n, --no-create-db    'CREATE DATABASE /*!32312 IF NOT EXISTS*/ db_name;'n
  212.                         will not be put in the output. The above line willn
  213.                         be added otherwise, if --databases orn
  214.                         --all-databases option was given.n
  215.   -t, --no-create-info Don't write table creation info.n
  216.   -d, --no-data No row information.n
  217.   -O, --set-variable var=optionn
  218.                         give a variable a value. --help lists variablesn
  219.   --opt Same as --add-drop-table --add-locks --alln
  220.                         --extended-insert --quick --lock-tablesn
  221.   -p, --password[=...] Password to use when connecting to server.n
  222.                         If password is not given it's solicited on the tty.n");
  223. #ifdef __WIN__
  224.   puts("-W, --pipe Use named pipes to connect to server");
  225. #endif
  226.   printf("
  227.   -P, --port=... Port number to use for connection.n
  228.   -q, --quick Don't buffer query, dump directly to stdout.n
  229.   -Q, --quote-names Quote table and column names with `n
  230.   -S, --socket=... Socket file to use for connection.n
  231.   --tables              Overrides option --databases (-B).n");
  232. #include "sslopt-usage.h"
  233.   printf("
  234.   -T, --tab=...         Creates tab separated textfile for each table ton
  235.                         given path. (creates .sql and .txt files).n
  236.                         NOTE: This only works if mysqldump is run onn
  237.                               the same machine as the mysqld daemon.n");
  238. #ifndef DONT_ALLOW_USER_CHANGE
  239.   printf("
  240.   -u, --user=# User for login if not current user.n");
  241. #endif
  242.   printf("
  243.   -v, --verbose Print info about the various stages.n
  244.   -V, --version Output version information and exit.n
  245.   -w, --where= dump only selected records; QUOTES mandatory!n
  246.   EXAMPLES: "--where=user='jimf'" "-wuserid>1" "-wuserid<1"n
  247.   Use -T (--tab=...) with --fields-...n
  248.   --fields-terminated-by=...n
  249.                         Fields in the textfile are terminated by ...n
  250.   --fields-enclosed-by=...n
  251.                         Fields in the importfile are enclosed by ...n
  252.   --fields-optionally-enclosed-by=...n
  253.                         Fields in the i.file are opt. enclosed by ...n
  254.   --fields-escaped-by=...n
  255.                         Fields in the i.file are escaped by ...n
  256.   --lines-terminated-by=...n
  257.                         Lines in the i.file are terminated by ...n
  258. ");
  259.   print_defaults("my",load_default_groups);
  261.   printf("nPossible variables for option --set-variable (-O) are:n");
  262.   for (i=0 ; changeable_vars[i].name ; i++)
  263.     printf("%-20s  current value: %lun",
  264.      changeable_vars[i].name,
  265.      (ulong) *changeable_vars[i].varptr);
  266. } /* usage */
  269. static void write_heder(FILE *sql_file, char *db_name)
  270. {
  271.   fprintf(sql_file, "# MySQL dump %sn#n", DUMP_VERSION);
  272.   fprintf(sql_file, "# Host: %s    Database: %sn",
  273.   current_host ? current_host : "localhost", db_name ? db_name : "");
  274.   fputs("#--------------------------------------------------------n",
  275.   sql_file);
  276.   fprintf(sql_file, "# Server versiont%sn",
  277.   mysql_get_server_info(&mysql_connection));
  278.   return;
  279. } /* write_heder */
  282. static int get_options(int *argc,char ***argv)
  283. {
  284.   int c,option_index;
  285.   my_bool tty_password=0;
  287.   load_defaults("my",load_default_groups,argc,argv);
  288.   set_all_changeable_vars(changeable_vars);
  289.   while ((c=getopt_long(*argc,*argv,"#::p::h:u:O:P:S:T:EBaAcCdefFlnqtvVw:?Ix",
  290. long_options, &option_index)) != EOF)
  291.   {
  292.     switch(c) {
  293.     case 'a':
  294.       create_options=1;
  295.       break;
  296.     case 'e':
  297.       extended_insert=1;
  298.       break;
  299.     case 'A':
  300.       opt_alldbs=1;
  301.       break;
  302.     case OPT_DEFAULT_CHARSET:
  303.       default_charset= optarg;
  304.       break;
  305.     case OPT_CHARSETS_DIR:
  306.       charsets_dir= optarg;
  307.       break;
  308.     case 'f':
  309.       ignore_errors=1;
  310.       break;
  311.     case 'F':
  312.       flush_logs=1;
  313.       break;
  314.     case 'h':
  315.       my_free(current_host,MYF(MY_ALLOW_ZERO_PTR));
  316.       current_host=my_strdup(optarg,MYF(MY_WME));
  317.       break;
  318.     case 'n':
  319.       opt_create_db = 1;
  320.       break;
  321. #ifndef DONT_ALLOW_USER_CHANGE
  322.     case 'u':
  323.       current_user=optarg;
  324.       break;
  325. #endif
  326.     case 'O':
  327.       if (set_changeable_var(optarg, changeable_vars))
  328.       {
  329. usage();
  330. return(1);
  331.       }
  332.       break;
  333.     case 'p':
  334.       if (optarg)
  335.       {
  336. char *start=optarg;
  337. my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR));
  338. opt_password=my_strdup(optarg,MYF(MY_FAE));
  339. while (*optarg) *optarg++= 'x'; /* Destroy argument */
  340. if (*start)
  341.   start[1]=0; /* Cut length of argument */
  342.       }
  343.       else
  344. tty_password=1;
  345.       break;
  346.     case 'P':
  347.       opt_mysql_port= (unsigned int) atoi(optarg);
  348.       break;
  349.     case 'S':
  350.       opt_mysql_unix_port= optarg;
  351.       break;
  352.     case 'W':
  353. #ifdef __WIN__
  354.       opt_mysql_unix_port=MYSQL_NAMEDPIPE;
  355. #endif
  356.       break;
  357.     case 'T':
  358.       path= optarg;
  359.       break;
  360.     case 'B':
  361.       opt_databases = 1;
  362.       break;
  363.     case '#':
  364.       DBUG_PUSH(optarg ? optarg : "d:t:o");
  365.       break;
  366.     case 'c': cFlag=1; break;
  367.     case 'C':
  368.       opt_compress=1;
  369.       break;
  370.     case 'd': dFlag=1; break;
  371.     case 'l': lock_tables=1; break;
  372.     case 'q': quick=1; break;
  373.     case 'Q': opt_quoted=1; break;
  374.     case 't': tFlag=1;  break;
  375.     case 'v': verbose=1; break;
  376.     case 'V': print_version(); exit(0);
  377.     case 'w':
  378.       where=optarg;
  379.       break;
  380.     case 'x':
  381.       opt_first_slave=1;
  382.       break;
  383.     default:
  384.       fprintf(stderr,"%s: Illegal option character '%c'n",my_progname,opterr);
  385.       /* Fall throught */
  386.     case 'I':
  387.     case '?':
  388.       usage();
  389.       exit(0);
  390.     case (int) OPT_FTB:
  391.       fields_terminated= optarg;
  392.       break;
  393.     case (int) OPT_LTB:
  394.       lines_terminated= optarg;
  395.       break;
  396.     case (int) OPT_ENC:
  397.       enclosed= optarg;
  398.       break;
  399.     case (int) OPT_O_ENC:
  400.       opt_enclosed= optarg;
  401.       break;
  402.     case (int) OPT_ESC:
  403.       escaped= optarg;
  404.       break;
  405.     case (int) OPT_DROP:
  406.       opt_drop=1;
  407.       break;
  408.     case (int) OPT_KEYWORDS:
  409.       opt_keywords=1;
  410.       break;
  411.     case (int) OPT_LOCKS:
  412.       opt_lock=1;
  413.       break;
  414.     case (int) OPT_OPTIMIZE:
  415.       extended_insert=opt_drop=opt_lock=lock_tables=quick=create_options=1;
  416.       break;
  417.     case (int) OPT_DELAYED:
  418.       opt_delayed=1;
  419.       break;
  420.     case (int) OPT_TABLES:
  421.       opt_databases=0;
  422.       break;
  423. #include "sslopt-case.h"
  424.     }
  425.   }
  426.   if (opt_delayed)
  427.     opt_lock=0; /* Can't have lock with delayed */
  428.   if (!path && (enclosed || opt_enclosed || escaped || lines_terminated ||
  429. fields_terminated))
  430.   {
  431.     fprintf(stderr, "%s: You must use option --tab with --fields-...n", my_progname);
  432.     return(1);
  433.   }
  435.   if (enclosed && opt_enclosed)
  436.   {
  437.     fprintf(stderr, "%s: You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.n", my_progname);
  438.     return(1);
  439.   }
  440.   if (replace && ignore)
  441.   {
  442.     fprintf(stderr, "%s: You can't use --ignore (-i) and --replace (-r) at the same time.n",my_progname);
  443.     return(1);
  444.   }
  445.   if ((opt_databases || opt_alldbs) && path)
  446.   {
  447.     fprintf(stderr,
  448.     "%s: --databases or --all-databases can't be used with --tab.n",
  449.     my_progname);
  450.     return(1);
  451.   }
  452.   if (default_charset)
  453.   {
  454.     if (set_default_charset_by_name(default_charset, MYF(MY_WME)))
  455.       exit(1);
  456.   }
  457.   (*argc)-=optind;
  458.   (*argv)+=optind;
  459.   if ((*argc < 1 && !opt_alldbs) || (*argc > 0 && opt_alldbs))
  460.   {
  461.     usage();
  462.     return 1;
  463.   }
  464.   if (tty_password)
  465.     opt_password=get_tty_password(NullS);
  466.   return(0);
  467. } /* get_options */
  470. /*
  471. ** DBerror -- prints mysql error message and exits the program.
  472. */
  473. static void DBerror(MYSQL *mysql, const char *when)
  474. {
  475.   DBUG_ENTER("DBerror");
  476.   my_printf_error(0,"Got error: %d: %s %s", MYF(0),
  477.   mysql_errno(mysql), mysql_error(mysql), when);
  478.   safe_exit(EX_MYSQLERR);
  479.   DBUG_VOID_RETURN;
  480. } /* DBerror */
  483. static void safe_exit(int error)
  484. {
  485.   if (!first_error)
  486.     first_error= error;
  487.   if (ignore_errors)
  488.     return;
  489.   if (sock)
  490.     mysql_close(sock);
  491.   exit(error);
  492. }
  493. /* safe_exit */
  496. /*
  497. ** dbConnect -- connects to the host and selects DB.
  498. **        Also checks whether the tablename is a valid table name.
  499. */
  500. static int dbConnect(char *host, char *user,char *passwd)
  501. {
  502.   DBUG_ENTER("dbConnect");
  503.   if (verbose)
  504.   {
  505.     fprintf(stderr, "# Connecting to %s...n", host ? host : "localhost");
  506.   }
  507.   mysql_init(&mysql_connection);
  508.   if (opt_compress)
  509.     mysql_options(&mysql_connection,MYSQL_OPT_COMPRESS,NullS);
  510. #ifdef HAVE_OPENSSL
  511.   if (opt_use_ssl)
  512.     mysql_ssl_set(&mysql_connection, opt_ssl_key, opt_ssl_cert, opt_ssl_ca,
  513.   opt_ssl_capath);
  514. #endif
  515.   if (!(sock= mysql_real_connect(&mysql_connection,host,user,passwd,
  516.          NULL,opt_mysql_port,opt_mysql_unix_port,
  517.          0)))
  518.   {
  519.     DBerror(&mysql_connection, "when trying to connect");
  520.     return 1;
  521.   }
  522.   return 0;
  523. } /* dbConnect */
  526. /*
  527. ** dbDisconnect -- disconnects from the host.
  528. */
  529. static void dbDisconnect(char *host)
  530. {
  531.   if (verbose)
  532.     fprintf(stderr, "# Disconnecting from %s...n", host ? host : "localhost");
  533.   mysql_close(sock);
  534. } /* dbDisconnect */
  537. static void unescape(FILE *file,char *pos,uint length)
  538. {
  539.   char *tmp;
  540.   DBUG_ENTER("unescape");
  541.   if (!(tmp=(char*) my_malloc(length*2+1, MYF(MY_WME))))
  542.   {
  543.     ignore_errors=0; /* Fatal error */
  544.     safe_exit(EX_MYSQLERR); /* Force exit */
  545.   }
  546.   mysql_real_escape_string(&mysql_connection,tmp, pos, length);
  547.   fputc(''', file);
  548.   fputs(tmp, file);
  549.   fputc(''', file);
  550.   my_free(tmp, MYF(MY_WME));
  551.   DBUG_VOID_RETURN;
  552. } /* unescape */
  555. static my_bool test_if_special_chars(const char *str)
  556. {
  557. #if MYSQL_VERSION_ID >= 32300
  558.   for ( ; *str ; str++)
  559.     if (!isvar(*str) && *str != '$')
  560.       return 1;
  561. #endif
  562.   return 0;
  563. } /* test_if_special_chars */
  565. static char *quote_name(char *name, char *buff)
  566. {
  567.   char *end;
  568.   if (!opt_quoted && !test_if_special_chars(name))
  569.     return name;
  570.   buff[0]=QUOTE_CHAR;
  571.   end=strmov(buff+1,name);
  572.   end[0]=QUOTE_CHAR;
  573.   end[1]=0;
  574.   return buff;
  575. } /* quote_name */
  578. /*
  579. ** getStructure -- retrievs database structure, prints out corresponding
  580. **       CREATE statement and fills out insert_pat.
  581. ** Return values:  number of fields in table, 0 if error
  582. */
  583. static uint getTableStructure(char *table, char* db)
  584. {
  585.   MYSQL_RES  *tableRes;
  586.   MYSQL_ROW  row;
  587.   my_bool    init=0;
  588.   uint       numFields;
  589.   char       *strpos, *table_name;
  590.   const char *delayed;
  591.   char       name_buff[NAME_LEN+3],table_buff[NAME_LEN+3];
  592.   FILE       *sql_file = stdout;
  593.   DBUG_ENTER("getTableStructure");
  595.   delayed= opt_delayed ? " DELAYED " : "";
  597.   if (verbose)
  598.     fprintf(stderr, "# Retrieving table structure for table %s...n", table);
  600.   sprintf(insert_pat,"SET OPTION SQL_QUOTE_SHOW_CREATE=%d", opt_quoted);
  601.   table_name=quote_name(table,table_buff);
  602.   if (!mysql_query(sock,insert_pat))
  603.   {
  604.     /* using SHOW CREATE statement */
  605.     if (!tFlag)
  606.     {
  607.       /* Make an sql-file, if path was given iow. option -T was given */
  608.       char buff[20+FN_REFLEN];
  610.       sprintf(buff,"show create table %s",table_name);
  611.       if (mysql_query(sock, buff))
  612.       {
  613.         fprintf(stderr, "%s: Can't get CREATE TABLE for table '%s' (%s)n",
  614.          my_progname, table, mysql_error(sock));
  615.         safe_exit(EX_MYSQLERR);
  616.         DBUG_RETURN(0);
  617.       }
  619.       if (path)
  620.       {
  621.         char filename[FN_REFLEN], tmp_path[FN_REFLEN];
  622.         strmov(tmp_path,path);
  623.         convert_dirname(tmp_path);
  624.         sql_file= my_fopen(fn_format(filename, table, tmp_path, ".sql", 4),
  625.     O_WRONLY, MYF(MY_WME));
  626.         if (!sql_file) /* If file couldn't be opened */
  627.         {
  628.    safe_exit(EX_MYSQLERR);
  629.    DBUG_RETURN(0);
  630.         }
  631.         write_heder(sql_file, db);
  632.       }
  633.       fprintf(sql_file, "n#n# Table structure for table '%s'n#nn", table);
  634.       if (opt_drop)
  635.         fprintf(sql_file, "DROP TABLE IF EXISTS %s;n",table_name);
  637.       tableRes=mysql_store_result(sock);
  638.       row=mysql_fetch_row(tableRes);
  639.       fprintf(sql_file, "%s;n", row[1]);
  640.       mysql_free_result(tableRes);
  641.     }
  642.     sprintf(insert_pat,"show fields from %s",table_name);
  643.     if (mysql_query(sock,insert_pat) || !(tableRes=mysql_store_result(sock)))
  644.     {
  645.       fprintf(stderr, "%s: Can't get info about table: '%s'nerror: %sn",
  646.        my_progname, table, mysql_error(sock));
  647.       safe_exit(EX_MYSQLERR);
  648.       DBUG_RETURN(0);
  649.     }
  651.     if (cFlag)
  652.       sprintf(insert_pat, "INSERT %sINTO %s (", delayed, table_name);
  653.     else
  654.     {
  655.       sprintf(insert_pat, "INSERT %sINTO %s VALUES ", delayed, table_name);
  656.       if (!extended_insert)
  657.         strcat(insert_pat,"(");
  658.     }
  660.     strpos=strend(insert_pat);
  661.     while ((row=mysql_fetch_row(tableRes)))
  662.     {
  663.       if (init)
  664.       {
  665.         if (cFlag)
  666.   strpos=strmov(strpos,", ");
  667.       }
  668.       init=1;
  669.       if (cFlag)
  670.         strpos=strmov(strpos,quote_name(row[SHOW_FIELDNAME],name_buff));
  671.     }
  672.     numFields = (uint) mysql_num_rows(tableRes);
  673.     mysql_free_result(tableRes);
  674.   }
  675.   else
  676.   {
  677.   /*  fprintf(stderr, "%s: Can't set SQL_QUOTE_SHOW_CREATE option (%s)n",
  678.       my_progname, mysql_error(sock)); */
  680.     sprintf(insert_pat,"show fields from %s",table_name);
  681.     if (mysql_query(sock,insert_pat) || !(tableRes=mysql_store_result(sock)))
  682.     {
  683.       fprintf(stderr, "%s: Can't get info about table: '%s'nerror: %sn",
  684.     my_progname, table, mysql_error(sock));
  685.       safe_exit(EX_MYSQLERR);
  686.       DBUG_RETURN(0);
  687.     }
  689.     /* Make an sql-file, if path was given iow. option -T was given */
  690.     if (!tFlag)
  691.     {
  692.       if (path)
  693.       {
  694.         char filename[FN_REFLEN], tmp_path[FN_REFLEN];
  695.         strmov(tmp_path,path);
  696.         convert_dirname(tmp_path);
  697.         sql_file= my_fopen(fn_format(filename, table, tmp_path, ".sql", 4),
  698.  O_WRONLY, MYF(MY_WME));
  699.         if (!sql_file) /* If file couldn't be opened */
  700.         {
  701. safe_exit(EX_MYSQLERR);
  702. DBUG_RETURN(0);
  703.         }
  704.         write_heder(sql_file, db);
  705.       }
  706.       fprintf(sql_file, "n#n# Table structure for table '%s'n#nn", table);
  707.       if (opt_drop)
  708.         fprintf(sql_file, "DROP TABLE IF EXISTS %s;n",table_name);
  709.       fprintf(sql_file, "CREATE TABLE %s (n", table_name);
  710.     }
  711.     if (cFlag)
  712.       sprintf(insert_pat, "INSERT %sINTO %s (", delayed, table_name);
  713.     else
  714.     {
  715.       sprintf(insert_pat, "INSERT %sINTO %s VALUES ", delayed, table_name);
  716.       if (!extended_insert)
  717.         strcat(insert_pat,"(");
  718.     }
  720.     strpos=strend(insert_pat);
  721.     while ((row=mysql_fetch_row(tableRes)))
  722.     {
  723.       ulong *lengths=mysql_fetch_lengths(tableRes);
  724.       if (init)
  725.       {
  726.         if (!tFlag)
  727. fputs(",n",sql_file);
  728.         if (cFlag)
  729. strpos=strmov(strpos,", ");
  730.       }
  731.       init=1;
  732.       if (cFlag)
  733.         strpos=strmov(strpos,quote_name(row[SHOW_FIELDNAME],name_buff));
  734.       if (!tFlag)
  735.       {
  736.         if (opt_keywords)
  737. fprintf(sql_file, "  %s.%s %s", table_name,
  738. quote_name(row[SHOW_FIELDNAME],name_buff), row[SHOW_TYPE]);
  739.         else
  740. fprintf(sql_file, "  %s %s", quote_name(row[SHOW_FIELDNAME],name_buff),
  741. row[SHOW_TYPE]);
  742.         if (row[SHOW_DEFAULT])
  743.         {
  744. fputs(" DEFAULT ", sql_file);
  745. unescape(sql_file,row[SHOW_DEFAULT],lengths[SHOW_DEFAULT]);
  746.         }
  747.         if (!row[SHOW_NULL][0])
  748. fputs(" NOT NULL", sql_file);
  749.         if (row[SHOW_EXTRA][0])
  750. fprintf(sql_file, " %s",row[SHOW_EXTRA]);
  751.       }
  752.     }
  753.     numFields = (uint) mysql_num_rows(tableRes);
  754.     mysql_free_result(tableRes);
  755.     if (!tFlag)
  756.     {
  757.       /* Make an sql-file, if path was given iow. option -T was given */
  758.       char buff[20+FN_REFLEN];
  759.       uint keynr,primary_key;
  760.       sprintf(buff,"show keys from %s",table_name);
  761.       if (mysql_query(sock, buff))
  762.       {
  763.         fprintf(stderr, "%s: Can't get keys for table '%s' (%s)n",
  764.       my_progname, table, mysql_error(sock));
  765.         if (sql_file != stdout)
  766. my_fclose(sql_file, MYF(MY_WME));
  767.         safe_exit(EX_MYSQLERR);
  768.         DBUG_RETURN(0);
  769.       }
  771.       tableRes=mysql_store_result(sock);
  772.       /* Find first which key is primary key */
  773.       keynr=0;
  774.       primary_key=INT_MAX;
  775.       while ((row=mysql_fetch_row(tableRes)))
  776.       {
  777.         if (atoi(row[3]) == 1)
  778.         {
  779. keynr++;
  780.     #ifdef FORCE_PRIMARY_KEY
  781. if (atoi(row[1]) == 0 && primary_key == INT_MAX)
  782.   primary_key=keynr;
  783.     #endif
  784. if (!strcmp(row[2],"PRIMARY"))
  785. {
  786.   primary_key=keynr;
  787.   break;
  788. }
  789.         }
  790.       }
  791.       mysql_data_seek(tableRes,0);
  792.       keynr=0;
  793.       while ((row=mysql_fetch_row(tableRes)))
  794.       {
  795.         if (atoi(row[3]) == 1)
  796.         {
  797. if (keynr++)
  798.   putc(')', sql_file);
  799. if (atoi(row[1]))       /* Test if duplicate key */
  800.   /* Duplicate allowed */
  801.   fprintf(sql_file, ",n  KEY %s (",quote_name(row[2],name_buff));
  802. else if (keynr == primary_key)
  803.   fputs(",n  PRIMARY KEY (",sql_file); /* First UNIQUE is primary */
  804. else
  805.   fprintf(sql_file, ",n  UNIQUE %s (",quote_name(row[2],name_buff));
  806.         }
  807.         else
  808. putc(',', sql_file);
  809.         fputs(quote_name(row[4],name_buff), sql_file);
  810.         if (row[7])
  811. fprintf(sql_file, " (%s)",row[7]);      /* Sub key */
  812.       }
  813.       if (keynr)
  814.         putc(')', sql_file);
  815.       fputs("n)",sql_file);
  817.       /* Get MySQL specific create options */
  818.       if (create_options)
  819.       {
  820.         sprintf(buff,"show table status like '%s'",table);
  821.         if (mysql_query(sock, buff))
  822.         {
  823. if (mysql_errno(sock) != ER_PARSE_ERROR)
  824. { /* If old MySQL version */
  825.   if (verbose)
  826.     fprintf(stderr,
  827.     "# Warning: Couldn't get status information for table '%s' (%s)n",
  828.     table,mysql_error(sock));
  829. }
  830.         }
  831.         else if (!(tableRes=mysql_store_result(sock)) ||
  832.        !(row=mysql_fetch_row(tableRes)))
  833.         {
  834. fprintf(stderr,
  835. "Error: Couldn't read status information for table '%s' (%s)n",
  836. table,mysql_error(sock));
  837.         }
  838.         else
  839.         {
  840. fputs("/*!",sql_file);
  841. print_value(sql_file,tableRes,row,"type=","Type",0);
  842. print_value(sql_file,tableRes,row,"","Create_options",0);
  843. print_value(sql_file,tableRes,row,"comment=","Comment",1);
  844. fputs(" */",sql_file);
  845.         }
  846.         mysql_free_result(tableRes); /* Is always safe to free */
  847.       }
  848.       fputs(";n", sql_file);
  849.     }
  850.   }
  851.   if (cFlag)
  852.   {
  853.     strpos=strmov(strpos,") VALUES ");
  854.     if (!extended_insert)
  855.       strpos=strmov(strpos,"(");
  856.   }
  857.   DBUG_RETURN(numFields);
  858. } /* getTableStructure */
  861. static char *add_load_option(char *ptr,const char *object,
  862.      const char *statement)
  863. {
  864.   if (object)
  865.   {
  866.     /* Don't escape hex constants */
  867.     if (object[0] == '0' && (object[1] == 'x' || object[1] == 'X'))
  868.       ptr= strxmov(ptr," ",statement," ",object,NullS);
  869.     else
  870.     {
  871.       /* char constant; escape */
  872.       ptr= strxmov(ptr," ",statement," '",NullS);
  873.       ptr= field_escape(ptr,object,(uint) strlen(object));
  874.       *ptr++= ''';
  875.     }
  876.   }
  877.   return ptr;
  878. } /* add_load_option */
  881. /*
  882. ** Allow the user to specify field terminator strings like:
  883. ** "'", "", "\" (escaped backslash), "t" (tab), "n" (newline)
  884. ** This is done by doubleing ' and add a end - if needed to avoid
  885. ** syntax errors from the SQL parser.
  886. */
  888. static char *field_escape(char *to,const char *from,uint length)
  889. {
  890.   const char *end;
  891.   uint end_backslashes=0;
  893.   for (end= from+length; from != end; from++)
  894.   {
  895.     *to++= *from;
  896.     if (*from == '\')
  897.       end_backslashes^=1;    /* find odd number of backslashes */
  898.     else
  899.     {
  900.       if (*from == ''' && !end_backslashes)
  901. *to++= *from;      /* We want a duplicate of "'" for MySQL */
  902.       end_backslashes=0;
  903.     }
  904.   }
  905.   /* Add missing backslashes if user has specified odd number of backs.*/
  906.   if (end_backslashes)
  907.     *to++= '\';
  908.   return to;
  909. } /* field_escape */
  912. /*
  913. ** dumpTable saves database contents as a series of INSERT statements.
  914. */
  915. static void dumpTable(uint numFields, char *table)
  916. {
  917.   char query[1024], *end, buff[256],table_buff[NAME_LEN+3];
  918.   MYSQL_RES *res;
  919.   MYSQL_FIELD  *field;
  920.   MYSQL_ROW    row;
  921.   ulong rownr, row_break, total_length, init_length;
  923.   if (verbose)
  924.     fprintf(stderr, "# Sending SELECT query...n");
  925.   if (path)
  926.   {
  927.     char filename[FN_REFLEN], tmp_path[FN_REFLEN];
  928.     strmov(tmp_path, path);
  929.     convert_dirname(tmp_path);
  930.     my_load_path(tmp_path, tmp_path, NULL);
  931.     fn_format(filename, table, tmp_path, ".txt", 4);
  932.     my_delete(filename, MYF(0)); /* 'INTO OUTFILE' doesn't work, if
  933.     filename wasn't deleted */
  934.     to_unix_path(filename);
  935.     sprintf(query, "SELECT * INTO OUTFILE '%s'", filename);
  936.     end= strend(query);
  937.     if (replace)
  938.       end= strmov(end, " REPLACE");
  939.     if (ignore)
  940.       end= strmov(end, " IGNORE");
  942.     if (fields_terminated || enclosed || opt_enclosed || escaped)
  943.       end= strmov(end, " FIELDS");
  944.     end= add_load_option(end, fields_terminated, " TERMINATED BY");
  945.     end= add_load_option(end, enclosed, " ENCLOSED BY");
  946.     end= add_load_option(end, opt_enclosed, " OPTIONALLY ENCLOSED BY");
  947.     end= add_load_option(end, escaped, " ESCAPED BY");
  948.     end= add_load_option(end, lines_terminated, " LINES TERMINATED BY");
  949.     *end= '';
  951.     sprintf(buff," FROM %s",table);
  952.     end= strmov(end,buff);
  953.     if (where)
  954.       end= strxmov(end, " WHERE ",where,NullS);
  955.     if (mysql_query(sock, query))
  956.     {
  957.       DBerror(sock, "when executing 'SELECT INTO OUTFILE'");
  958.       return;
  959.     }
  960.   }
  961.   else
  962.   {
  963.     printf("n#n# Dumping data for table '%s'n", table);
  964.     sprintf(query, "SELECT * FROM %s", quote_name(table,table_buff));
  965.     if (where)
  966.     {
  967.       printf("# WHERE:  %sn",where);
  968.       strxmov(strend(query), " WHERE ",where,NullS);
  969.     }
  970.     puts("#n");
  972.     if (mysql_query(sock, query))
  973.     {
  974.       DBerror(sock, "when retrieving data from server");
  975.       return;
  976.     }
  977.     if (quick)
  978.       res=mysql_use_result(sock);
  979.     else
  980.       res=mysql_store_result(sock);
  981.     if (!res)
  982.     {
  983.       DBerror(sock, "when retrieving data from server");
  984.       return;
  985.     }
  986.     if (verbose)
  987.       fprintf(stderr, "# Retrieving rows...n");
  988.     if (mysql_num_fields(res) != numFields)
  989.     {
  990.       fprintf(stderr,"%s: Error in field count for table: '%s' !  Aborting.n",
  991.       my_progname,table);
  992.       safe_exit(EX_CONSCHECK);
  993.       return;
  994.     }
  996.     if (opt_lock)
  997.       printf("LOCK TABLES %s WRITE;n", quote_name(table,table_buff));
  999.     total_length=net_buffer_length; /* Force row break */
  1000.     row_break=0;
  1001.     rownr=0;
  1002.     init_length=(uint) strlen(insert_pat)+4;
  1004.     while ((row=mysql_fetch_row(res)))
  1005.     {
  1006.       uint i;
  1007.       ulong *lengths=mysql_fetch_lengths(res);
  1008.       rownr++;
  1009.       if (!extended_insert)
  1010. fputs(insert_pat,stdout);
  1011.       mysql_field_seek(res,0);
  1013.       for (i = 0; i < mysql_num_fields(res); i++)
  1014.       {
  1015. if (!(field = mysql_fetch_field(res)))
  1016. {
  1017.   sprintf(query,"%s: Not enough fields from table '%s'! Aborting.n",
  1018.   my_progname,table);
  1019.   fputs(query,stderr);
  1020.   safe_exit(EX_CONSCHECK);
  1021.   return;
  1022. }
  1023. if (extended_insert)
  1024. {
  1025.   ulong length = lengths[i];
  1026.   if (i == 0)
  1027.     dynstr_set(&extended_row,"(");
  1028.   else
  1029.     dynstr_append(&extended_row,",");
  1031.   if (row[i])
  1032.   {
  1033.     if (length)
  1034.     {
  1035.       if (!IS_NUM_FIELD(field))
  1036.       {
  1037. if (dynstr_realloc(&extended_row,length * 2+2))
  1038. {
  1039.   fputs("Aborting dump (out of memory)",stderr);
  1040.   safe_exit(EX_EOM);
  1041. }
  1042. dynstr_append(&extended_row,"'");
  1043. extended_row.length +=
  1044.   mysql_real_escape_string(&mysql_connection,
  1045.    &extended_row.str[extended_row.length],row[i],length);
  1046. extended_row.str[extended_row.length]='';
  1047. dynstr_append(&extended_row,"'");
  1048.       }
  1049.       else
  1050. dynstr_append(&extended_row,row[i]);
  1051.     }
  1052.     else
  1053.       dynstr_append(&extended_row,"''");
  1054.   }
  1055.   else if (dynstr_append(&extended_row,"NULL"))
  1056.   {
  1057.     fputs("Aborting dump (out of memory)",stderr);
  1058.     safe_exit(EX_EOM);
  1059.   }
  1060. }
  1061. else
  1062. {
  1063.   if (i)
  1064.     putchar(',');
  1065.   if (row[i])
  1066.   {
  1067.     if (!IS_NUM_FIELD(field))
  1068.       unescape(stdout, row[i], lengths[i]);
  1069.     else
  1070.       fputs(row[i],stdout);
  1071.   }
  1072.   else
  1073.   {
  1074.     fputs("NULL",stdout);
  1075.   }
  1076. }
  1077.       }
  1079.       if (extended_insert)
  1080.       {
  1081. ulong row_length;
  1082. dynstr_append(&extended_row,")");
  1083.         row_length = 2 + extended_row.length;
  1084.         if (total_length + row_length < net_buffer_length)
  1085.         {
  1086.   total_length += row_length;
  1087.   putchar(','); /* Always row break */
  1088.   fputs(extended_row.str,stdout);
  1089. }
  1090.         else
  1091.         {
  1092.   if (row_break)
  1093.     puts(";");
  1094.   row_break=1; /* This is first row */
  1095.   fputs(insert_pat,stdout);
  1096.   fputs(extended_row.str,stdout);
  1097.   total_length = row_length+init_length;
  1098.         }
  1099.       }
  1100.       else
  1101.       {
  1102. puts(");");
  1103.       }
  1104.     }
  1105.     if (extended_insert && row_break)
  1106.       puts(";"); /* If not empty table */
  1107.     fflush(stdout);
  1108.     if (mysql_errno(sock))
  1109.     {
  1110.       sprintf(query,"%s: Error %d: %s when dumping table '%s' at row: %ldn",
  1111.       my_progname,
  1112.       mysql_errno(sock),
  1113.       mysql_error(sock),
  1114.       table,
  1115.       rownr);
  1116.       fputs(query,stderr);
  1117.       safe_exit(EX_CONSCHECK);
  1118.       return;
  1119.     }
  1120.     if (opt_lock)
  1121.       puts("UNLOCK TABLES;");
  1122.     mysql_free_result(res);
  1123.   }
  1124. } /* dumpTable */
  1127. static char *getTableName(int reset)
  1128. {
  1129.   static MYSQL_RES *res = NULL;
  1130.   MYSQL_ROW    row;
  1132.   if (!res)
  1133.   {
  1134.     if (!(res = mysql_list_tables(sock,NullS)))
  1135.       return(NULL);
  1136.   }
  1137.   if ((row = mysql_fetch_row(res)))
  1138.     return((char*) row[0]);
  1140.   if (reset)
  1141.     mysql_data_seek(res,0);      /* We want to read again */
  1142.   else
  1143.   {
  1144.     mysql_free_result(res);
  1145.     res = NULL;
  1146.   }
  1147.   return(NULL);
  1148. } /* getTableName */
  1151. static int dump_all_databases()
  1152. {
  1153.   MYSQL_ROW row;
  1154.   MYSQL_RES *tableres;
  1155.   int result=0;
  1157.   if (mysql_query(sock, "SHOW DATABASES") ||
  1158.       !(tableres = mysql_store_result(sock)))
  1159.   {
  1160.     my_printf_error(0, "Error: Couldn't execute 'SHOW DATABASES': %s",
  1161.     MYF(0), mysql_error(sock));
  1162.     return 1;
  1163.   }
  1164.   while ((row = mysql_fetch_row(tableres)))
  1165.   {
  1166.     if (dump_all_tables_in_db(row[0]))
  1167.       result=1;
  1168.   }
  1169.   return result;
  1170. }
  1171. /* dump_all_databases */
  1174. static int dump_databases(char **db_names)
  1175. {
  1176.   int result=0;
  1177.   for ( ; *db_names ; db_names++)
  1178.   {
  1179.     if (dump_all_tables_in_db(*db_names))
  1180.       result=1;
  1181.   }
  1182.   return result;
  1183. } /* dump_databases */
  1186. static int init_dumping(char *database)
  1187. {
  1188.   if (mysql_select_db(sock, database))
  1189.   {
  1190.     DBerror(sock, "when selecting the database");
  1191.     return 1; /* If --force */
  1192.   }
  1193.   if (!path)
  1194.   {
  1195.     if (opt_databases || opt_alldbs)
  1196.     {
  1197.       printf("n#n# Current Database: %sn#n", database);
  1198.       if (!opt_create_db)
  1199. printf("nCREATE DATABASE /*!32312 IF NOT EXISTS*/ %s;n", database);
  1200.       printf("nUSE %s;n", database);
  1201.     }
  1202.   }
  1203.   if (extended_insert)
  1204.     if (init_dynamic_string(&extended_row, "", 1024, 1024))
  1205.       exit(EX_EOM);
  1206.   return 0;
  1207. } /* init_dumping */
  1210. static int dump_all_tables_in_db(char *database)
  1211. {
  1212.   char *table;
  1213.   uint numrows;
  1215.   if (init_dumping(database))
  1216.     return 1;
  1217.   if (lock_tables)
  1218.   {
  1219.     DYNAMIC_STRING query;
  1220.     init_dynamic_string(&query, "LOCK TABLES ", 256, 1024);
  1221.     for (numrows=0 ; (table = getTableName(1)) ; numrows++)
  1222.     {
  1223.       dynstr_append(&query, table);
  1224.       dynstr_append(&query, " READ /*!32311 LOCAL */,");
  1225.     }
  1226.     if (numrows && mysql_real_query(sock, query.str, query.length-1))
  1227.       DBerror(sock, "when using LOCK TABLES");
  1228.             /* We shall continue here, if --force was given */
  1229.     dynstr_free(&query);
  1230.   }
  1231.   if (flush_logs)
  1232.   {
  1233.     if (mysql_refresh(sock, REFRESH_LOG))
  1234.       DBerror(sock, "when doing refresh");
  1235.            /* We shall continue here, if --force was given */
  1236.   }
  1237.   while ((table = getTableName(0)))
  1238.   {
  1239.     numrows = getTableStructure(table, database);
  1240.     if (!dFlag && numrows > 0)
  1241.       dumpTable(numrows,table);
  1242.   }
  1243.   if (lock_tables)
  1244.     mysql_query(sock,"UNLOCK_TABLES");
  1245.   return 0;
  1246. } /* dump_all_tables_in_db */
  1250. static int dump_selected_tables(char *db, char **table_names, int tables)
  1251. {
  1252.   uint numrows;
  1254.   if (init_dumping(db))
  1255.     return 1;
  1256.   if (lock_tables)
  1257.   {
  1258.     DYNAMIC_STRING query;
  1259.     int i;
  1261.     init_dynamic_string(&query, "LOCK TABLES ", 256, 1024);
  1262.     for (i=0 ; i < tables ; i++)
  1263.     {
  1264.       dynstr_append(&query, table_names[i]);
  1265.       dynstr_append(&query, " READ /*!32311 LOCAL */,");
  1266.     }
  1267.     if (mysql_real_query(sock, query.str, query.length-1))
  1268.       DBerror(sock, "when doing LOCK TABLES");
  1269.        /* We shall countinue here, if --force was given */
  1270.     dynstr_free(&query);
  1271.   }
  1272.   if (flush_logs)
  1273.   {
  1274.     if (mysql_refresh(sock, REFRESH_LOG))
  1275.       DBerror(sock, "when doing refresh");
  1276.      /* We shall countinue here, if --force was given */
  1277.   }
  1278.   for (; tables > 0 ; tables-- , table_names++)
  1279.   {
  1280.     numrows = getTableStructure(*table_names, db);
  1281.     if (!dFlag && numrows > 0)
  1282.       dumpTable(numrows, *table_names);
  1283.   }
  1284.   if (lock_tables)
  1285.     mysql_query(sock,"UNLOCK_TABLES");
  1286.   return 0;
  1287. } /* dump_selected_tables */
  1290. /* Print a value with a prefix on file */
  1291. static void print_value(FILE *file, MYSQL_RES  *result, MYSQL_ROW row,
  1292. const char *prefix, const char *name,
  1293. int string_value)
  1294. {
  1295.   MYSQL_FIELD *field;
  1296.   mysql_field_seek(result, 0);
  1298.   for ( ; (field = mysql_fetch_field(result)) ; row++)
  1299.   {
  1300.     if (!strcmp(field->name,name))
  1301.     {
  1302.       if (row[0] && row[0][0] && strcmp(row[0],"0")) /* Skip default */
  1303.       {
  1304. fputc(' ',file);
  1305. fputs(prefix, file);
  1306. if (string_value)
  1307.   unescape(file,row[0],(uint) strlen(row[0]));
  1308. else
  1309.   fputs(row[0], file);
  1310. return;
  1311.       }
  1312.     }
  1313.   }
  1314.   return; /* This shouldn't happen */
  1315. } /* print_value */
  1318. int main(int argc, char **argv)
  1319. {
  1320.   MY_INIT(argv[0]);
  1321.   /*
  1322.   ** Check out the args
  1323.   */
  1324.   if (get_options(&argc, &argv))
  1325.   {
  1326.     my_end(0);
  1327.     exit(EX_USAGE);
  1328.   }
  1329.   if (dbConnect(current_host, current_user, opt_password))
  1330.     exit(EX_MYSQLERR);
  1331.   if (!path)
  1332.     write_heder(stdout, *argv);
  1334.    if (opt_first_slave)
  1335.    {
  1336.      lock_tables=0; /* No other locks needed */
  1337.      if (mysql_query(sock, "FLUSH TABLES WITH READ LOCK"))
  1338.      {
  1339.        my_printf_error(0, "Error: Couldn't execute 'FLUSH TABLES WITH READ LOCK': %s",
  1340.        MYF(0), mysql_error(sock));
  1341.        my_end(0);
  1342.        return(first_error);
  1343.      }
  1344.    }
  1345.   if (opt_alldbs)
  1346.     dump_all_databases();
  1347.   /* Only one database and selected table(s) */
  1348.   else if (argc > 1 && !opt_databases)
  1349.     dump_selected_tables(*argv, (argv + 1), (argc - 1));
  1350.   /* One or more databases, all tables */
  1351.   else
  1352.     dump_databases(argv);
  1354.   if (opt_first_slave)
  1355.   {
  1356.     if (mysql_query(sock, "FLUSH MASTER"))
  1357.     {
  1358.       my_printf_error(0, "Error: Couldn't execute 'FLUSH MASTER': %s",
  1359.       MYF(0), mysql_error(sock));
  1360.     }
  1361.     if (mysql_query(sock, "UNLOCK TABLES"))
  1362.     {
  1363.       my_printf_error(0, "Error: Couldn't execute 'UNLOCK TABLES': %s",
  1364.       MYF(0), mysql_error(sock));
  1365.    }
  1366.   }
  1367.   dbDisconnect(current_host);
  1368.   puts("");
  1369.   my_free(opt_password, MYF(MY_ALLOW_ZERO_PTR));
  1370.   if (extended_insert)
  1371.     dynstr_free(&extended_row);
  1372.   my_end(0);
  1373.   return(first_error);
  1374. } /* main */