PostgreSQL Source Code  git master
logicalproto.h File Reference
#include "access/xact.h"
#include "executor/tuptable.h"
#include "replication/reorderbuffer.h"
#include "utils/rel.h"
Include dependency graph for logicalproto.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  LogicalRepTupleData
 
struct  LogicalRepRelation
 
struct  LogicalRepTyp
 
struct  LogicalRepBeginData
 
struct  LogicalRepCommitData
 
struct  LogicalRepPreparedTxnData
 
struct  LogicalRepCommitPreparedTxnData
 
struct  LogicalRepRollbackPreparedTxnData
 
struct  LogicalRepStreamAbortData
 

Macros

#define LOGICALREP_PROTO_MIN_VERSION_NUM   1
 
#define LOGICALREP_PROTO_VERSION_NUM   1
 
#define LOGICALREP_PROTO_STREAM_VERSION_NUM   2
 
#define LOGICALREP_PROTO_TWOPHASE_VERSION_NUM   3
 
#define LOGICALREP_PROTO_STREAM_PARALLEL_VERSION_NUM   4
 
#define LOGICALREP_PROTO_MAX_VERSION_NUM   LOGICALREP_PROTO_STREAM_PARALLEL_VERSION_NUM
 
#define LOGICALREP_COLUMN_NULL   'n'
 
#define LOGICALREP_COLUMN_UNCHANGED   'u'
 
#define LOGICALREP_COLUMN_TEXT   't'
 
#define LOGICALREP_COLUMN_BINARY   'b' /* added in PG14 */
 

Typedefs

typedef enum LogicalRepMsgType LogicalRepMsgType
 
typedef struct LogicalRepTupleData LogicalRepTupleData
 
typedef uint32 LogicalRepRelId
 
typedef struct LogicalRepRelation LogicalRepRelation
 
typedef struct LogicalRepTyp LogicalRepTyp
 
typedef struct LogicalRepBeginData LogicalRepBeginData
 
typedef struct LogicalRepCommitData LogicalRepCommitData
 
typedef struct LogicalRepPreparedTxnData LogicalRepPreparedTxnData
 
typedef struct LogicalRepCommitPreparedTxnData LogicalRepCommitPreparedTxnData
 
typedef struct LogicalRepRollbackPreparedTxnData LogicalRepRollbackPreparedTxnData
 
typedef struct LogicalRepStreamAbortData LogicalRepStreamAbortData
 

Enumerations

enum  LogicalRepMsgType {
  LOGICAL_REP_MSG_BEGIN = 'B' , LOGICAL_REP_MSG_COMMIT = 'C' , LOGICAL_REP_MSG_ORIGIN = 'O' , LOGICAL_REP_MSG_INSERT = 'I' ,
  LOGICAL_REP_MSG_UPDATE = 'U' , LOGICAL_REP_MSG_DELETE = 'D' , LOGICAL_REP_MSG_TRUNCATE = 'T' , LOGICAL_REP_MSG_RELATION = 'R' ,
  LOGICAL_REP_MSG_TYPE = 'Y' , LOGICAL_REP_MSG_MESSAGE = 'M' , LOGICAL_REP_MSG_BEGIN_PREPARE = 'b' , LOGICAL_REP_MSG_PREPARE = 'P' ,
  LOGICAL_REP_MSG_COMMIT_PREPARED = 'K' , LOGICAL_REP_MSG_ROLLBACK_PREPARED = 'r' , LOGICAL_REP_MSG_STREAM_START = 'S' , LOGICAL_REP_MSG_STREAM_STOP = 'E' ,
  LOGICAL_REP_MSG_STREAM_COMMIT = 'c' , LOGICAL_REP_MSG_STREAM_ABORT = 'A' , LOGICAL_REP_MSG_STREAM_PREPARE = 'p'
}
 

Functions

void logicalrep_write_begin (StringInfo out, ReorderBufferTXN *txn)
 
void logicalrep_read_begin (StringInfo in, LogicalRepBeginData *begin_data)
 
void logicalrep_write_commit (StringInfo out, ReorderBufferTXN *txn, XLogRecPtr commit_lsn)
 
void logicalrep_read_commit (StringInfo in, LogicalRepCommitData *commit_data)
 
void logicalrep_write_begin_prepare (StringInfo out, ReorderBufferTXN *txn)
 
void logicalrep_read_begin_prepare (StringInfo in, LogicalRepPreparedTxnData *begin_data)
 
void logicalrep_write_prepare (StringInfo out, ReorderBufferTXN *txn, XLogRecPtr prepare_lsn)
 
void logicalrep_read_prepare (StringInfo in, LogicalRepPreparedTxnData *prepare_data)
 
void logicalrep_write_commit_prepared (StringInfo out, ReorderBufferTXN *txn, XLogRecPtr commit_lsn)
 
void logicalrep_read_commit_prepared (StringInfo in, LogicalRepCommitPreparedTxnData *prepare_data)
 
void logicalrep_write_rollback_prepared (StringInfo out, ReorderBufferTXN *txn, XLogRecPtr prepare_end_lsn, TimestampTz prepare_time)
 
void logicalrep_read_rollback_prepared (StringInfo in, LogicalRepRollbackPreparedTxnData *rollback_data)
 
void logicalrep_write_stream_prepare (StringInfo out, ReorderBufferTXN *txn, XLogRecPtr prepare_lsn)
 
void logicalrep_read_stream_prepare (StringInfo in, LogicalRepPreparedTxnData *prepare_data)
 
void logicalrep_write_origin (StringInfo out, const char *origin, XLogRecPtr origin_lsn)
 
char * logicalrep_read_origin (StringInfo in, XLogRecPtr *origin_lsn)
 
void logicalrep_write_insert (StringInfo out, TransactionId xid, Relation rel, TupleTableSlot *newslot, bool binary, Bitmapset *columns)
 
LogicalRepRelId logicalrep_read_insert (StringInfo in, LogicalRepTupleData *newtup)
 
void logicalrep_write_update (StringInfo out, TransactionId xid, Relation rel, TupleTableSlot *oldslot, TupleTableSlot *newslot, bool binary, Bitmapset *columns)
 
LogicalRepRelId logicalrep_read_update (StringInfo in, bool *has_oldtuple, LogicalRepTupleData *oldtup, LogicalRepTupleData *newtup)
 
void logicalrep_write_delete (StringInfo out, TransactionId xid, Relation rel, TupleTableSlot *oldslot, bool binary, Bitmapset *columns)
 
LogicalRepRelId logicalrep_read_delete (StringInfo in, LogicalRepTupleData *oldtup)
 
void logicalrep_write_truncate (StringInfo out, TransactionId xid, int nrelids, Oid relids[], bool cascade, bool restart_seqs)
 
Listlogicalrep_read_truncate (StringInfo in, bool *cascade, bool *restart_seqs)
 
