</listitem>

</varlistentry>

<varlistentry>

<term><option>-T <replaceable class="parameter">olddir</replaceable>=<replaceable class="parameter">newdir</replaceable></option></term>

<term><option>--tablespace-mapping=<replaceable class="parameter">olddir</replaceable>=<replaceable class="parameter">newdir</replaceable></option></term>

<listitem>

<para>

Relocate the tablespace in directory <replaceable>olddir</replaceable>

to <replaceable>newdir</replaceable> during the backup. To be

effective, <replaceable>olddir</replaceable> must exactly match the

path specification of the tablespace as it is currently defined. (But

it is not an error if there is no tablespace

in <replaceable>olddir</replaceable> contained in the backup.)

Both <replaceable>olddir</replaceable>

and <replaceable>newdir</replaceable> must be absolute paths. If a

path happens to contain a <literal>=</literal> sign, escape it with a

backslash. This option can be specified multiple times for multiple

tablespaces. See examples below.

</para>

<para>

If a tablespace is relocated in this way, the symbolic links inside

the main data directory are updated to point to the new location. So

the new data directory is ready to be used for a new server instance

with all tablespaces in the updated locations.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><option>--xlogdir=<replaceable class="parameter">xlogdir</replaceable></option></term>

<listitem>

</para>

<para>

The way <productname>PostgreSQL</productname> manages tablespaces, the path

for all additional tablespaces must be identical whenever a backup is

restored. The main data directory, however, is relocatable to any location.

Tablespaces will in plain format by default be backed up to the same path

they have on the server, unless the

option <replaceable>--tablespace-mapping</replaceable> is used. Without

this option, running a plain format base backup on the same host as the

server will not work if tablespaces are in use, because the backup would

have to be written to the same directory locations as the original

tablespaces.

</para>

<para>

(This command will fail if there are multiple tablespaces in the

database.)

</para>

<para>

To create a backup of a local database where the tablespace in

<filename>/opt/ts</filename> is relocated

to <filename>./backup/ts</filename>:

<screen>

<prompt>$</prompt> <userinput>pg_basebackup -D backup/data -T /opt/ts=$(pwd)/backup/ts</userinput>

</screen>

</para>

</refsect1>

<refsect1>

#defineatooid(x) ((Oid) strtoul((x), NULL, 10))

{

structTablespaceListCell*next;

charold_dir[MAXPGPATH];

charnew_dir[MAXPGPATH];

}TablespaceListCell;

{

TablespaceListCell*head;

TablespaceListCell*tail;

}TablespaceList;

staticchar*basedir=NULL;

staticTablespaceListtablespace_dirs= {NULL,NULL};

staticchar*xlog_dir="";

staticcharformat='p';/* p(lain)/t(ar) */

staticchar*label="pg_basebackup base backup";

staticboolreached_end_position(XLogRecPtrsegendpos,uint32timeline,

boolsegment_finished);

staticconstchar*get_tablespace_mapping(constchar*dir);

staticvoidupdate_tablespace_symlink(Oidoid,constchar*old_dir);

staticvoidtablespace_list_append(constchar*arg);

staticvoiddisconnect_and_exit(intcode)

{

}

tablespace_list_append(constchar*arg)

{

TablespaceListCell*cell= (TablespaceListCell*)pg_malloc0(sizeof(TablespaceListCell));

char*dst;

char*dst_ptr;

constchar*arg_ptr;

dst_ptr=dst=cell->old_dir;

for (arg_ptr=arg;*arg_ptr;arg_ptr++)

{

if (dst_ptr-dst >=MAXPGPATH)

{

fprintf(stderr,_("%s: directory name too long\n"),progname);

exit(1);

}

if (*arg_ptr=='\\'&&*(arg_ptr+1)=='=')

;/* skip backslash escaping = */

elseif (*arg_ptr=='='&& (arg_ptr==arg||*(arg_ptr-1)!='\\'))

{

if (*cell->new_dir)

{

fprintf(stderr,_("%s: multiple \"=\" signs in tablespace mapping\n"),progname);

exit(1);

}

dst=dst_ptr=cell->new_dir;

}

*dst_ptr++=*arg_ptr;

}

if (!*cell->old_dir|| !*cell->new_dir)

{

fprintf(stderr,

_("%s: invalid tablespace mapping format \"%s\", must be \"OLDDIR=NEWDIR\"\n"),

progname,arg);

exit(1);

}

if (!is_absolute_path(cell->old_dir))

{

fprintf(stderr,_("%s: old directory not absolute in tablespace mapping: %s\n"),

progname,cell->old_dir);

exit(1);

}

if (!is_absolute_path(cell->new_dir))

{

fprintf(stderr,_("%s: new directory not absolute in tablespace mapping: %s\n"),

progname,cell->new_dir);

exit(1);

}

if (tablespace_dirs.tail)

tablespace_dirs.tail->next=cell;

tablespace_dirs.head=cell;

tablespace_dirs.tail=cell;

}

