~drizzle-trunk/drizzle/development

  This program is free software; you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation; version 2 of the License.

 

  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

 

  You should have received a copy of the GNU General Public License

  along with this program; if not, write to the Free Software

  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

 **

 ** The author's original notes follow :-

 **

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

 ** DATE:   December 3, 1994

 ** WARRANTY: None, expressed, impressed, implied

 **          or other

 ** STATUS: Public domain

 * and more work by Monty, Jani & Sinisa

 * and all the MySQL developers over the years.

                         char **err_pos, uint32_t *err_len);

  "", compatible_mode_names, NULL};

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

    0, 0, 0, 0, 0},

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

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

    0, 0},

    "Dump all the tablespaces.",

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

    0, 0},

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

    0},

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

    0},

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

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

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

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

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

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

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

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

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

    0, 0},

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

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

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

    0, 0, 0},

    "Include all DRIZZLE specific create options.",

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

    0, 0, 0, 0, 0},

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

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

    0, 0, 0, 0},

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

    0, 0},

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

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

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

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

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

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

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

    "Fields in the importfile are enclosed by ...", (char**) &enclosed,

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

    "Fields in the i.file are opt. enclosed by ...", (char**) &opt_enclosed,

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

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

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

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

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

      "in this case the logs will be flushed only once, corresponding "

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

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

      "--lock-all-tables or --flush-logs",

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

    0, 0},

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

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

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

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

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

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

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

      "be specified with both database and table names, e.g. --ignore-table=database.table",

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

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

    0, 0},

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

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

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

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

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

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

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

    0, 0, 0},

    "Wrap tables with autocommit/commit statements.",

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

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

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

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

    0, 0, 0, 0},

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

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

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

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

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

    "Same as --add-drop-table, --add-locks, --create-options, --quick, --extended-insert, --lock-tables, --set-charset, and --disable-keys. Enabled by default, disable with --skip-opt.",

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

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

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

    "Password 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, 0, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

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

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

    0, 0},

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

    0, 0},

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

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

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

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

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

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

      "guaranteed to be consistent for other storage engines. "

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

      "dump file (correct table contents), no other "

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  verbose_msg()

  fmt   format specifier

  ...   variable number of parameters

  check_io()

  file        - checked file

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

              "\nSET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION;\n");

              SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;\n\

              SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;\n\

              ");

              SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;\n\

              SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;\n");

     *        This also helps with potential data loss casting unsigned long to a

     *               uint32_t. */

                          "Aborting.\n"));

            opt_xml= 1;

            extended_insert= opt_drop=

              opt_disable_keys= opt_autocommit= opt_create_db= 0;

            break;

            usage();

            exit(0);

            extended_insert= opt_drop= quick= create_options=

              opt_disable_keys= opt_set_charset= 1;

            break;

            extended_insert= opt_drop= quick= create_options=

              opt_disable_keys= opt_set_charset= 0;

            break;

            if (opt_compact)

            {

              opt_comments= opt_drop= opt_disable_keys= 0;

              opt_set_charset= 0;

            }

            opt_databases=0;

            break;

            {

              if (!strchr(argument, '.'))

              {

                fprintf(stderr, _("Illegal use of option --ignore-table=<database>.<table>\n"));

                return EXIT_ARGUMENT_INVALID;

              }

              string tmpptr(argument);

              ignore_table.insert(tmpptr); 

              break;

            }

            {

              char buff[255];

              char *end= compatible_mode_normal_str;

              uint32_t i;

              uint32_t mode;

              uint32_t error_len;

              opt_quoted= 1;

              opt_set_charset= 0;

              opt_compatible_mode_str= argument;

              opt_compatible_mode= find_set(&compatible_mode_typelib,

                                            argument, strlen(argument),

                                            &err_ptr, &error_len);

              if (error_len)

              {

                strncpy(buff, err_ptr, min((uint32_t)sizeof(buff), error_len+1));

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

                return EXIT_ARGUMENT_INVALID;

              }

              mode= opt_compatible_mode;

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

              {

                if (mode & 1)

                {

                  uint32_t len = strlen(compatible_mode_names[i]);

                  end= strcpy(end, compatible_mode_names[i]) + len;

                  end= strcpy(end, ",")+1;

                }

              }

              if (end!=compatible_mode_normal_str)

                end[-1]= 0;

            }

                      "--lock-all-tables at the same time.\n"), internal::my_progname);

 ** DB_error -- prints DRIZZLE error message and exits the program.

              drizzle_result_error_code(res),

              when);

  die()

  error_num   - process return value

  fmt_reason  - a format string for use by vsnprintf.

  ...         - variable arguments for above fmt_reason string

  This call prints out the formatted error message to stderr and then

  terminates the process.

  maybe_die()

  error_num   - process return value

  fmt_reason  - a format string for use by vsnprintf.

  ...         - variable arguments for above fmt_reason string

  This call prints out the formatted error message to stderr and then

  terminates the process, unless the --force command line option is used.

  This call should be used for non-fatal errors (such as database

  errors) that the code may still be able to continue to the next unit

  of work.

  drizzleclient_query_with_error_report()

  drizzle_con       connection to use

  res             if non zero, result will be put there with

  drizzleclient_store_result()

  query           query to send to server

  0               query sending and (if res!=0) result reading went ok

  1               error

  open_sql_file_for_table

  name      name of the table or view

  0        Failed to open file

  > 0      Handle of the open file

 ** dbDisconnect -- disconnects from the host.

  quote_for_like()

  name     name of the table

  buff     quoted name of the table

  Quote \, _, ' and % characters

 