void logicalrep_write_message (StringInfo out, TransactionId xid, XLogRecPtr lsn, bool transactional, const char *prefix, Size sz, const char *message)
 
void logicalrep_write_rel (StringInfo out, TransactionId xid, Relation rel, Bitmapset *columns)
 
LogicalRepRelationlogicalrep_read_rel (StringInfo in)
 
void logicalrep_write_typ (StringInfo out, TransactionId xid, Oid typoid)
 
void logicalrep_read_typ (StringInfo in, LogicalRepTyp *ltyp)
 
void logicalrep_write_stream_start (StringInfo out, TransactionId xid, bool first_segment)
 
TransactionId logicalrep_read_stream_start (StringInfo in, bool *first_segment)
 
void logicalrep_write_stream_stop (StringInfo out)
 
void logicalrep_write_stream_commit (StringInfo out, ReorderBufferTXN *txn, XLogRecPtr commit_lsn)
 
TransactionId logicalrep_read_stream_commit (StringInfo in, LogicalRepCommitData *commit_data)
 
void logicalrep_write_stream_abort (StringInfo out, TransactionId xid, TransactionId subxid, XLogRecPtr abort_lsn, TimestampTz abort_time, bool write_abort_info)
 
void logicalrep_read_stream_abort (StringInfo in, LogicalRepStreamAbortData *abort_data, bool read_abort_info)
 
const char * logicalrep_message_type (LogicalRepMsgType action)
 

Macro Definition Documentation

◆ LOGICALREP_COLUMN_BINARY

#define LOGICALREP_COLUMN_BINARY   'b' /* added in PG14 */

Definition at line 99 of file logicalproto.h.

◆ LOGICALREP_COLUMN_NULL

#define LOGICALREP_COLUMN_NULL   'n'

Definition at line 96 of file logicalproto.h.

◆ LOGICALREP_COLUMN_TEXT

#define LOGICALREP_COLUMN_TEXT   't'

Definition at line 98 of file logicalproto.h.

◆ LOGICALREP_COLUMN_UNCHANGED

#define LOGICALREP_COLUMN_UNCHANGED   'u'

Definition at line 97 of file logicalproto.h.

◆ LOGICALREP_PROTO_MAX_VERSION_NUM

#define LOGICALREP_PROTO_MAX_VERSION_NUM   LOGICALREP_PROTO_STREAM_PARALLEL_VERSION_NUM

Definition at line 45 of file logicalproto.h.

◆ LOGICALREP_PROTO_MIN_VERSION_NUM

#define LOGICALREP_PROTO_MIN_VERSION_NUM   1

Definition at line 40 of file logicalproto.h.

◆ LOGICALREP_PROTO_STREAM_PARALLEL_VERSION_NUM

#define LOGICALREP_PROTO_STREAM_PARALLEL_VERSION_NUM   4

Definition at line 44 of file logicalproto.h.

◆ LOGICALREP_PROTO_STREAM_VERSION_NUM

#define LOGICALREP_PROTO_STREAM_VERSION_NUM   2

Definition at line 42 of file logicalproto.h.

◆ LOGICALREP_PROTO_TWOPHASE_VERSION_NUM

#define LOGICALREP_PROTO_TWOPHASE_VERSION_NUM   3

Definition at line 43 of file logicalproto.h.

◆ LOGICALREP_PROTO_VERSION_NUM

#define LOGICALREP_PROTO_VERSION_NUM   1

Definition at line 41 of file logicalproto.h.

Typedef Documentation

◆ LogicalRepBeginData

◆ LogicalRepCommitData

◆ LogicalRepCommitPreparedTxnData

◆ LogicalRepMsgType

◆ LogicalRepPreparedTxnData

◆ LogicalRepRelation

◆ LogicalRepRelId

Definition at line 101 of file logicalproto.h.

◆ LogicalRepRollbackPreparedTxnData

◆ LogicalRepStreamAbortData

◆ LogicalRepTupleData

◆ LogicalRepTyp

typedef struct LogicalRepTyp LogicalRepTyp

Enumeration Type Documentation

◆ LogicalRepMsgType

Enumerator
LOGICAL_REP_MSG_BEGIN 
LOGICAL_REP_MSG_COMMIT 
LOGICAL_REP_MSG_ORIGIN 
LOGICAL_REP_MSG_INSERT 
LOGICAL_REP_MSG_UPDATE 
LOGICAL_REP_MSG_DELETE 
LOGICAL_REP_MSG_TRUNCATE 
LOGICAL_REP_MSG_RELATION 
LOGICAL_REP_MSG_TYPE 
LOGICAL_REP_MSG_MESSAGE 
LOGICAL_REP_MSG_BEGIN_PREPARE 
LOGICAL_REP_MSG_PREPARE 
LOGICAL_REP_MSG_COMMIT_PREPARED 
LOGICAL_REP_MSG_ROLLBACK_PREPARED 
LOGICAL_REP_MSG_STREAM_START 
LOGICAL_REP_MSG_STREAM_STOP 
LOGICAL_REP_MSG_STREAM_COMMIT 
LOGICAL_REP_MSG_STREAM_ABORT 
LOGICAL_REP_MSG_STREAM_PREPARE 

Definition at line 57 of file logicalproto.h.

