<row>

<entry role="catalog_table_entry"><para role="column_definition">

<structfield>min_safe_lsn</structfield> <type>pg_lsn</type>

<structfield>safe_wal_size</structfield> <type>int8</type>

</para>

<para>

The minimum LSN currently available for walsenders.

The number of bytes that can be written to WAL such that this slot

is not in danger of getting in state "lost". It is NULL for lost

slots, as well as if <varname>max_slot_wal_keep_size</varname>

is <literal>-1</literal>.

</para></entry>

</row>

</tbody>

#defineConvertToXSegs(x,segsize)\

((x) / ((segsize) / (1024 * 1024)))

#defineConvertToXSegs(x,segsize)XLogMBVarToSegs((x), (segsize))

staticintUsableBytesInSegment;

XLogSegNotargetSeg;/* segid of targetLSN */

XLogSegNooldestSeg;/* actual oldest segid */

XLogSegNooldestSegMaxWalSize;/* oldest segid kept by max_wal_size */

XLogSegNooldestSlotSeg=InvalidXLogRecPtr;/* oldest segid kept by

XLogSegNooldestSlotSeg;/* oldest segid kept by slot */

uint64keepSegs;

L.restart_lsn,

L.confirmed_flush_lsn,

L.wal_status,

L.min_safe_lsn

L.safe_wal_size

FROM pg_get_replication_slots()AS L

LEFT JOIN pg_database DON (L.datoid=D.oid);

Tuplestorestate*tupstore;

MemoryContextper_query_ctx;

MemoryContextoldcontext;

XLogRecPtrcurrlsn;

intslotno;

MemoryContextSwitchTo(oldcontext);

currlsn=GetXLogWriteRecPtr();

LWLockAcquire(ReplicationSlotControlLock,LW_SHARED);

for (slotno=0;slotno<max_replication_slots;slotno++)

{

Datumvalues[PG_GET_REPLICATION_SLOTS_COLS];

boolnulls[PG_GET_REPLICATION_SLOTS_COLS];

WALAvailabilitywalstate;

XLogSegNolast_removed_seg;

inti;

if (!slot->in_use)

if (!XLogRecPtrIsInvalid(slot_contents.data.restart_lsn))

{

intpid;

SpinLockAcquire(&slot->mutex);

pid=slot->active_pid;

slot_contents.data.restart_lsn=slot->data.restart_lsn;

SpinLockRelease(&slot->mutex);

if (pid!=0)

{

values[i++]=CStringGetTextDatum("unreserved");

walstate=WALAVAIL_UNRESERVED;

break;

}

}

values[i++]=CStringGetTextDatum("lost");

break;

}

if (max_slot_wal_keep_size_mb >=0&&

(walstate==WALAVAIL_RESERVED||walstate==WALAVAIL_EXTENDED)&&

((last_removed_seg=XLogGetLastRemovedSegno())!=0))

if (walstate==WALAVAIL_REMOVED||max_slot_wal_keep_size_mb<0)

nulls[i++]= true;

{

XLogRecPtrmin_safe_lsn;

XLogSegNotargetSeg;

XLogSegNokeepSegs;

XLogSegNofailSeg;

XLogRecPtrfailLSN;

XLogSegNoOffsetToRecPtr(last_removed_seg+1,0,

wal_segment_size,min_safe_lsn);

values[i++]=Int64GetDatum(min_safe_lsn);

XLByteToSeg(slot_contents.data.restart_lsn,targetSeg,wal_segment_size);

keepSegs=XLogMBVarToSegs(max_slot_wal_keep_size_mb,wal_segment_size);

keepSegs=Max(keepSegs,wal_keep_segments);

failSeg=targetSeg+keepSegs+1;

XLogSegNoOffsetToRecPtr(failSeg,0,wal_segment_size,failLSN);

values[i++]=Int64GetDatum(failLSN-currlsn);

}

nulls[i++]= true;

Assert(i==PG_GET_REPLICATION_SLOTS_COLS);

#defineXLByteToPrevSeg(xlrp,logSegNo,wal_segsz_bytes) \

logSegNo = ((xlrp) - 1) / (wal_segsz_bytes)

#defineXLogMBVarToSegs(mbvar,wal_segsz_bytes) \

((mbvar) / ((wal_segsz_bytes) / (1024 * 1024)))

proname => 'pg_get_replication_slots', prorows => '10', proisstrict => 'f',

proretset => 't', provolatile => 's', prorettype => 'record',

proargtypes => '',

proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn,text,pg_lsn}',

proallargtypes => '{name,name,text,oid,bool,bool,int4,xid,xid,pg_lsn,pg_lsn,text,int8}',

proargmodes => '{o,o,o,o,o,o,o,o,o,o,o,o,o}',

proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn,wal_status,min_safe_lsn}',

proargnames => '{slot_name,plugin,slot_type,datoid,temporary,active,active_pid,xmin,catalog_xmin,restart_lsn,confirmed_flush_lsn,wal_status,safe_wal_size}',

prosrc => 'pg_get_replication_slots' },

{ oid => '3786', descr => 'set up a logical replication slot',

proname => 'pg_create_logical_replication_slot', provolatile => 'v',

my$result =$node_master->safe_psql('postgres',

);

is($result,"t|t|t",'check the state of non-reserved slot is "unknown"');

$node_standby->stop;

$result =$node_master->safe_psql('postgres',

);

is($result,"reserved|t",'check the catching-up state');

$result =$node_master->safe_psql('postgres',

);

is($result,"reserved|t",

'check that it is safe if WAL fits in max_wal_size');

$result =$node_master->safe_psql('postgres',

);

is($result,"reserved|t",'check that slot is working');

));

$node_master->reload;

$result =$node_master->safe_psql('postgres',

"SELECT wal_status FROM pg_replication_slots WHERE slot_name = 'rep1'");

$result =$node_master->safe_psql('postgres',

"SELECT wal_status FROM pg_replication_slots WHERE slot_name = 'rep1'");

is($result,"reserved",

'check thatmin_safe_lsn gets close to the current LSN');

'check thatsafe_wal_size gets close to the current LSN');

$node_standby->start;

advance_wal($node_master, 1);

$result =$node_master->safe_psql('postgres',

);

is($result,"unreserved|t",

'check that the slot state changes to "unreserved"');

$result =$node_master->safe_psql('postgres',

);

is($result,"rep1|f|t|lost|",

'check that the slot became inactive and the state "lost" persists');

l.restart_lsn,

l.confirmed_flush_lsn,

l.wal_status,

l.min_safe_lsn

FROM (pg_get_replication_slots() l(slot_name, plugin, slot_type, datoid, temporary, active, active_pid, xmin, catalog_xmin, restart_lsn, confirmed_flush_lsn, wal_status,min_safe_lsn)

l.safe_wal_size

FROM (pg_get_replication_slots() l(slot_name, plugin, slot_type, datoid, temporary, active, active_pid, xmin, catalog_xmin, restart_lsn, confirmed_flush_lsn, wal_status,safe_wal_size)

LEFT JOIN pg_database d ON ((l.datoid = d.oid)));

pg_roles| SELECT pg_authid.rolname,

pg_authid.rolsuper,