Note: Because DRIZZLE uses the C escape syntax in strings

(for example, '\n' to represent newline), you must double

any '\' that you use in your LIKE  strings. For example, to

search for '\n', specify it as '\\n'. To search for '\', specify

it as '\\\\' (the backslashes are stripped once by the parser

and another time when the pattern match is done, leaving a

single backslash to be matched).

 

Example: "t\1" => "t\\\\1"

  print_quoted_xml()

  xml_file    - output file

  str         - string to print

  len         - its length

  Quote '<' '>' '&' '\"' chars and print a string to the xml_file.

      case '\"':

        fputs("&quot;", xml_file);

  print_xml_tag(xml_file, sbeg, send, tag_name, first_attribute_name,

  ..., attribute_name_n, attribute_value_n, NULL)

  xml_file              - output file

  sbeg                  - line beginning

  line_end              - line ending

  tag_name              - XML tag name.

  first_attribute_name  - tag and first attribute

  first_attribute_value - (Implied) value of first attribute

  attribute_name_n      - attribute n

  attribute_value_n     - value of attribute n

  Print XML tag with any number of attribute="value" pairs to the xml_file.

  Format is:

  sbeg<tag_name first_attribute_name="first_attribute_value" ...

  attribute_name_n="attribute_value_n">send

  Additional arguments must be present in attribute/value pairs.

  The last argument should be the null character pointer.

  All attribute_value arguments MUST be NULL terminated strings.

  All attribute_value arguments will be quoted before output.

  print_xml_null_tag()

  xml_file    - output file

  sbeg        - line beginning

  stag_atr    - tag and attribute

  sval        - value of attribute

  line_end        - line ending

  Print tag with one attribute to the xml_file. Format is:

  <stag_atr="sval" xsi:nil="true"/>

  sval MUST be a NULL terminated string.

  sval string will be qouted before output.

  print_xml_row()

  xml_file    - output file

  row_name    - xml tag name

  tableRes    - query result

  row         - result row

  Print tag with many attribute to the xml_file. Format is:

  \t\t<row_name Atr1="Val1" Atr2="Val2"... />

  All atributes and values will be quoted before output.

  print_blob_as_hex()

  output_file         - output file

  str                 - string to print

  len                 - its length

  Print hex value for blob data.

  /* sakaik got the idea to to provide blob's in hex notation. */

  const char *ptr= str, *end= ptr + len;

  for (; ptr < end ; ptr++)

    fprintf(output_file, "%02X", *((unsigned char *)ptr));

  check_io(output_file);

  table       - table name

  db          - db name

  table_type  - table type, e.g. "MyISAM" or "InnoDB", but also "VIEW"

  ignore_flag - what we must particularly ignore - see IGNORE_ defines above

  num_fields  - number of fields in the table

  true if success, false if error

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

        /*

          Even if the "table" is a view, we do a DROP TABLE here.

        */

                      NULL);

  SYNOPSIS

  table - table name

  db    - db name

  RETURNS

  void

    _completely_ ignored and no data dumped

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

              opt_quoted_table);

                    NULL);

                  _("%s: Error reading rows for table: %s (%d:%s) ! Aborting.\n"),

              _("Not enough fields from table %s! Aborting.\n"),

              result_table);

          63 is my_charset_bin. If charsetnr is not 63,

          we have not a BLOB but a TEXT column.

          we'll dump in hex only BLOB columns.

                                                       my_isalpha(charset_info, ptr[1])))

                              drizzle_column_name(column), NULL);

      fputs("\t</table_data>\n", md_result_file);

  Table Specific database initalization.

  SYNOPSIS

  RETURN VALUES

      ret != DRIZZLE_RETURN_OK)

  pointer to the table name

  0 if error

      TODO-> Return all matching rows

    die(EX_EOM, _("alloc_root failure."));

                                            "FLUSH TABLES WITH READ LOCK", false) );

                                                "SET SESSION TRANSACTION ISOLATION "

                                                "LEVEL REPEATABLE READ", false) ||

                                                "START TRANSACTION "

                                                "WITH CONSISTENT SNAPSHOT", false));

                         char **err_pos, uint32_t *err_len)

  check_if_ignore_table()

  table_name                  Table name to check

  table_type                  Type of table

  drizzle                       Drizzle connection

  verbose                     Write warning messages

  char (bit value)            See IGNORE_ values at top

    Note-> we do not want to skip dumping this table if if is not one of

  */

  char *primary_key_fields(const char *table_name)

  RETURNS     pointer to allocated buffer (must be freed by caller)

  table_name  quoted table name

  Use SHOW KEYS FROM table_name, allocate a buffer to hold the

  field names, and then build that string and return the pointer

  to that buffer.

  Returns NULL if there is no PRIMARY or UNIQUE key on the table,

  or if there is some failure.  It is better to continue to dump

  the table unsorted, rather than exit without dumping the data.

                        " records are NOT sorted (%s)\n"),

                        " records are NOT sorted (%s)\n"),

                      " records are NOT sorted (%s)\n"),

 */

    size_t result_length_alloc = result_length + 10;

    result= (char *)malloc(result_length_alloc);

    result_length_alloc -= strlen(quoted_field);

      end+= snprintf(end, result_length_alloc, ",%s",quoted_field);

      result_length_alloc -= strlen(quoted_field);

    goto err;