58 {
LogicalRepMsgType
Definition: logicalproto.h:58
@ LOGICAL_REP_MSG_INSERT
Definition: logicalproto.h:62
@ LOGICAL_REP_MSG_TRUNCATE
Definition: logicalproto.h:65
@ LOGICAL_REP_MSG_STREAM_STOP
Definition: logicalproto.h:74
@ LOGICAL_REP_MSG_BEGIN
Definition: logicalproto.h:59
@ LOGICAL_REP_MSG_STREAM_PREPARE
Definition: logicalproto.h:77
@ LOGICAL_REP_MSG_STREAM_ABORT
Definition: logicalproto.h:76
@ LOGICAL_REP_MSG_BEGIN_PREPARE
Definition: logicalproto.h:69
@ LOGICAL_REP_MSG_STREAM_START
Definition: logicalproto.h:73
@ LOGICAL_REP_MSG_COMMIT
Definition: logicalproto.h:60
@ LOGICAL_REP_MSG_PREPARE
Definition: logicalproto.h:70
@ LOGICAL_REP_MSG_RELATION
Definition: logicalproto.h:66
@ LOGICAL_REP_MSG_MESSAGE
Definition: logicalproto.h:68
@ LOGICAL_REP_MSG_ROLLBACK_PREPARED
Definition: logicalproto.h:72
@ LOGICAL_REP_MSG_COMMIT_PREPARED
Definition: logicalproto.h:71
@ LOGICAL_REP_MSG_TYPE
Definition: logicalproto.h:67
@ LOGICAL_REP_MSG_DELETE
Definition: logicalproto.h:64
@ LOGICAL_REP_MSG_STREAM_COMMIT
Definition: logicalproto.h:75
@ LOGICAL_REP_MSG_ORIGIN
Definition: logicalproto.h:61
@ LOGICAL_REP_MSG_UPDATE
Definition: logicalproto.h:63

Function Documentation

◆ logicalrep_message_type()

const char* logicalrep_message_type ( LogicalRepMsgType  action)

Definition at line 1217 of file proto.c.

1218 {
1219  static char err_unknown[20];
1220 
1221  switch (action)
1222  {
1223  case LOGICAL_REP_MSG_BEGIN:
1224  return "BEGIN";
1226  return "COMMIT";
1228  return "ORIGIN";
1230  return "INSERT";
1232  return "UPDATE";
1234  return "DELETE";
1236  return "TRUNCATE";
1238  return "RELATION";
1239  case LOGICAL_REP_MSG_TYPE:
1240  return "TYPE";
1242  return "MESSAGE";
1244  return "BEGIN PREPARE";
1246  return "PREPARE";
1248  return "COMMIT PREPARED";
1250  return "ROLLBACK PREPARED";
1252  return "STREAM START";
1254  return "STREAM STOP";
1256  return "STREAM COMMIT";
1258  return "STREAM ABORT";
1260  return "STREAM PREPARE";
1261  }
1262 
1263  /*
1264  * This message provides context in the error raised when applying a
1265  * logical message. So we can't throw an error here. Return an unknown
1266  * indicator value so that the original error is still reported.
1267  */
1268  snprintf(err_unknown, sizeof(err_unknown), "??? (%d)", action);
1269 
1270  return err_unknown;
1271 }
#define snprintf
Definition: port.h:238

References generate_unaccent_rules::action, LOGICAL_REP_MSG_BEGIN, LOGICAL_REP_MSG_BEGIN_PREPARE, LOGICAL_REP_MSG_COMMIT, LOGICAL_REP_MSG_COMMIT_PREPARED, LOGICAL_REP_MSG_DELETE, LOGICAL_REP_MSG_INSERT, LOGICAL_REP_MSG_MESSAGE, LOGICAL_REP_MSG_ORIGIN, LOGICAL_REP_MSG_PREPARE, LOGICAL_REP_MSG_RELATION, LOGICAL_REP_MSG_ROLLBACK_PREPARED, LOGICAL_REP_MSG_STREAM_ABORT, LOGICAL_REP_MSG_STREAM_COMMIT, LOGICAL_REP_MSG_STREAM_PREPARE, LOGICAL_REP_MSG_STREAM_START, LOGICAL_REP_MSG_STREAM_STOP, LOGICAL_REP_MSG_TRUNCATE, LOGICAL_REP_MSG_TYPE, LOGICAL_REP_MSG_UPDATE, and snprintf.

Referenced by apply_error_callback().

◆ logicalrep_read_begin()

void logicalrep_read_begin ( StringInfo  in,
LogicalRepBeginData begin_data 
)

Definition at line 74 of file proto.c.

75 {
76  /* read fields */
77  begin_data->final_lsn = pq_getmsgint64(in);
78  if (begin_data->final_lsn == InvalidXLogRecPtr)
79  elog(ERROR, "final_lsn not set in begin message");
80  begin_data->committime = pq_getmsgint64(in);
81  begin_data->xid = pq_getmsgint(in, 4);
82 }
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
unsigned int pq_getmsgint(StringInfo msg, int b)
Definition: pqformat.c:415
int64 pq_getmsgint64(StringInfo msg)
Definition: pqformat.c:453
XLogRecPtr final_lsn
Definition: logicalproto.h:129
TransactionId xid
Definition: logicalproto.h:131
TimestampTz committime
Definition: logicalproto.h:130
#define InvalidXLogRecPtr
Definition: xlogdefs.h:28

References LogicalRepBeginData::committime, elog, ERROR, LogicalRepBeginData::final_lsn, InvalidXLogRecPtr, pq_getmsgint(), pq_getmsgint64(), and LogicalRepBeginData::xid.

Referenced by apply_handle_begin().

◆ logicalrep_read_begin_prepare()

void logicalrep_read_begin_prepare ( StringInfo  in,
LogicalRepPreparedTxnData begin_data 
)

Definition at line 145 of file proto.c.

146 {
147  /* read fields */
148  begin_data->prepare_lsn = pq_getmsgint64(in);
149  if (begin_data->prepare_lsn == InvalidXLogRecPtr)
150  elog(ERROR, "prepare_lsn not set in begin prepare message");
151  begin_data->end_lsn = pq_getmsgint64(in);
152  if (begin_data->end_lsn == InvalidXLogRecPtr)
153  elog(ERROR, "end_lsn not set in begin prepare message");
154  begin_data->prepare_time = pq_getmsgint64(in);
155  begin_data->xid = pq_getmsgint(in, 4);
156 
157  /* read gid (copy it into a pre-allocated buffer) */
158  strlcpy(begin_data->gid, pq_getmsgstring(in), sizeof(begin_data->gid));
159 }
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
const char * pq_getmsgstring(StringInfo msg)
Definition: pqformat.c:579

References elog, LogicalRepPreparedTxnData::end_lsn, ERROR, LogicalRepPreparedTxnData::gid, InvalidXLogRecPtr, pq_getmsgint(), pq_getmsgint64(), pq_getmsgstring(), LogicalRepPreparedTxnData::prepare_lsn, LogicalRepPreparedTxnData::prepare_time, strlcpy(), and LogicalRepPreparedTxnData::xid.

Referenced by apply_handle_begin_prepare().

◆ logicalrep_read_commit()

void logicalrep_read_commit ( StringInfo  in,
LogicalRepCommitData commit_data 
)

Definition at line 109 of file proto.c.

110 {
111  /* read flags (unused for now) */
112  uint8 flags = pq_getmsgbyte(in);
113 
114  if (flags != 0)
115  elog(ERROR, "unrecognized flags %u in commit message", flags);
116 
117  /* read fields */
118  commit_data->commit_lsn = pq_getmsgint64(in);
119  commit_data->end_lsn = pq_getmsgint64(in);
120  commit_data->committime = pq_getmsgint64(in);
121 }
unsigned char uint8
Definition: c.h:491
int pq_getmsgbyte(StringInfo msg)
Definition: pqformat.c:399
TimestampTz committime
Definition: logicalproto.h:138

References LogicalRepCommitData::commit_lsn, LogicalRepCommitData::committime, elog, LogicalRepCommitData::end_lsn, ERROR, pq_getmsgbyte(), and pq_getmsgint64().

Referenced by apply_handle_commit().

◆ logicalrep_read_commit_prepared()

void logicalrep_read_commit_prepared ( StringInfo  in,
LogicalRepCommitPreparedTxnData prepare_data 
)

Definition at line 278 of file proto.c.

279 {
280  /* read flags */
281  uint8 flags = pq_getmsgbyte(in);
282 
283  if (flags != 0)
284  elog(ERROR, "unrecognized flags %u in commit prepared message", flags);
285 
286  /* read fields */
287  prepare_data->commit_lsn = pq_getmsgint64(in);
288  if (prepare_data->commit_lsn == InvalidXLogRecPtr)
289  elog(ERROR, "commit_lsn is not set in commit prepared message");
290  prepare_data->end_lsn = pq_getmsgint64(in);
291  if (prepare_data->end_lsn == InvalidXLogRecPtr)
292  elog(ERROR, "end_lsn is not set in commit prepared message");
293  prepare_data->commit_time = pq_getmsgint64(in);
294  prepare_data->xid = pq_getmsgint(in, 4);
295 
296  /* read gid (copy it into a pre-allocated buffer) */
297  strlcpy(prepare_data->gid, pq_getmsgstring(in), sizeof(prepare_data->gid));
298 }

References LogicalRepCommitPreparedTxnData::commit_lsn, LogicalRepCommitPreparedTxnData::commit_time, elog, LogicalRepCommitPreparedTxnData::end_lsn, ERROR, LogicalRepCommitPreparedTxnData::gid, InvalidXLogRecPtr, pq_getmsgbyte(), pq_getmsgint(), pq_getmsgint64(), pq_getmsgstring(), strlcpy(), and LogicalRepCommitPreparedTxnData::xid.

Referenced by apply_handle_commit_prepared().

◆ logicalrep_read_delete()

LogicalRepRelId logicalrep_read_delete ( StringInfo  in,
LogicalRepTupleData oldtup 
)

Definition at line 564 of file proto.c.

565 {
566  char action;
567  LogicalRepRelId relid;
568 
569  /* read the relation id */
570  relid = pq_getmsgint(in, 4);
571 
572  /* read and verify action */
573  action = pq_getmsgbyte(in);
574  if (action != 'K' && action != 'O')
575  elog(ERROR, "expected action 'O' or 'K', got %c", action);
576 
577  logicalrep_read_tuple(in, oldtup);
578 
579  return relid;
580 }
uint32 LogicalRepRelId
Definition: logicalproto.h:101
static void logicalrep_read_tuple(StringInfo in, LogicalRepTupleData *tuple)
Definition: proto.c:866

References generate_unaccent_rules::action, elog, ERROR, logicalrep_read_tuple(), pq_getmsgbyte(), and pq_getmsgint().

Referenced by apply_handle_delete().

◆ logicalrep_read_insert()

LogicalRepRelId logicalrep_read_insert ( StringInfo  in,
LogicalRepTupleData newtup 
)

Definition at line 436 of file proto.c.

437 {
438  char action;
439  LogicalRepRelId relid;
440 
441  /* read the relation id */
442  relid = pq_getmsgint(in, 4);
443 
444  action = pq_getmsgbyte(in);
445  if (action != 'N')
446  elog(ERROR, "expected new tuple but got %d",
447  action);
448 
449  logicalrep_read_tuple(in, newtup);
450 
451  return relid;
452 }

References generate_unaccent_rules::action, elog, ERROR, logicalrep_read_tuple(), pq_getmsgbyte(), and pq_getmsgint().

Referenced by apply_handle_insert().

◆ logicalrep_read_origin()

char* logicalrep_read_origin ( StringInfo  in,
XLogRecPtr origin_lsn 
)

Definition at line 401 of file proto.c.

402 {
403  /* fixed fields */
404  *origin_lsn = pq_getmsgint64(in);
405 
406  /* return origin */
407  return pstrdup(pq_getmsgstring(in));
408 }
char * pstrdup(const char *in)
Definition: mcxt.c:1683

References pq_getmsgint64(), pq_getmsgstring(), and pstrdup().

◆ logicalrep_read_prepare()

void logicalrep_read_prepare ( StringInfo  in,
LogicalRepPreparedTxnData prepare_data 
)

Definition at line 239 of file proto.c.

240 {
241  logicalrep_read_prepare_common(in, "prepare", prepare_data);
242 }
static void logicalrep_read_prepare_common(StringInfo in, char *msgtype, LogicalRepPreparedTxnData *prepare_data)
Definition: proto.c:210

References logicalrep_read_prepare_common().

Referenced by apply_handle_prepare().

◆ logicalrep_read_rel()

LogicalRepRelation* logicalrep_read_rel ( StringInfo  in)

Definition at line 700 of file proto.c.

701 {
703 
704  rel->remoteid = pq_getmsgint(in, 4);
705 
706  /* Read relation name from stream */
708  rel->relname = pstrdup(pq_getmsgstring(in));
709 
710  /* Read the replica identity. */
711  rel->replident = pq_getmsgbyte(in);
712 
713  /* Get attribute description */
714  logicalrep_read_attrs(in, rel);
715 
716  return rel;
717 }
void * palloc(Size size)
Definition: mcxt.c:1304
static void logicalrep_read_attrs(StringInfo in, LogicalRepRelation *rel)
Definition: proto.c:993
static const char * logicalrep_read_namespace(StringInfo in)
Definition: proto.c:1055
LogicalRepRelId remoteid
Definition: logicalproto.h:107

References logicalrep_read_attrs(), logicalrep_read_namespace(), LogicalRepRelation::nspname, palloc(), pq_getmsgbyte(), pq_getmsgint(), pq_getmsgstring(), pstrdup(), LogicalRepRelation::relname, LogicalRepRelation::remoteid, and LogicalRepRelation::replident.

Referenced by apply_handle_relation().

◆ logicalrep_read_rollback_prepared()

void logicalrep_read_rollback_prepared ( StringInfo  in,
LogicalRepRollbackPreparedTxnData rollback_data 
)

Definition at line 336 of file proto.c.

338 {
339  /* read flags */
340  uint8 flags = pq_getmsgbyte(in);
341 
342  if (flags != 0)
343  elog(ERROR, "unrecognized flags %u in rollback prepared message", flags);
344 
345  /* read fields */
346  rollback_data->prepare_end_lsn = pq_getmsgint64(in);
347  if (rollback_data->prepare_end_lsn == InvalidXLogRecPtr)
348  elog(ERROR, "prepare_end_lsn is not set in rollback prepared message");
349  rollback_data->rollback_end_lsn = pq_getmsgint64(in);
350  if (rollback_data->rollback_end_lsn == InvalidXLogRecPtr)
351  elog(ERROR, "rollback_end_lsn is not set in rollback prepared message");
352  rollback_data->prepare_time = pq_getmsgint64(in);
353  rollback_data->rollback_time = pq_getmsgint64(in);
354  rollback_data->xid = pq_getmsgint(in, 4);
355 
356  /* read gid (copy it into a pre-allocated buffer) */
357  strlcpy(rollback_data->gid, pq_getmsgstring(in), sizeof(rollback_data->gid));
358 }

References elog, ERROR, LogicalRepRollbackPreparedTxnData::gid, InvalidXLogRecPtr, pq_getmsgbyte(), pq_getmsgint(), pq_getmsgint64(), pq_getmsgstring(), LogicalRepRollbackPreparedTxnData::prepare_end_lsn, LogicalRepRollbackPreparedTxnData::prepare_time, LogicalRepRollbackPreparedTxnData::rollback_end_lsn, LogicalRepRollbackPreparedTxnData::rollback_time, strlcpy(), and LogicalRepRollbackPreparedTxnData::xid.

Referenced by apply_handle_rollback_prepared().

◆ logicalrep_read_stream_abort()

void logicalrep_read_stream_abort ( StringInfo  in,
LogicalRepStreamAbortData abort_data,
bool  read_abort_info 
)

Definition at line 1192 of file proto.c.

1195 {
1196  Assert(abort_data);
1197 
1198  abort_data->xid = pq_getmsgint(in, 4);
1199  abort_data->subxid = pq_getmsgint(in, 4);
1200 
1201  if (read_abort_info)
1202  {
1203  abort_data->abort_lsn = pq_getmsgint64(in);
1204  abort_data->abort_time = pq_getmsgint64(in);
1205  }
1206  else
1207  {
1208  abort_data->abort_lsn = InvalidXLogRecPtr;
1209  abort_data->abort_time = 0;
1210  }
1211 }
Assert(fmt[strlen(fmt) - 1] !='\n')

References LogicalRepStreamAbortData::abort_lsn, LogicalRepStreamAbortData::abort_time, Assert(), InvalidXLogRecPtr, pq_getmsgint(), pq_getmsgint64(), LogicalRepStreamAbortData::subxid, and LogicalRepStreamAbortData::xid.

Referenced by apply_handle_stream_abort().

◆ logicalrep_read_stream_commit()

TransactionId logicalrep_read_stream_commit ( StringInfo  in,
LogicalRepCommitData commit_data 
)

Definition at line 1137 of file proto.c.

1138 {
1139  TransactionId xid;
1140  uint8 flags;
1141 
1142  xid = pq_getmsgint(in, 4);
1143 
1144  /* read flags (unused for now) */
1145  flags = pq_getmsgbyte(in);
1146 
1147  if (flags != 0)
1148  elog(ERROR, "unrecognized flags %u in commit message", flags);
1149 
1150  /* read fields */
1151  commit_data->commit_lsn = pq_getmsgint64(in);
1152  commit_data->end_lsn = pq_getmsgint64(in);
1153  commit_data->committime = pq_getmsgint64(in);
1154 
1155  return xid;
1156 }
uint32 TransactionId
Definition: c.h:639

References LogicalRepCommitData::commit_lsn, LogicalRepCommitData::committime, elog, LogicalRepCommitData::end_lsn, ERROR, pq_getmsgbyte(), pq_getmsgint(), and pq_getmsgint64().

Referenced by apply_handle_stream_commit().

◆ logicalrep_read_stream_prepare()

void logicalrep_read_stream_prepare ( StringInfo  in,
LogicalRepPreparedTxnData prepare_data 
)

Definition at line 376 of file proto.c.

377 {
378  logicalrep_read_prepare_common(in, "stream prepare", prepare_data);
379 }

References logicalrep_read_prepare_common().

Referenced by apply_handle_stream_prepare().

◆ logicalrep_read_stream_start()

TransactionId logicalrep_read_stream_start ( StringInfo  in,
bool first_segment 
)

Definition at line 1087 of file proto.c.

1088 {
1089  TransactionId xid;
1090 
1091  Assert(first_segment);
1092 
1093  xid = pq_getmsgint(in, 4);
1094  *first_segment = (pq_getmsgbyte(in) == 1);
1095 
1096  return xid;
1097 }

References Assert(), pq_getmsgbyte(), and pq_getmsgint().

Referenced by apply_handle_stream_start().

◆ logicalrep_read_truncate()

List* logicalrep_read_truncate ( StringInfo  in,
bool cascade,
bool restart_seqs 
)

Definition at line 618 of file proto.c.

620 {
621  int i;
622  int nrelids;
623  List *relids = NIL;
624  uint8 flags;
625 
626  nrelids = pq_getmsgint(in, 4);
627 
628  /* read and decode truncate flags */
629  flags = pq_getmsgint(in, 1);
630  *cascade = (flags & TRUNCATE_CASCADE) > 0;
631  *restart_seqs = (flags & TRUNCATE_RESTART_SEQS) > 0;
632 
633  for (i = 0; i < nrelids; i++)
634  relids = lappend_oid(relids, pq_getmsgint(in, 4));
635 
636  return relids;
637 }
int i
Definition: isn.c:73
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
#define NIL
Definition: pg_list.h:68
#define TRUNCATE_RESTART_SEQS
Definition: proto.c:30
#define TRUNCATE_CASCADE
Definition: proto.c:29
Definition: pg_list.h:54

References i, lappend_oid(), NIL, pq_getmsgint(), TRUNCATE_CASCADE, and TRUNCATE_RESTART_SEQS.

Referenced by apply_handle_truncate().

◆ logicalrep_read_typ()

void logicalrep_read_typ ( StringInfo  in,
LogicalRepTyp ltyp 
)

Definition at line 756 of file proto.c.

757 {
758  ltyp->remoteid = pq_getmsgint(in, 4);
759 
760  /* Read type name from stream */
762  ltyp->typname = pstrdup(pq_getmsgstring(in));
763 }

References logicalrep_read_namespace(), LogicalRepTyp::nspname, pq_getmsgint(), pq_getmsgstring(), pstrdup(), LogicalRepTyp::remoteid, and LogicalRepTyp::typname.

Referenced by apply_handle_type().

◆ logicalrep_read_update()

LogicalRepRelId logicalrep_read_update ( StringInfo  in,
bool has_oldtuple,
LogicalRepTupleData oldtup,
LogicalRepTupleData newtup 
)

Definition at line 492 of file proto.c.

495 {
496  char action;
497  LogicalRepRelId relid;
498 
499  /* read the relation id */
500  relid = pq_getmsgint(in, 4);
501 
502  /* read and verify action */
503  action = pq_getmsgbyte(in);
504  if (action != 'K' && action != 'O' && action != 'N')
505  elog(ERROR, "expected action 'N', 'O' or 'K', got %c",
506  action);
507 
508  /* check for old tuple */
509  if (action == 'K' || action == 'O')
510  {
511  logicalrep_read_tuple(in, oldtup);
512  *has_oldtuple = true;
513 
514  action = pq_getmsgbyte(in);
515  }
516  else
517  *has_oldtuple = false;
518 
519  /* check for new tuple */
520  if (action != 'N')
521  elog(ERROR, "expected action 'N', got %c",
522  action);
523 
524  logicalrep_read_tuple(in, newtup);
525 
526  return relid;
527 }

References generate_unaccent_rules::action, elog, ERROR, logicalrep_read_tuple(), pq_getmsgbyte(), and pq_getmsgint().

Referenced by apply_handle_update().

◆ logicalrep_write_begin()

void logicalrep_write_begin ( StringInfo  out,
ReorderBufferTXN txn 
)

Definition at line 60 of file proto.c.

61 {
63 
64  /* fixed fields */
65  pq_sendint64(out, txn->final_lsn);
67  pq_sendint32(out, txn->xid);
68 }
static void pq_sendint32(StringInfo buf, uint32 i)
Definition: pqformat.h:144
static void pq_sendbyte(StringInfo buf, uint8 byt)
Definition: pqformat.h:160
static void pq_sendint64(StringInfo buf, uint64 i)
Definition: pqformat.h:152
TimestampTz commit_time
XLogRecPtr final_lsn
TransactionId xid
union ReorderBufferTXN::@106 xact_time

References ReorderBufferTXN::commit_time, ReorderBufferTXN::final_lsn, LOGICAL_REP_MSG_BEGIN, pq_sendbyte(), pq_sendint32(), pq_sendint64(), ReorderBufferTXN::xact_time, and ReorderBufferTXN::xid.

Referenced by pgoutput_send_begin().

◆ logicalrep_write_begin_prepare()

void logicalrep_write_begin_prepare ( StringInfo  out,
ReorderBufferTXN txn 
)

Definition at line 127 of file proto.c.

128 {
130 
131  /* fixed fields */
132  pq_sendint64(out, txn->final_lsn);
133  pq_sendint64(out, txn->end_lsn);
135  pq_sendint32(out, txn->xid);
136 
137  /* send gid */
138  pq_sendstring(out, txn->gid);
139 }
void pq_sendstring(StringInfo buf, const char *str)
Definition: pqformat.c:195
XLogRecPtr end_lsn
TimestampTz prepare_time

References ReorderBufferTXN::end_lsn, ReorderBufferTXN::final_lsn, ReorderBufferTXN::gid, LOGICAL_REP_MSG_BEGIN_PREPARE, pq_sendbyte(), pq_sendint32(), pq_sendint64(), pq_sendstring(), ReorderBufferTXN::prepare_time, ReorderBufferTXN::xact_time, and ReorderBufferTXN::xid.

Referenced by pgoutput_begin_prepare_txn().

◆ logicalrep_write_commit()

void logicalrep_write_commit ( StringInfo  out,
ReorderBufferTXN txn,
XLogRecPtr  commit_lsn 
)

Definition at line 89 of file proto.c.

91 {
92  uint8 flags = 0;
93 
95 
96  /* send the flags field (unused for now) */
97  pq_sendbyte(out, flags);
98 
99  /* send fields */
100  pq_sendint64(out, commit_lsn);
101  pq_sendint64(out, txn->end_lsn);
103 }

References ReorderBufferTXN::commit_time, ReorderBufferTXN::end_lsn, LOGICAL_REP_MSG_COMMIT, pq_sendbyte(), pq_sendint64(), and ReorderBufferTXN::xact_time.

Referenced by pgoutput_commit_txn().

◆ logicalrep_write_commit_prepared()

void logicalrep_write_commit_prepared ( StringInfo  out,
ReorderBufferTXN txn,
XLogRecPtr  commit_lsn 
)

Definition at line 248 of file proto.c.

250 {
251  uint8 flags = 0;
252 
254 
255  /*
256  * This should only ever happen for two-phase commit transactions, in
257  * which case we expect to have a valid GID.
258  */
259  Assert(txn->gid != NULL);
260 
261  /* send the flags field */
262  pq_sendbyte(out, flags);
263 
264  /* send fields */
265  pq_sendint64(out, commit_lsn);
266  pq_sendint64(out, txn->end_lsn);
268  pq_sendint32(out, txn->xid);
269 
270  /* send gid */
271  pq_sendstring(out, txn->gid);
272 }

References Assert(), ReorderBufferTXN::commit_time, ReorderBufferTXN::end_lsn, ReorderBufferTXN::gid, LOGICAL_REP_MSG_COMMIT_PREPARED, pq_sendbyte(), pq_sendint32(), pq_sendint64(), pq_sendstring(), ReorderBufferTXN::xact_time, and ReorderBufferTXN::xid.

Referenced by pgoutput_commit_prepared_txn().

◆ logicalrep_write_delete()

void logicalrep_write_delete ( StringInfo  out,
TransactionId  xid,
Relation  rel,
TupleTableSlot oldslot,
bool  binary,
Bitmapset columns 
)

Definition at line 533 of file proto.c.

536 {
537  Assert(rel->rd_rel->relreplident == REPLICA_IDENTITY_DEFAULT ||
538  rel->rd_rel->relreplident == REPLICA_IDENTITY_FULL ||
539  rel->rd_rel->relreplident == REPLICA_IDENTITY_INDEX);
540 
542 
543  /* transaction ID (if not valid, we're not streaming) */
544  if (TransactionIdIsValid(xid))
545  pq_sendint32(out, xid);
546 
547  /* use Oid as relation identifier */
548  pq_sendint32(out, RelationGetRelid(rel));
549 
550  if (rel->rd_rel->relreplident == REPLICA_IDENTITY_FULL)
551  pq_sendbyte(out, 'O'); /* old tuple follows */
552  else
553  pq_sendbyte(out, 'K'); /* old key follows */
554 
555  logicalrep_write_tuple(out, rel, oldslot, binary, columns);
556 }
static void logicalrep_write_tuple(StringInfo out, Relation rel, TupleTableSlot *slot, bool binary, Bitmapset *columns)
Definition: proto.c:769
#define RelationGetRelid(relation)
Definition: rel.h:505
Form_pg_class rd_rel
Definition: rel.h:111
#define TransactionIdIsValid(xid)
Definition: transam.h:41

References Assert(), LOGICAL_REP_MSG_DELETE, logicalrep_write_tuple(), pq_sendbyte(), pq_sendint32(), RelationData::rd_rel, RelationGetRelid, and TransactionIdIsValid.

Referenced by pgoutput_change().

◆ logicalrep_write_insert()

void logicalrep_write_insert ( StringInfo  out,
TransactionId  xid,
Relation  rel,
TupleTableSlot newslot,
bool  binary,
Bitmapset columns 
)

Definition at line 414 of file proto.c.

416 {
418 
419  /* transaction ID (if not valid, we're not streaming) */
420  if (TransactionIdIsValid(xid))
421  pq_sendint32(out, xid);
422 
423  /* use Oid as relation identifier */
424  pq_sendint32(out, RelationGetRelid(rel));
425 
426  pq_sendbyte(out, 'N'); /* new tuple follows */
427  logicalrep_write_tuple(out, rel, newslot, binary, columns);
428 }

References LOGICAL_REP_MSG_INSERT, logicalrep_write_tuple(), pq_sendbyte(), pq_sendint32(), RelationGetRelid, and TransactionIdIsValid.

Referenced by pgoutput_change().

◆ logicalrep_write_message()

void logicalrep_write_message ( StringInfo  out,
TransactionId  xid,
XLogRecPtr  lsn,
bool  transactional,
const char *  prefix,
Size  sz,
const char *  message 
)

Definition at line 643 of file proto.c.

646 {
647  uint8 flags = 0;
648 
650 
651  /* encode and send message flags */
652  if (transactional)
653  flags |= MESSAGE_TRANSACTIONAL;
654 
655  /* transaction ID (if not valid, we're not streaming) */
656  if (TransactionIdIsValid(xid))
657  pq_sendint32(out, xid);
658 
659  pq_sendint8(out, flags);
660  pq_sendint64(out, lsn);
661  pq_sendstring(out, prefix);
662  pq_sendint32(out, sz);
663  pq_sendbytes(out, message, sz);
664 }
void pq_sendbytes(StringInfo buf, const void *data, int datalen)
Definition: pqformat.c:126
static void pq_sendint8(StringInfo buf, uint8 i)
Definition: pqformat.h:128
#define MESSAGE_TRANSACTIONAL
Definition: proto.c:28

References LOGICAL_REP_MSG_MESSAGE, MESSAGE_TRANSACTIONAL, pq_sendbyte(), pq_sendbytes(), pq_sendint32(), pq_sendint64(), pq_sendint8(), pq_sendstring(), and TransactionIdIsValid.

Referenced by pgoutput_message().

◆ logicalrep_write_origin()

void logicalrep_write_origin ( StringInfo  out,
const char *  origin,
XLogRecPtr  origin_lsn 
)

Definition at line 385 of file proto.c.

387 {
389 
390  /* fixed fields */
391  pq_sendint64(out, origin_lsn);
392 
393  /* origin string */
394  pq_sendstring(out, origin);
395 }

References LOGICAL_REP_MSG_ORIGIN, pq_sendbyte(), pq_sendint64(), and pq_sendstring().

Referenced by send_repl_origin().

◆ logicalrep_write_prepare()

void logicalrep_write_prepare ( StringInfo  out,
ReorderBufferTXN txn,
XLogRecPtr  prepare_lsn 
)

Definition at line 198 of file proto.c.

200 {
202  txn, prepare_lsn);
203 }
static void logicalrep_write_prepare_common(StringInfo out, LogicalRepMsgType type, ReorderBufferTXN *txn, XLogRecPtr prepare_lsn)
Definition: proto.c:166

