manpagez: man pages & more
man ndb_restore(1)
Home | html | info | man
ndb_restore(1)               MySQL Database System              ndb_restore(1)




NAME

       ndb_restore - restore a MySQL Cluster backup


SYNOPSIS

       ndb_restore options


DESCRIPTION

       The cluster restoration program is implemented as a separate
       command-line utility ndb_restore, which can normally be found in the
       MySQL bin directory. This program reads the files created as a result
       of the backup and inserts the stored information into the database.

       ndb_restore must be executed once for each of the backup files that
       were created by the START BACKUP command used to create the backup (see
       Section 16.5.3.2, "Using The MySQL Cluster Management Client to Create
       a Backup"). This is equal to the number of data nodes in the cluster at
       the time that the backup was created.

           Note
           Before using ndb_restore, it is recommended that the cluster be
           running in single user mode, unless you are restoring multiple data
           nodes in parallel. See Section 16.5.7, "MySQL Cluster Single User
           Mode", for more information.

       The following table includes options that are specific to the MySQL
       Cluster native backup restoration program ndb_restore. Additional
       descriptions follow the table. For options common to all MySQL Cluster
       programs, see Section 16.4.2, "Options Common to MySQL Cluster
       Programs".

       Typical options for this utility are shown here:

           ndb_restore [-c connectstring] -n node_id [-m] -b backup_id \
               -r --backup_path=/path/to/backup/files

       The -c option is used to specify a connectstring which tells
       ndb_restore where to locate the cluster management server. (See
       Section 16.3.2.3, "The MySQL Cluster Connectstring", for information on
       connectstrings.) If this option is not used, then ndb_restore attempts
       to connect to a management server on localhost:1186. This utility acts
       as a cluster API node, and so requires a free connection "slot" to
       connect to the cluster management server. This means that there must be
       at least one [api] or [mysqld] section that can be used by it in the
       cluster config.ini file. It is a good idea to keep at least one empty
       [api] or [mysqld] section in config.ini that is not being used for a
       MySQL server or other application for this reason (see
       Section 16.3.2.7, "Defining SQL and Other API Nodes in a MySQL
       Cluster").

       You can verify that ndb_restore is connected to the cluster by using
       the SHOW command in the ndb_mgm management client. You can also
       accomplish this from a system shell, as shown here:

           shell> ndb_mgm -e "SHOW"

       -n is used to specify the node ID of the data node on which the backups
       were taken.

       The first time you run the ndb_restore restoration program, you also
       need to restore the metadata. In other words, you must re-create the
       database tables--this can be done by running it with the -m option.
       Note that the cluster should have an empty database when starting to
       restore a backup. (In other words, you should start ndbd with --initial
       prior to performing the restore. You should also remove manually any
       Disk Data files present in the data node's DataDir.)

       It is possible to restore data without restoring table metadata. The
       default behavior when doing this is for ndb_restore to fail with an
       error if table data do not match the table schema; this can be
       overridden using the --skip-table-check or -s option.

       Some of the restrictions on mismatches in column definitions when
       restoring data using ndb_restore are relaxed; when one of these types
       of mismatches is encountered, ndb_restore does not stop with an error
       as it did previously, but rather accepts the data and inserts it into
       the target table while issuing a warning to the user that this is being
       done. This behavior occurs whether or not either of the options
       --skip-table-check or --promote-attributes is in use. These differences
       in column definitions are of the following types:

       o   Different COLUMN_FORMAT settings (FIXED, DYNAMIC, DEFAULT)

       o   Different STORAGE settings (MEMORY, DISK)

       o   Different default values

       o   Different distribution key settings

       ndb_restore supports limited attribute promotion in much the same way
       that it is supported by MySQL replication; that is, data backed up from
       a column of a given type can generally be restored to a column using a
       "larger, similar" type. For example, data from a CHAR(20) column can be
       restored to a column declared as VARCHAR(20), VARCHAR(30), or CHAR(30);
       data from a MEDIUMINT column can be restored to a column of type INT or
       BIGINT. See Section 15.4.1.6.2, "Replication of Columns Having
       Different Data Types", for a table of type conversions currently
       supported by attribute promotion.

       Attribute promotion by ndb_restore must be enabled explicitly, as
       follows:

        1. Prepare the table to which the backup is to be restored.
           ndb_restore cannot be used to re-create the table with a different
           definition from the original; this means that you must either
           create the table manually, or alter the columns which you wish to
           promote using ALTER TABLE after restoring the table metadata but
           before restoring the data.

        2. Invoke ndb_restore with the --promote-attributes option (short form
           -A) when restoring the table data. Attribute promotion does not
           occur if this option is not used; instead, the restore operation
           fails with an error.

       --lossy-conversions, -L

       +-------------+---------------------+
       |Command-Line | --lossy-conversions |
       |Format       |                     |
       +-------------+---------------------+
       |             | -L                  |
       +-------------+---------------------+
       |             | Permitted Values    |
       |             +----------+----------+
       |             | Type     | boolean  |
       |             +----------+----------+
       |             | Default  | FALSE    |
       +-------------+----------+----------+

       This option is intended to complement the --promote-attributes option.
       Using --lossy-conversions allows lossy conversions of column values
       (type demotions or changes in sign) when restoring data from backup.
       With some exceptions, the rules governing demotion are the same as for
       MySQL replication; see Section 15.4.1.6.2, "Replication of Columns
       Having Different Data Types", for information about specific type
       conversions currently supported by attribute demotion.

       ndb_restore reports any truncation of data that it performs during
       lossy conversions once per attribute and column.

       The --preserve-trailing-spaces option (short form -R) causes trailing
       spaces to be preserved when promoting a fixed-width character data type
       to its variable-width equivalent--that is, when promoting a CHAR column
       value to VARCHAR or a BINARY column value to VARBINARY. Otherwise, any
       trailing spaces are dropped from such column values when they are
       inserted into the new columns.

           Note
           Although you can promote CHAR columns to VARCHAR and BINARY columns
           to VARBINARY, you cannot promote VARCHAR columns to CHAR or
           VARBINARY columns to BINARY.

       The -b option is used to specify the ID or sequence number of the
       backup, and is the same number shown by the management client in the
       Backup backup_id completed message displayed upon completion of a
       backup. (See Section 16.5.3.2, "Using The MySQL Cluster Management
       Client to Create a Backup".)

           Important
           When restoring cluster backups, you must be sure to restore all
           data nodes from backups having the same backup ID. Using files from
           different backups will at best result in restoring the cluster to
           an inconsistent state, and may fail altogether.

       --restore_epoch (short form: -e) adds (or restores) epoch information
       to the cluster replication status table. This is useful for starting
       replication on a MySQL Cluster replication slave. When this option is
       used, the row in the mysql.ndb_apply_status having 0 in the id column
       is updated if it already exists; such a row is inserted if it does not
       already exist. (See Section 16.6.9, "MySQL Cluster Backups With MySQL
       Cluster Replication".)

       --restore_data causes ndb_restore to output NDB table data and logs.

       This option causes ndb_restore to print NDB table metadata.

       The path to the backup directory is required; this is supplied to
       ndb_restore using the --backup_path option, and must include the
       subdirectory corresponding to the ID backup of the backup to be
       restored. For example, if the data node's DataDir is
       /var/lib/mysql-cluster, then the backup directory is
       /var/lib/mysql-cluster/BACKUP, and the backup files for the backup with
       the ID 3 can be found in /var/lib/mysql-cluster/BACKUP/BACKUP-3. The
       path may be absolute or relative to the directory in which the
       ndb_restore executable is located, and may be optionally prefixed with
       backup_path=.

       It is possible to restore a backup to a database with a different
       configuration than it was created from. For example, suppose that a
       backup with backup ID 12, created in a cluster with two database nodes
       having the node IDs 2 and 3, is to be restored to a cluster with four
       nodes. Then ndb_restore must be run twice--once for each database node
       in the cluster where the backup was taken. However, ndb_restore cannot
       always restore backups made from a cluster running one version of MySQL
       to a cluster running a different MySQL version. See Section 16.2.7,
       "Upgrading and Downgrading MySQL Cluster NDB 7.2", for more
       information.

           Important
           It is not possible to restore a backup made from a newer version of
           MySQL Cluster using an older version of ndb_restore. You can
           restore a backup made from a newer version of MySQL to an older
           cluster, but you must use a copy of ndb_restore from the newer
           MySQL Cluster version to do so.

           For example, to restore a cluster backup taken from a cluster
           running MySQL Cluster NDB 7.1.8 to a cluster running MySQL Cluster
           NDB 7.0.16, you must use the ndb_restore that comes with the MySQL
           Cluster NDB 7.1.8 distribution.

       For more rapid restoration, the data may be restored in parallel,
       provided that there is a sufficient number of cluster connections
       available. That is, when restoring to multiple nodes in parallel, you
       must have an [api] or [mysqld] section in the cluster config.ini file
       available for each concurrent ndb_restore process. However, the data
       files must always be applied before the logs.

       When using ndb_restore to restore a backup, VARCHAR columns created
       using the old fixed format are resized and recreated using the
       variable-width format now employed. This behavior can be overridden
       using the --no-upgrade option (short form: -u) when running
       ndb_restore.

       --print_data

       The --print_data option causes ndb_restore to direct its output to
       stdout.

       TEXT and BLOB column values are always truncated to the first 256 bytes
       in the output; this cannot currently be overridden when using
       --print_data.

       Several additional options are available for use with the --print_data
       option in generating data dumps, either to stdout, or to a file. These
       are similar to some of the options used with mysqldump, and are shown
       in the following list:

       o   --tab, -T

           +-------------+------------+
           |Command-Line | --tab=path |
           |Format       |            |
           +-------------+------------+
           |             | -T         |
           +-------------+------------+
           This option causes --print_data to create dump files, one per
           table, each named tbl_name.txt. It requires as its argument the
           path to the directory where the files should be saved; use .  for
           the current directory.

       o   --fields-enclosed-by=string

           +-------------+---------------------------+
           |Command-Line | --fields-enclosed-by=char |
           |Format       |                           |
           +-------------+---------------------------+
           |             | Permitted Values          |
           |             +------------+--------------+
           |             | Type       | string       |
           |             +------------+--------------+
           |             | Default    |              |
           +-------------+------------+--------------+
           Each column values are enclosed by the string passed to this option
           (regardless of data type; see next item).

       o   --fields-optionally-enclosed-by=string

           +-------------+---------------------------------+
           |Command-Line | --fields-optionally-enclosed-by |
           |Format       |                                 |
           +-------------+---------------------------------+
           |             | Permitted Values                |
           |             +--------------+------------------+
           |             | Type         | string           |
           |             +--------------+------------------+
           |             | Default      |                  |
           +-------------+--------------+------------------+
           The string passed to this option is used to enclose column values
           containing character data (such as CHAR, VARCHAR, BINARY, TEXT, or
           ENUM).

       o   --fields-terminated-by=string

           +-------------+-----------------------------+
           |Command-Line | --fields-terminated-by=char |
           |Format       |                             |
           +-------------+-----------------------------+
           |             | Permitted Values            |
           |             +------------+----------------+
           |             | Type       | string         |
           |             +------------+----------------+
           |             | Default    | \t (tab)       |
           +-------------+------------+----------------+
           The string passed to this option is used to separate column values.
           The default value is a tab character (\t).

       o   --hex

           +-------------+-----------+
           |Command-Line | --hex     |
           |Format       |           |
           +-------------+-----------+
           If this option is used, all binary values are output in hexadecimal
           format.

       o   --fields-terminated-by=string

           +-------------+-----------------------------+
           |Command-Line | --fields-terminated-by=char |
           |Format       |                             |
           +-------------+-----------------------------+
           |             | Permitted Values            |
           |             +------------+----------------+
           |             | Type       | string         |
           |             +------------+----------------+
           |             | Default    | \t (tab)       |
           +-------------+------------+----------------+
           This option specifies the string used to end each line of output.
           The default is a linefeed character (\n).

       o   --append

           +-------------+-----------+
           |Command-Line | --append  |
           |Format       |           |
           +-------------+-----------+
           When used with the --tab and --print_data options, this causes the
           data to be appended to any existing files having the same names.

           Note
           If a table has no explicit primary key, then the output generated
           when using the --print_data option includes the table's hidden
           primary key.

       --print_metadata

       This option causes ndb_restore to print all metadata to stdout.

       --print_log

       The --print_log option causes ndb_restore to output its log to stdout.

       --print

       Causes ndb_restore to print all data, metadata, and logs to stdout.
       Equivalent to using the --print_data, --print_metadata, and --print_log
       options together.

       --dont_ignore_systab_0

       Normally, when restoring table data and metadata, ndb_restore ignores
       the copy of the NDB system table that is present in the backup.
       --dont_ignore_systab_0 causes the system table to be restored.  This
       option is intended for experimental and development use only, and is
       not recommended in a production environment.

       --ndb-nodegroup-map, -z

       This option can be used to restore a backup taken from one node group
       to a different node group. Its argument is a list of the form
       source_node_group, target_node_group.

       --no-binlog

       This option prevents any connected SQL nodes from writing data restored
       by ndb_restore to their binary logs.

       --no-restore-disk-objects, -d

       This option stops ndb_restore from restoring any MySQL Cluster Disk
       Data objects, such as tablespaces and log file groups; see
       Section 16.5.11, "MySQL Cluster Disk Data Tables", for more information
       about these.

       --parallelism=#, -p

       Determines the maximum number of parallel transactions that ndb_restore
       tries to use. By default, this is 128; the minimum is 1, and the
       maximum is 1024.

       --progress-frequency=N

       Print a status report each N seconds while the backup is in progress. 0
       (the default) causes no status reports to be printed. The maximum is
       65535.

       --verbose=#

       Sets the level for the verbosity of the output. The minimum is 0; the
       maximum is 255. The default value is 1.

       It is possible to restore only selected databases, or selected tables
       from a single database, using the syntax shown here:

           ndb_restore other_options db_name,[db_name[,...] | tbl_name[,tbl_name][,...]]

       In other words, you can specify either of the following to be restored:

       o   All tables from one or more databases

       o   One or more tables from a single database

       --include-databases=db_name[,db_name][,...]

       +-------------+-----------------------------+
       |Command-Line | --include-databases=db-list |
       |Format       |                             |
       +-------------+-----------------------------+
       |             | Permitted Values            |
       |             +-------------+---------------+
       |             | Type        | string        |
       |             +-------------+---------------+
       |             | Default     |               |
       +-------------+-------------+---------------+

       --include-tables=db_name.tbl_name[,db_name.tbl_name][,...]

       +-------------+-----------------------------+
       |Command-Line | --include-tables=table-list |
       |Format       |                             |
       +-------------+-----------------------------+
       |             | Permitted Values            |
       |             +-------------+---------------+
       |             | Type        | string        |
       |             +-------------+---------------+
       |             | Default     |               |
       +-------------+-------------+---------------+

       Use the --include-databases option or the --include-tables option for
       restoring only specific databases or tables, respectively.
       --include-databases takes a comma-delimited list of databases to be
       restored.  --include-tables takes a comma-delimited list of tables (in
       database.table format) to be restored.

       When --include-databases or --include-tables is used, only those
       databases or tables named by the option are restored; all other
       databases and tables are excluded by ndb_restore, and are not restored.

       The following table shows several invocations of ndb_restore using
       --include-* options (other options possibly required have been omitted
       for clarity), and the effects these have on restoring from a MySQL
       Cluster backup:

       +-------------------------------------------+-----------------------------+
       |Option Used                                | Result                      |
       +-------------------------------------------+-----------------------------+
       |--include-databases=db1                    | Only tables in database     |
       |                                           | db1 are restored; all       |
       |                                           | tables                      |
       |                                           |                   in all    |
       |                                           | other databases are         |
       |                                           | ignored                     |
       +-------------------------------------------+-----------------------------+
       |--include-databases=db1,db2                | Only tables in databases    |
       |(or                                        | db1 and                     |
       |                  --include-databases=db1  |                   db2 are   |
       |                  --include-databases=db2) | restored; all tables in     |
       |                                           | all                         |
       |                                           |                   other     |
       |                                           | databases are ignored       |
       +-------------------------------------------+-----------------------------+
       |--include-tables=db1.t1                    | Only table t1 in database   |
       |                                           | db1 is                      |
       |                                           |                   restored; |
       |                                           | no other tables in db1 or   |
       |                                           |                   in any    |
       |                                           | other database are          |
       |                                           | restored                    |
       +-------------------------------------------+-----------------------------+
       |--include-tables=db1.t2,db2.t1 (or         | Only the table t2 in        |
       |                  --include-tables=db1.t2  | database db1                |
       |                  --include-tables=db2.t1) |                   and the   |
       |                                           | table t1 in database        |
       |                                           |                   db2 are   |
       |                                           | restored; no other tables   |
       |                                           |                   in db1,   |
       |                                           | db2, or                     |
       |                                           |                   any other |
       |                                           | database are restored       |
       +-------------------------------------------+-----------------------------+

       You can also use these two options together. For example, the following
       causes all tables in databases db1 and db2, together with the tables t1
       and t2 in database db3, to be restored (and no other databases or
       tables):

           shell> ndb_restore [...] --include-databases=db1,db2 --include-tables=db3.t1,db3.t2

       (Again we have omitted other, possibly required, options in the example
       just shown.)

       --exclude-databases=db_name[,db_name][,...]

       +-------------+-----------------------------+
       |Command-Line | --exclude-databases=db-list |
       |Format       |                             |
       +-------------+-----------------------------+
       |             | Permitted Values            |
       |             +-------------+---------------+
       |             | Type        | string        |
       |             +-------------+---------------+
       |             | Default     |               |
       +-------------+-------------+---------------+

       --exclude-tables=db_name.tbl_name[,db_name.tbl_name][,...]

       +-------------+-----------------------------+
       |Command-Line | --exclude-tables=table-list |
       |Format       |                             |
       +-------------+-----------------------------+
       |             | Permitted Values            |
       |             +-------------+---------------+
       |             | Type        | string        |
       |             +-------------+---------------+
       |             | Default     |               |
       +-------------+-------------+---------------+

       It is possible to prevent one or more databases or tables from being
       restored using the ndb_restore options --exclude-databases and
       --exclude-tables.  --exclude-databases takes a comma-delimited list of
       one or more databases which should not be restored.  --exclude-tables
       takes a comma-delimited list of one or more tables (using
       database.table format) which should not be restored.

       When --exclude-databases or --exclude-tables is used, only those
       databases or tables named by the option are excluded; all other
       databases and tables are restored by ndb_restore.

       This table shows several invocations of ndb_restore usng --exclude-*
       options (other options possibly required have been omitted for
       clarity), and the effects these options have on restoring from a MySQL
       Cluster backup:

       +-------------------------------------------+-----------------------------+
       |Option Used                                | Result                      |
       +-------------------------------------------+-----------------------------+
       |--exclude-databases=db1                    | All tables in all           |
       |                                           | databases except db1 are    |
       |                                           | restored;                   |
       |                                           |                   no        |
       |                                           | tables in db1 are restored  |
       +-------------------------------------------+-----------------------------+
       |--exclude-databases=db1,db2                | All tables in all           |
       |(or                                        | databases except db1 and    |
       |                  --exclude-databases=db1  |                   db2 are   |
       |                  --exclude-databases=db2) | restored; no tables in      |
       |                                           |                   db1 or    |
       |                                           | db2 are                     |
       |                                           |                   restored  |
       +-------------------------------------------+-----------------------------+
       |--exclude-tables=db1.t1                    | All tables except t1 in     |
       |                                           | database                    |
       |                                           |                   db1 are   |
       |                                           | restored; all other tables  |
       |                                           |                   in db1    |
       |                                           | are restored; all tables    |
       |                                           | in                          |
       |                                           |                   all       |
       |                                           | other databases are         |
       |                                           | restored                    |
       +-------------------------------------------+-----------------------------+
       |--exclude-tables=db1.t2,db2.t1 (or         | All tables in database db1  |
       |                  --exclude-tables=db1.t2  | except for                  |
       |                  --exclude-tables=db2.t1) |                   t2 and    |
       |                                           | all tables in database      |
       |                                           |                   db2       |
       |                                           | except for table            |
       |                                           |                   t1 are    |
       |                                           | restored; no other tables   |
       |                                           | in                          |
       |                                           |                   db1 or    |
       |                                           | db2 are                     |
       |                                           |                   restored; |
       |                                           | all tables in all other     |
       |                                           | databases are               |
       |                                           |                   restored  |
       +-------------------------------------------+-----------------------------+

       You can use these two options together. For example, the following
       causes all tables in all databases except for databases db1 and db2,
       along with the tables t1 and t2 in database db3, not to be restored:

           shell> ndb_restore [...] --exclude-databases=db1,db2 --exclude-tables=db3.t1,db3.t2

       (Again, we have omitted other possibly necessary options in the
       interest of clarity and brevity from the example just shown.)

       You can use --include-* and --exclude-* options together, subject to
       the following rules:

       o   The actions of all --include-* and --exclude-* options are
           cumulative.

       o   All --include-* and --exclude-* options are evaluated in the order
           passed to ndb_restore, from right to left.

       o   In the event of conflicting options, the first (rightmost) option
           takes precedence. In other words, the first option (going from
           right to left) that matches against a given database or table
           "wins".

       For example, the following set of options causes ndb_restore to restore
       all tables from database db1 except db1.t1, while restoring no other
       tables from any other databases:

           --include-databases=db1 --exclude-tables=db1.t1

       However, reversing the order of the options just given simply causes
       all tables from database db1 to be restored (including db1.t1, but no
       tables from any other database), because the --include-databases
       option, being farthest to the right, is the first match against
       database db1 and thus takes precedence over any other option that
       matches db1 or any tables in db1:

           --exclude-tables=db1.t1 --include-databases=db1

       --exclude-missing-columns

       +-------------+---------------------------+
       |Command-Line | --exclude-missing-columns |
       |Format       |                           |
       +-------------+---------------------------+

       It is also possible to restore only selected table columns using the
       --exclude-missing-columns option. When this option is used, ndb_restore
       ignores any columns missing from tables being restored as compared to
       the versions of those tables found in the backup. This option applies
       to all tables being restored. If you wish to apply this option only to
       selected tables or databases, you can use it in combination with one or
       more of the options described in the previous paragraph to do so, then
       restore data to the remaining tables using a complementary set of these
       options.

       --disable-indexes

       +-------------+-------------------+
       |Command-Line | --disable-indexes |
       |Format       |                   |
       +-------------+-------------------+

       Disable restoration of indexes during restoration of the data from a
       native NDB backup. Afterwards, you can restore indexes for all tables
       at once with multi-threaded building of indexes using
       --rebuild-indexes, which should be faster than rebuilding indexes
       concurrently for very large tables.

       --rebuild-indexes

       +-------------+-------------------+
       |Command-Line | --rebuild-indexes |
       |Format       |                   |
       +-------------+-------------------+

       You can use this option with ndb_restore to cause multi-threaded
       rebuilding of the ordered indexes while restoring a native NDB backup.

       --skip-broken-objects

       +-------------+-----------------------+
       |Command-Line | --skip-broken-objects |
       |Format       |                       |
       +-------------+-----------------------+

       This option causes ndb_restore to ignore corrupt tables while reading a
       native NDB backup, and to continue restoring any remaining tables (that
       are not also corrupted). Currently, the --skip-broken-objects option
       works only in the case of missing blob parts tables.

       --skip-unknown-objects

       +-------------+------------------------+
       |Command-Line | --skip-unknown-objects |
       |Format       |                        |
       +-------------+------------------------+

       This option causes ndb_restore to ignore any schema objects it does not
       recognize while reading a native NDB backup. This can be used for
       restoring a backup made from a cluster running MySQL Cluster NDB 7.2 to
       a cluster running MySQL Cluster NDB 7.1.

       --rewrite-database=old_dbname,new_dbname

       +-------------+--------------------------------+
       |Command-Line | --rewrite-database=olddb,newdb |
       |Format       |                                |
       +-------------+--------------------------------+
       |             | Permitted Values               |
       |             +--------------+-----------------+
       |             | Type         | string          |
       |             +--------------+-----------------+
       |             | Default      | none            |
       +-------------+--------------+-----------------+

       This option makes it possible to restore to a database having a
       different name from that used in the backup. For example, if a backup
       is made of a database named products, you can restore the data it
       contains to a database named inventory, use this option as shown here
       (omitting any other options that might be required):

           shell> ndb_restore --rewrite-database=product,inventory

       The option can be employed multiple times in a single invocation of
       ndb_restore. Thus it is possible to restore simultaneously from a
       database named db1 to a database named db2 and from a database named
       db3 to one named db4 using --rewrite-database=db1,db2
       --rewrite-database=db3,db4. Other ndb_restore options may be used
       between multiple occurrences of --rewrite-database.

       In the event of conflicts between multiple --rewrite-database options,
       the last --rewrite-database option used, reading from left to right, is
       the one that takes effect. For example, if --rewrite-database=db1,db2
       --rewrite-database=db1,db3 is used, only --rewrite-database=db1,db3 is
       honored, and --rewrite-database=db1,db2 is ignored. It is also possible
       to restore from multiple databases to a single database, so that
       --rewrite-database=db1,db3 --rewrite-database=db2,db3 restores all
       tables and data from databases db1 and db2 into database db3.

           Important
           When restoring from multiple backup databases into a single target
           database using --rewrite-database, no check is made for collisions
           between table or other object names, and the order in which rows
           are restored is not guaranteed. This means that it is possible in
           such cases for rows to be overwritten and updates to be lost.

       Error reporting. .  ndb_restore reports both temporary and permanent
       errors. In the case of temporary errors, it may able to recover from
       them, and reports Restore successful, but encountered temporary error,
       please look at configuration in such cases.

           Important
           After using ndb_restore to initialize a MySQL Cluster for use in
           circular replication, binary logs on the SQL node acting as the
           replication slave are not automatically created, and you must cause
           them to be created manually. To cause the binary logs to be
           created, issue a SHOW TABLES statement on that SQL node before
           running START SLAVE. This is a known issue in MySQL Cluster.


COPYRIGHT

       Copyright (C) 1997, 2012, Oracle and/or its affiliates. All rights
       reserved.

       This documentation is free software; you can redistribute it and/or
       modify it only under the terms of the GNU General Public License as
       published by the Free Software Foundation; version 2 of the License.

       This documentation 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 the program; if not, write to the Free Software Foundation, Inc.,
       51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or see
       http://www.gnu.org/licenses/.



SEE ALSO

       For more information, please refer to the MySQL Reference Manual, which
       may already be installed locally and which is also available online at
       http://dev.mysql.com/doc/.


AUTHOR

       Oracle Corporation (http://dev.mysql.com/).



MySQL 5.5                         03/02/2012                    ndb_restore(1)

mysql 5.5.22 - Generated Fri Apr 6 12:32:36 CDT 2012
© manpagez.com 2000-2024
Individual documents may contain additional copyright information.