~drizzle-trunk/drizzle/development

                      char **err_pos, uint *err_len);

 

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

                quick= 1, extended_insert= 1,

                lock_tables=1,ignore_errors=0,flush_logs=0,flush_privileges=0,

                opt_drop=1,opt_keywords=0,opt_lock=1,opt_compress=0,

                opt_include_master_host_port= 0,

                opt_events= 0,

                opt_alltspcs=0, opt_notspcs= 0;

static ulong opt_max_allowed_packet, opt_net_buffer_length;

static MYSQL mysql_connection,*mysql=0;

static DYNAMIC_STRING insert_pat;

static char **defaults_argv= 0;

static char compatible_mode_normal_str[255];

/* Server supports character_set_results session variable? */

static ulong opt_compatible_mode= 0;

#define MYSQL_OPT_MASTER_DATA_EFFECTIVE_SQL 1

#define MYSQL_OPT_MASTER_DATA_COMMENTED_SQL 2

FILE *md_result_file= 0;

FILE *stderror_file=0;

 

static uint opt_protocol= MYSQL_PROTOCOL_TCP;

 

/*

static CHARSET_INFO *charset_info= &my_charset_latin1;

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

/* have we seen any VIEWs during table scanning? */

const char *compatible_mode_names[]=

{

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

static struct my_option my_long_options[] =

{

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

   0, 0, 0, 0, 0},

  {"all-databases", 'A',

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

   0, 0},

  {"all-tablespaces", 'Y',

   "Dump all the tablespaces.",

   0, 0},

  {"no-tablespaces", 'y',

   "Do not dump any tablespace information.",

   0, 0},

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

   0},

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

   0},

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

   0},

  {"allow-keywords", OPT_KEYWORDS,

  {"apply-slave-statements", OPT_MYSQLDUMP_SLAVE_APPLY,

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

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

  {"character-sets-dir", OPT_CHARSETS_DIR,

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

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

  {"compatible", OPT_COMPATIBLE,

   "Change the dump to be compatible with a given mode. By default tables are dumped in a format optimized for MySQL. Legal modes are: ansi, mysql323, mysql40, postgresql, oracle, mssql, db2, maxdb, no_key_options, no_table_options, no_field_options. One can use several modes separated by commas. Note: Requires MySQL server version 4.1.0 or higher. This option is ignored with earlier server versions.",

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

  {"compact", OPT_COMPACT,

   "Give less verbose output (useful for debugging). Disables structure comments and header/footer constructs.  Enables options --skip-add-drop-table --no-set-names --skip-disable-keys --skip-add-locks",

   0, 0},

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

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

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

   0, 0, 0},

  {"create-options", OPT_CREATE_OPTIONS,

   "Include all MySQL specific create options.",

   0, 0, 0, 0, 0},

  {"databases", 'B',

   "To dump several databases. Note the difference in usage; In this case no tables are given. All name arguments are regarded as databasenames. 'USE db_name;' will be included in the output.",

   0, 0, 0, 0},

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

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

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

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

  {"default-character-set", OPT_DEFAULT_CHARSET,

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

   0, 0},

  {"delete-master-logs", OPT_DELETE_MASTER_LOGS,

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

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

  {"disable-keys", 'K',

  {"dump-slave", OPT_MYSQLDUMP_SLAVE_DATA,

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

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

   "- don't forget to read about --single-transaction below). In all cases "

   "any action on logs will happen at the exact moment of the dump."

   "Option automatically turns --lock-tables off.",

   GET_UINT, OPT_ARG, 0, 0, MYSQL_OPT_SLAVE_DATA_COMMENTED_SQL, 0, 0, 0},

  {"events", 'E', "Dump events.",

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

  {"extended-insert", 'e',

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

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

  {"fields-terminated-by", OPT_FTB,

  {"fields-enclosed-by", OPT_ENC,

  {"fields-optionally-enclosed-by", OPT_O_ENC,

  {"fields-escaped-by", OPT_ESC, "Fields in the i.file are escaped by ...",

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

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

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

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

   "to the moment all tables are locked. So if you want your dump and "

   "the log flush to happen at the same exact moment you should use "

   "--lock-all-tables or --master-data with --flush-logs",

   0, 0},

  {"flush-privileges", OPT_ESC, "Emit a FLUSH PRIVILEGES statement "

   "after dumping the mysql database.  This option should be used any "

   "time the dump contains the mysql database and any other database "

   "that depends on the data in the mysql database for proper restore. ",

   0, 0},

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

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

  {"help", '?', "Display this help message and exit.", 0, 0, 0, GET_NO_ARG,

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

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

    "VARBINARY, BLOB) in hexadecimal format.",

  {"ignore-table", OPT_IGNORE_TABLE,

   "Do not dump the specified table. To specify more than one table to ignore, "

   "use the directive multiple times, once for each table.  Each table must "

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

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

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

   0, GET_BOOL, NO_ARG,

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

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

   0, 0},

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

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

  {"lock-all-tables", 'x', "Locks all tables across all databases. This "

   "is achieved by taking a global read lock for the duration of the whole "

   "dump. Automatically turns --single-transaction and --lock-tables off.",

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

  {"log-error", OPT_ERROR_LOG_FILE, "Append warnings and errors to given file.",

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

  {"master-data", OPT_MASTER_DATA,

   "This causes the binary log position and filename to be appended to the "

   "- don't forget to read about --single-transaction below). In all cases "

   "any action on logs will happen at the exact moment of the dump."

   "Option automatically turns --lock-tables off.",

   GET_UINT, OPT_ARG, 0, 0, MYSQL_OPT_MASTER_DATA_COMMENTED_SQL, 0, 0, 0},

  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET, "",

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

  {"net_buffer_length", OPT_NET_BUFFER_LENGTH, "",

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

   MALLOC_OVERHEAD-1024, 1024, 0},

  {"no-autocommit", OPT_AUTOCOMMIT,

   "Wrap tables with autocommit/commit statements.",

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

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

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

   0, 0, 0, 0},

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

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

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

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

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

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

  {"order-by-primary", OPT_ORDER_BY_PRIMARY,

   "Sorts each table's rows by primary key, or first unique key, if such a key exists.  Useful when dumping a MyISAM table to be loaded into an InnoDB table, but will make the dump itself take considerably longer.",

  {"password", 'p',

   "Password to use when connecting to server. If password is not given it's solicited on the tty.",

   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

   0},

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

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

   0, 0},

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

   0, 0},

  {"result-file", 'r',

   "Direct output to a given file. This option should be used in MSDOS, because it prevents new line '\\n' from being converted to '\\r\\n' (carriage return + line feed).",

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

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

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

  {"set-charset", OPT_SET_CHARSET,

   "Add 'SET NAMES default_character_set' to the output.",

   0, 0, 0, 0, 0},

  {"set-variable", 'O',

   "Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value.",

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

  /*

    Note that the combination --single-transaction --master-data

    will give bullet-proof binlog position only if server >=4.1.3. That's the

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

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

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

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

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

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

  {"skip-opt", OPT_SKIP_OPTIMIZATION,

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

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

  {"tab",'T',

   "Creates tab separated textfile for each table to given path. (creates .sql and .txt files). NOTE: This only works if mysqldump is run on the same machine as the mysqld daemon.",

  {"tables", OPT_TABLES, "Overrides option --databases (-B).",

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

  {"tz-utc", OPT_TZ_UTC,

    "SET TIME_ZONE='+00:00' at top of dump to allow dumping of TIMESTAMP data when a server has data in different time zones or data is being moved between servers with different time zones.",

#ifndef DONT_ALLOW_USER_CHANGE

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

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

#endif

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

  {"version",'V', "Output version information and exit.", 0, 0, 0,

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

  {"where", 'w', "Dump only selected records; QUOTES mandatory!",

  {"xml", 'X', "Dump a database as well formed XML.", 0, 0, 0, GET_NO_ARG,

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

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

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

static int dump_databases(char **);

static int dump_all_databases(void);

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

static char *primary_key_fields(const char *table_name);

 

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

{

  va_list args;

 

  if (!verbose)

 

  va_start(args, fmt);

  vfprintf(stderr, fmt, args);

  va_end(args);

 

}

 

/*

 

 

static uchar* get_table_key(const char *entry, size_t *length,

{

  *length= strlen(entry);

  return (uchar*) entry;

}

 

 

get_one_option(int optid, const struct my_option *opt __attribute__((unused)),

               char *argument)

{

    }

 

    break;

  case 'V': print_version(); exit(0);

  case 'X':

    opt_xml= 1;

        fprintf(stderr, "Invalid mode to --compatible: %s\n", buff);

        exit(1);

      }

      mode= opt_compatible_mode;

      for (i= 0, mode= opt_compatible_mode; mode; mode>>= 1, i++)

      {

*/

static void DB_error(MYSQL *mysql_arg, const char *when)

{

  maybe_die(EX_MYSQLERR, "Got error: %d: %s %s",

          mysql_errno(mysql_arg), mysql_error(mysql_arg), when);

}

 

 

 

  /* Server lacks facility.  This is not an error, by arbitrary decision . */

  if (!server_supports_switching_charsets)

 

  query_length= snprintf(query_buffer,

                         sizeof (query_buffer),

static int connect_to_db(char *host, char *user,char *passwd)

{

  char buff[20+FN_REFLEN];

 

  verbose_msg("-- Connecting to %s...\n", host ? host : "localhost");

  mysql_init(&mysql_connection);

    mysql_options(&mysql_connection,MYSQL_OPT_COMPRESS,NullS);

  if (opt_protocol)

    mysql_options(&mysql_connection,MYSQL_OPT_PROTOCOL,(char*)&opt_protocol);

  mysql_options(&mysql_connection, MYSQL_SET_CHARSET_NAME, default_charset);

  if (!(mysql= mysql_real_connect(&mysql_connection,host,user,passwd,

                                  NULL,opt_mysql_port, NULL,

                                  0)))

  {

    DB_error(&mysql_connection, "when trying to connect");

  }

  if (mysql_get_server_version(&mysql_connection) < 40100)

  {

    opt_set_charset= 0;

 

    /* Don't switch charsets for 4.1 and earlier.  (bug#34192). */

  } 

  /*

    set time_zone to UTC to allow dumping date types between servers with

  {

    snprintf(buff, sizeof(buff), "/*!40103 SET TIME_ZONE='+00:00' */");

    if (mysql_query_with_error_report(mysql, 0, buff))

  }

} /* connect_to_db */

 

 

static void unescape(FILE *file,char *pos,uint length)

{

  char *tmp;

  if (!(tmp=(char*) my_malloc(length*2+1, MYF(MY_WME))))

    die(EX_MYSQLERR, "Couldn't allocate memory");

 

  fputc('\'', file);

  check_io(file);

  my_free(tmp, MYF(MY_WME));

} /* unescape */

 

 

{

  for ( ; *str ; str++)

    if (!my_isvar(charset_info,*str) && *str != '$')

      return 1;

  return 0;

} /* test_if_special_chars */

 

  buff                 quoted string

 

*/

{

  char *to= buff;

  char qtype= (opt_compatible_mode & MASK_ANSI_QUOTES) ? '\"' : '`';

  while (attribute_name != NullS)

  {

    attribute_value= va_arg(arg_list, char *);

 

    fputc(' ', xml_file);

    fputs(attribute_name, xml_file);    

{

  uint i;

  MYSQL_FIELD *field;

 

  fprintf(xml_file, "\t\t<%s", row_name);

  check_io(xml_file);

static uint get_table_structure(char *table, char *db, char *table_type,

                                char *ignore_flag)

{

  char       *result_table, *opt_quoted_table;

  const char *insert_option;

  char       name_buff[NAME_LEN+3],table_buff[NAME_LEN*2+3];

  int        len;

  MYSQL_RES  *result;

  MYSQL_ROW  row;

 

  *ignore_flag= check_if_ignore_table(table, table_type);

 

      if (switch_character_set_results(mysql, "binary") ||

          mysql_query_with_error_report(mysql, &result, buff) ||

          switch_character_set_results(mysql, default_charset))

 

      if (path)

      {

        if (!(sql_file= open_sql_file_for_table(table)))

 

        write_header(sql_file, db);

      }

 

          my_free(scv_buff, MYF(MY_ALLOW_ZERO_PTR));

 

        }

        else

          my_free(scv_buff, MYF(MY_ALLOW_ZERO_PTR));

          my_fclose(sql_file, MYF(MY_WME));

 

        seen_views= 1;

      }

 

      row= mysql_fetch_row(result);

    {

      if (path)

        my_fclose(sql_file, MYF(MY_WME));

    }

 

    /*

    snprintf(query_buff, sizeof(query_buff), "show fields from %s",

             result_table);

    if (mysql_query_with_error_report(mysql, &result, query_buff))

 

    /* Make an sql-file, if path was given iow. option -T was given */

    if (!opt_no_create_info)

      if (path)

      {

        if (!(sql_file= open_sql_file_for_table(table)))

        write_header(sql_file, db);

      }

      if (!opt_xml && opt_comments)

 

    while ((row= mysql_fetch_row(result)))

    {

      if (init)

      {

        if (!opt_xml && !opt_no_create_info)

                my_progname, result_table, mysql_error(mysql));

        if (path)

          my_fclose(sql_file, MYF(MY_WME));

      }

 

      /* Find first which key is primary key */

    write_footer(sql_file);

    my_fclose(sql_file, MYF(MY_WME));

  }

} /* get_table_structure */

 

static void add_load_option(DYNAMIC_STRING *str, const char *option,

  MYSQL_RES     *res;

  MYSQL_FIELD   *field;

  MYSQL_ROW     row;

 

  /*

    Make sure you get the create table info before the following check for

    The "table" could be a view.  If so, we don't do anything here.

  */

  if (strcmp(table_type, "VIEW") == 0)

 

  /* Check --no-data flag */

  if (opt_no_data)

  {

    verbose_msg("-- Skipping dump data for table '%s', --no-data was used\n",

                table);

  }

 

  /*

    If the table type is a merge table or any type that has to be

     _completely_ ignored and no data dumped

  {

    verbose_msg("-- Warning: Skipping data for table '%s' because " \

                "it's of type %s\n", table, table_type);

  }

  /* Check that there are any fields in the table */

  if (num_fields == 0)

  {

    verbose_msg("-- Skipping dump data for table '%s', it has no fields\n",

                table);

  }

 

  /*

      !my_strcasecmp(&my_charset_latin1, table, "event"))

  {

    verbose_msg("-- Skipping data table mysql.event, --skip-events was used\n");

  }

 

  result_table= quote_name(table,table_buff, 1);

    {

      DB_error(mysql, "when executing 'SELECT INTO OUTFILE'");

      dynstr_free(&query_string);

    }

  }

  else

    while ((row= mysql_fetch_row(res)))

    {

      uint i;

      rownr++;

      if (!extended_insert && !opt_xml)

      {

                  extended_row.length+= mysql_hex_string(extended_row.str +

                                                         extended_row.length,

                                                         row[i], length);

                  /* mysql_hex_string() already terminated string by '\0' */

                }

                else

                {

    mysql_free_result(res);

  }

  dynstr_free(&query_string);

 

err:

  dynstr_free(&query_string);

  maybe_exit(error);

} /* dump_table */

 

 

{

  int result=0;

  char **db;

 

  for (db= db_names ; *db ; db++)

  {

    if (dump_all_tables_in_db(*db))

      result=1;

  }

} /* dump_databases */

 

 

 

int init_dumping_tables(char *qdatabase)

{

 

  if (!opt_create_db)

  {

      mysql_free_result(dbinfo);

    }

  }

} /* init_dumping_tables */

 

 

 

/* Return 1 if we should copy the table */

 

{

  return !hash_search(&ignore_table, hash_key, len);

}

  char hash_key[2*NAME_LEN+2];  /* "db.tablename" */

  char *afterdot;

  int using_mysql_db= my_strcasecmp(&my_charset_latin1, database, "mysql");

 

  afterdot= strmov(hash_key, database);

  *afterdot++= '.';

 

  if (init_dumping(database, init_dumping_tables))

  if (opt_xml)

    print_xml_tag(md_result_file, "", "\n", "database", "name=", database, NullS);

  if (lock_tables)

    fprintf(md_result_file,"\n--\n-- Flush Grant Tables \n--\n");

    fprintf(md_result_file,"\n/*! FLUSH PRIVILEGES */;\n");

  }

} /* dump_all_tables_in_db */

 

 

  MYSQL_ROW  row;

  char query[50 + 2*NAME_LEN];

  char show_name_buff[FN_REFLEN];

 

  /* Check memory for quote_for_like() */

  snprintf(query, sizeof(query), "SHOW TABLES LIKE %s",

           quote_for_like(old_table_name, show_name_buff));

 

 

  if ((table_res= mysql_store_result(mysql)))

  {

    if (num_rows > 0)

    {

      /*

        Return first row

        TODO: Return all matching rows

    }

    mysql_free_result(table_res);

  }

}

 

 

  DYNAMIC_STRING lock_tables_query;

  MEM_ROOT root;

  char **dump_tables, **pos, **end;

 

  if (init_dumping(db, init_dumping_tables))

 

  init_alloc_root(&root, 8192, 0);

  if (!(dump_tables= pos= (char**) alloc_root(&root, tables * sizeof(char *))))

 

  /* Dump each selected table */

  for (pos= dump_tables; pos < end; pos++)

    dump_table(*pos, db);

 

  free_root(&root, MYF(0));

  my_free(order_by, MYF(MY_ALLOW_ZERO_PTR));

  }

  if (lock_tables)

    VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));

} /* dump_selected_tables */

 

 

        *err_len= var_len;

      }

      else

      if (pos == end)

        break;

      start= pos + 1;

 

  Check if we the table is one of the table types that should be ignored:

  MRG_ISAM, MRG_MYISAM, if opt_delayed, if that table supports delayed inserts.

  should not be ignored. If the user has selected to use INSERT DELAYED, it

  sets the value of the bool pointer supports_delayed_inserts to 0 if not

  supported, 1 if it is supported.

  char buff[FN_REFLEN+80], show_name_buff[FN_REFLEN];

  MYSQL_RES *res= NULL;

  MYSQL_ROW row;

 

  /* Check memory for quote_for_like() */

  snprintf(buff, sizeof(buff), "show table status like %s",

           quote_for_like(table_name, show_name_buff));

  if (mysql_query_with_error_report(mysql, &res, buff))

    {                                   /* If old MySQL version */

      verbose_msg("-- Warning: Couldn't get status information for "

                  "table %s (%s)\n", table_name, mysql_error(mysql));

    }

  }

  if (!(row= mysql_fetch_row(res)))

            "Error: Couldn't read status information for table %s (%s)\n",

            table_name, mysql_error(mysql));

    mysql_free_result(res);

  }

  if (!(row[1]))

    strmake(table_type, "VIEW", NAME_LEN-1);

      result= IGNORE_DATA;

  }

  mysql_free_result(res);

}

 

 

  if (opt_delete_master_logs && purge_bin_logs_to(mysql, bin_log_name))

    goto err;

 

  /*

    No reason to explicitely COMMIT the transaction, neither to explicitely

    UNLOCK TABLES: these will be automatically be done by the server when we