References LOGICAL_REP_MSG_PREPARE, and logicalrep_write_prepare_common().

Referenced by pgoutput_prepare_txn().

◆ logicalrep_write_rel()

void logicalrep_write_rel ( StringInfo  out,
TransactionId  xid,
Relation  rel,
Bitmapset columns 
)

Definition at line 670 of file proto.c.

672 {
673  char *relname;
674 
676 
677  /* transaction ID (if not valid, we're not streaming) */
678  if (TransactionIdIsValid(xid))
679  pq_sendint32(out, xid);
680 
681  /* use Oid as relation identifier */
682  pq_sendint32(out, RelationGetRelid(rel));
683 
684  /* send qualified relation name */
687  pq_sendstring(out, relname);
688 
689  /* send replica identity */
690  pq_sendbyte(out, rel->rd_rel->relreplident);
691 
692  /* send the attribute info */
693  logicalrep_write_attrs(out, rel, columns);
694 }
NameData relname
Definition: pg_class.h:38
static void logicalrep_write_namespace(StringInfo out, Oid nspid)
Definition: proto.c:1035
static void logicalrep_write_attrs(StringInfo out, Relation rel, Bitmapset *columns)
Definition: proto.c:926
#define RelationGetRelationName(relation)
Definition: rel.h:539
#define RelationGetNamespace(relation)
Definition: rel.h:546

