LCOV - code coverage report
Current view: top level - src/backend/backup - basebackup_sink.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 29 29 100.0 %
Date: 2024-02-28 06:10:54 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * basebackup_sink.c
       4             :  *    Default implementations for bbsink (basebackup sink) callbacks.
       5             :  *
       6             :  * Portions Copyright (c) 2010-2024, PostgreSQL Global Development Group
       7             :  *
       8             :  * src/backend/backup/basebackup_sink.c
       9             :  *
      10             :  *-------------------------------------------------------------------------
      11             :  */
      12             : 
      13             : #include "postgres.h"
      14             : 
      15             : #include "backup/basebackup_sink.h"
      16             : 
      17             : /*
      18             :  * Forward begin_backup callback.
      19             :  *
      20             :  * Only use this implementation if you want the bbsink you're implementing to
      21             :  * share a buffer with the successor bbsink.
      22             :  */
      23             : void
      24         276 : bbsink_forward_begin_backup(bbsink *sink)
      25             : {
      26             :     Assert(sink->bbs_next != NULL);
      27             :     Assert(sink->bbs_state != NULL);
      28         276 :     bbsink_begin_backup(sink->bbs_next, sink->bbs_state,
      29         276 :                         sink->bbs_buffer_length);
      30         276 :     sink->bbs_buffer = sink->bbs_next->bbs_buffer;
      31         276 : }
      32             : 
      33             : /*
      34             :  * Forward begin_archive callback.
      35             :  */
      36             : void
      37         336 : bbsink_forward_begin_archive(bbsink *sink, const char *archive_name)
      38             : {
      39             :     Assert(sink->bbs_next != NULL);
      40         336 :     bbsink_begin_archive(sink->bbs_next, archive_name);
      41         336 : }
      42             : 
      43             : /*
      44             :  * Forward archive_contents callback.
      45             :  *
      46             :  * Code that wants to use this should initialize its own bbs_buffer and
      47             :  * bbs_buffer_length fields to the values from the successor sink. In cases
      48             :  * where the buffer isn't shared, the data needs to be copied before forwarding
      49             :  * the callback. We don't do try to do that here, because there's really no
      50             :  * reason to have separately allocated buffers containing the same identical
      51             :  * data.
      52             :  */
      53             : void
      54      598578 : bbsink_forward_archive_contents(bbsink *sink, size_t len)
      55             : {
      56             :     Assert(sink->bbs_next != NULL);
      57             :     Assert(sink->bbs_buffer == sink->bbs_next->bbs_buffer);
      58             :     Assert(sink->bbs_buffer_length == sink->bbs_next->bbs_buffer_length);
      59      598578 :     bbsink_archive_contents(sink->bbs_next, len);
      60      598578 : }
      61             : 
      62             : /*
      63             :  * Forward end_archive callback.
      64             :  */
      65             : void
      66         328 : bbsink_forward_end_archive(bbsink *sink)
      67             : {
      68             :     Assert(sink->bbs_next != NULL);
      69         328 :     bbsink_end_archive(sink->bbs_next);
      70         328 : }
      71             : 
      72             : /*
      73             :  * Forward begin_manifest callback.
      74             :  */
      75             : void
      76         266 : bbsink_forward_begin_manifest(bbsink *sink)
      77             : {
      78             :     Assert(sink->bbs_next != NULL);
      79         266 :     bbsink_begin_manifest(sink->bbs_next);
      80         266 : }
      81             : 
      82             : /*
      83             :  * Forward manifest_contents callback.
      84             :  *
      85             :  * As with the archive_contents callback, it's expected that the buffer is
      86             :  * shared.
      87             :  */
      88             : void
      89        1330 : bbsink_forward_manifest_contents(bbsink *sink, size_t len)
      90             : {
      91             :     Assert(sink->bbs_next != NULL);
      92             :     Assert(sink->bbs_buffer == sink->bbs_next->bbs_buffer);
      93             :     Assert(sink->bbs_buffer_length == sink->bbs_next->bbs_buffer_length);
      94        1330 :     bbsink_manifest_contents(sink->bbs_next, len);
      95        1330 : }
      96             : 
      97             : /*
      98             :  * Forward end_manifest callback.
      99             :  */
     100             : void
     101         266 : bbsink_forward_end_manifest(bbsink *sink)
     102             : {
     103             :     Assert(sink->bbs_next != NULL);
     104         266 :     bbsink_end_manifest(sink->bbs_next);
     105         266 : }
     106             : 
     107             : /*
     108             :  * Forward end_backup callback.
     109             :  */
     110             : void
     111         268 : bbsink_forward_end_backup(bbsink *sink, XLogRecPtr endptr, TimeLineID endtli)
     112             : {
     113             :     Assert(sink->bbs_next != NULL);
     114         268 :     bbsink_end_backup(sink->bbs_next, endptr, endtli);
     115         268 : }
     116             : 
     117             : /*
     118             :  * Forward cleanup callback.
     119             :  */
     120             : void
     121         268 : bbsink_forward_cleanup(bbsink *sink)
     122             : {
     123             :     Assert(sink->bbs_next != NULL);
     124         268 :     bbsink_cleanup(sink->bbs_next);
     125         268 : }

Generated by: LCOV version 1.14