get_gz_error(gzFilegzf)

printf(_(" -F, --format=p|t output format (plain (default), tar)\n"));

printf(_(" -R, --write-recovery-conf\n"

" write recovery.conf after backup\n"));

printf(_(" -T, --tablespace-mapping=OLDDIR=NEWDIR\n"

" relocate tablespace in OLDDIR to NEWDIR\n"));

printf(_(" -x, --xlog include required WAL files in backup (fetch mode)\n"));

printf(_(" -X, --xlog-method=fetch|stream\n"

" include required WAL files with specified method\n"));

PQfreemem(copybuf);

}

get_tablespace_mapping(constchar*dir)

{

TablespaceListCell*cell;

for (cell=tablespace_dirs.head;cell;cell=cell->next)

if (strcmp(dir,cell->old_dir)==0)

returncell->new_dir;

returndir;

}

update_tablespace_symlink(Oidoid,constchar*old_dir)

{

constchar*new_dir=get_tablespace_mapping(old_dir);

if (strcmp(old_dir,new_dir)!=0)

{

char*linkloc=psprintf("%s/pg_tblspc/%d",basedir,oid);

if (unlink(linkloc)!=0&&errno!=ENOENT)

{

fprintf(stderr,_("%s: could not remove symbolic link \"%s\": %s"),

progname,linkloc,strerror(errno));

disconnect_and_exit(1);

}

if (symlink(new_dir,linkloc)!=0)

{

fprintf(stderr,_("%s: could not create symbolic link \"%s\": %s"),

progname,linkloc,strerror(errno));

disconnect_and_exit(1);

}

}

}

ReceiveAndUnpackTarFile(PGconn*conn,PGresult*res,intrownum)

if (basetablespace)

strlcpy(current_path,basedir,sizeof(current_path));

strlcpy(current_path,PQgetvalue(res,rownum,1),sizeof(current_path));

strlcpy(current_path,get_tablespace_mapping(PQgetvalue(res,rownum,1)),sizeof(current_path));

if (format=='p'&& !PQgetisnull(res,i,1))

verify_dir_is_empty_or_create(PQgetvalue(res,i,1));

{

char*path= (char*)get_tablespace_mapping(PQgetvalue(res,i,1));

verify_dir_is_empty_or_create(path);

}

}

progress_report(PQntuples(res),NULL, true);

fprintf(stderr,"\n");/* Need to move to next line */

}

if (format=='p'&&tablespace_dirs.head!=NULL)

{

for (i=0;i<PQntuples(res);i++)

{

Oidtblspc_oid=atooid(PQgetvalue(res,i,0));

if (tblspc_oid)

update_tablespace_symlink(tblspc_oid,PQgetvalue(res,i,1));

}

}

PQclear(res);

{"format",required_argument,NULL,'F'},

{"checkpoint",required_argument,NULL,'c'},

{"write-recovery-conf",no_argument,NULL,'R'},

{"tablespace-mapping",required_argument,NULL,'T'},

{"xlog",no_argument,NULL,'x'},

{"xlog-method",required_argument,NULL,'X'},

{"gzip",no_argument,NULL,'z'},

}

}

while ((c=getopt_long(argc,argv,"D:F:RxX:l:zZ:d:c:h:p:U:s:wWvP",

while ((c=getopt_long(argc,argv,"D:F:RT:xX:l:zZ:d:c:h:p:U:s:wWvP",

long_options,&option_index))!=-1)

{

switch (c)

case'R':

writerecoveryconf= true;

break;

case'T':

tablespace_list_append(optarg);

break;

case'x':

if (includewal)

{