References LOGICAL_REP_MSG_RELATION, logicalrep_write_attrs(), logicalrep_write_namespace(), pq_sendbyte(), pq_sendint32(), pq_sendstring(), RelationData::rd_rel, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, relname, and TransactionIdIsValid.

Referenced by send_relation_and_attrs().

◆ logicalrep_write_rollback_prepared()

void logicalrep_write_rollback_prepared ( StringInfo  out,
ReorderBufferTXN txn,
XLogRecPtr  prepare_end_lsn,
TimestampTz  prepare_time 
)

Definition at line 304 of file proto.c.

307 {
308  uint8 flags = 0;
309 
311 
312  /*
313  * This should only ever happen for two-phase commit transactions, in
314  * which case we expect to have a valid GID.
315  */
316  Assert(txn->gid != NULL);
317 
318  /* send the flags field */
319  pq_sendbyte(out, flags);
320 
321  /* send fields */
322  pq_sendint64(out, prepare_end_lsn);
323  pq_sendint64(out, txn->end_lsn);
324  pq_sendint64(out, prepare_time);
326  pq_sendint32(out, txn->xid);
327 
328  /* send gid */
329  pq_sendstring(out, txn->gid);
330 }

References Assert(), ReorderBufferTXN::commit_time, ReorderBufferTXN::end_lsn, ReorderBufferTXN::gid, LOGICAL_REP_MSG_ROLLBACK_PREPARED, pq_sendbyte(), pq_sendint32(), pq_sendint64(), pq_sendstring(), ReorderBufferTXN::xact_time, and ReorderBufferTXN::xid.

Referenced by pgoutput_rollback_prepared_txn().

◆ logicalrep_write_stream_abort()

void logicalrep_write_stream_abort ( StringInfo  out,
TransactionId  xid,
TransactionId  subxid,
XLogRecPtr  abort_lsn,
TimestampTz  abort_time,
bool  write_abort_info 
)

Definition at line 1166 of file proto.c.

1169 {
1171 
1173 
1174  /* transaction ID */
1175  pq_sendint32(out, xid);
1176  pq_sendint32(out, subxid);
1177 
1178  if (write_abort_info)
1179  {
1180  pq_sendint64(out, abort_lsn);
1181  pq_sendint64(out, abort_time);
1182  }
1183 }

References Assert(), LOGICAL_REP_MSG_STREAM_ABORT, pq_sendbyte(), pq_sendint32(), pq_sendint64(), and TransactionIdIsValid.

Referenced by pgoutput_stream_abort().

◆ logicalrep_write_stream_commit()

void logicalrep_write_stream_commit ( StringInfo  out,
ReorderBufferTXN txn,
XLogRecPtr  commit_lsn 
)

Definition at line 1112 of file proto.c.

1114 {
1115  uint8 flags = 0;
1116 
1118 
1120 
1121  /* transaction ID */
1122  pq_sendint32(out, txn->xid);
1123 
1124  /* send the flags field (unused for now) */
1125  pq_sendbyte(out, flags);
1126 
1127  /* send fields */
1128  pq_sendint64(out, commit_lsn);
1129  pq_sendint64(out, txn->end_lsn);
1130  pq_sendint64(out, txn->xact_time.commit_time);
1131 }

References Assert(), ReorderBufferTXN::commit_time, ReorderBufferTXN::end_lsn, LOGICAL_REP_MSG_STREAM_COMMIT, pq_sendbyte(), pq_sendint32(), pq_sendint64(), TransactionIdIsValid, ReorderBufferTXN::xact_time, and ReorderBufferTXN::xid.

Referenced by pgoutput_stream_commit().

◆ logicalrep_write_stream_prepare()

void logicalrep_write_stream_prepare ( StringInfo  out,
ReorderBufferTXN txn,
XLogRecPtr  prepare_lsn 
)

Definition at line 364 of file proto.c.

367 {
369  txn, prepare_lsn);
370 }

References LOGICAL_REP_MSG_STREAM_PREPARE, and logicalrep_write_prepare_common().

Referenced by pgoutput_stream_prepare_txn().

◆ logicalrep_write_stream_start()

void logicalrep_write_stream_start ( StringInfo  out,
TransactionId  xid,
bool  first_segment 
)

Definition at line 1069 of file proto.c.

1071 {
1073 
1075 
1076  /* transaction ID (we're starting to stream, so must be valid) */
1077  pq_sendint32(out, xid);
1078 
1079  /* 1 if this is the first streaming segment for this xid */
1080  pq_sendbyte(out, first_segment ? 1 : 0);
1081 }

References Assert(), LOGICAL_REP_MSG_STREAM_START, pq_sendbyte(), pq_sendint32(), and TransactionIdIsValid.

Referenced by pgoutput_stream_start().

◆ logicalrep_write_stream_stop()

void logicalrep_write_stream_stop ( StringInfo  out)

Definition at line 1103 of file proto.c.

1104 {
1106 }

References LOGICAL_REP_MSG_STREAM_STOP, and pq_sendbyte().

Referenced by pgoutput_stream_stop().

◆ logicalrep_write_truncate()

void logicalrep_write_truncate ( StringInfo  out,
TransactionId  xid,
int  nrelids,
Oid  relids[],
bool  cascade,
bool  restart_seqs 
)

Definition at line 586 of file proto.c.

591 {
592  int i;
593  uint8 flags = 0;
594 
596 
597  /* transaction ID (if not valid, we're not streaming) */
598  if (TransactionIdIsValid(xid))
599  pq_sendint32(out, xid);
600 
601  pq_sendint32(out, nrelids);
602 
603  /* encode and send truncate flags */
604  if (cascade)
605  flags |= TRUNCATE_CASCADE;
606  if (restart_seqs)
607  flags |= TRUNCATE_RESTART_SEQS;
608  pq_sendint8(out, flags);
609 
610  for (i = 0; i < nrelids; i++)
611  pq_sendint32(out, relids[i]);
612 }

References i, LOGICAL_REP_MSG_TRUNCATE, pq_sendbyte(), pq_sendint32(), pq_sendint8(), TransactionIdIsValid, TRUNCATE_CASCADE, and TRUNCATE_RESTART_SEQS.

Referenced by pgoutput_truncate().

◆ logicalrep_write_typ()

void logicalrep_write_typ ( StringInfo  out,
TransactionId  xid,
Oid  typoid 
)

Definition at line 725 of file proto.c.

726 {
727  Oid basetypoid = getBaseType(typoid);
728  HeapTuple tup;
729  Form_pg_type typtup;
730 
732 
733  /* transaction ID (if not valid, we're not streaming) */
734  if (TransactionIdIsValid(xid))
735  pq_sendint32(out, xid);
736 
737  tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(basetypoid));
738  if (!HeapTupleIsValid(tup))
739  elog(ERROR, "cache lookup failed for type %u", basetypoid);
740  typtup = (Form_pg_type) GETSTRUCT(tup);
741 
742  /* use Oid as relation identifier */
743  pq_sendint32(out, typoid);
744 
745  /* send qualified type name */
746  logicalrep_write_namespace(out, typtup->typnamespace);
747  pq_sendstring(out, NameStr(typtup->typname));
748 
749  ReleaseSysCache(tup);
750 }
#define NameStr(name)
Definition: c.h:733
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
Oid getBaseType(Oid typid)
Definition: lsyscache.c:2477
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
unsigned int Oid
Definition: postgres_ext.h:31
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218

References elog, ERROR, getBaseType(), GETSTRUCT, HeapTupleIsValid, LOGICAL_REP_MSG_TYPE, logicalrep_write_namespace(), NameStr, ObjectIdGetDatum(), pq_sendbyte(), pq_sendint32(), pq_sendstring(), ReleaseSysCache(), SearchSysCache1(), and TransactionIdIsValid.

Referenced by send_relation_and_attrs().

◆ logicalrep_write_update()

void logicalrep_write_update ( StringInfo  out,
TransactionId  xid,
Relation  rel,
TupleTableSlot oldslot,
TupleTableSlot newslot,
bool  binary,
Bitmapset columns 
)

Definition at line 458 of file proto.c.

461 {
463 
464  Assert(rel->rd_rel->relreplident == REPLICA_IDENTITY_DEFAULT ||
465  rel->rd_rel->relreplident == REPLICA_IDENTITY_FULL ||
466  rel->rd_rel->relreplident == REPLICA_IDENTITY_INDEX);
467 
468  /* transaction ID (if not valid, we're not streaming) */
469  if (TransactionIdIsValid(xid))
470  pq_sendint32(out, xid);
471 
472  /* use Oid as relation identifier */
473  pq_sendint32(out, RelationGetRelid(rel));
474 
475  if (oldslot != NULL)
476  {
477  if (rel->rd_rel->relreplident == REPLICA_IDENTITY_FULL)
478  pq_sendbyte(out, 'O'); /* old tuple follows */
479  else
480  pq_sendbyte(out, 'K'); /* old key follows */
481  logicalrep_write_tuple(out, rel, oldslot, binary, columns);
482  }
483 
484  pq_sendbyte(out, 'N'); /* new tuple follows */
485  logicalrep_write_tuple(out, rel, newslot, binary, columns);
486 }

References Assert(), LOGICAL_REP_MSG_UPDATE, logicalrep_write_tuple(), pq_sendbyte(), pq_sendint32(), RelationData::rd_rel, RelationGetRelid, and TransactionIdIsValid.

Referenced by pgoutput_change().