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
 

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_MAX_VERSION_NUM   LOGICALREP_PROTO_TWOPHASE_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
 

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 *oldtuple, bool binary)
 
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 out, 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 out, LogicalRepCommitData *commit_data)
 
void logicalrep_write_stream_abort (StringInfo out, TransactionId xid, TransactionId subxid)
 
void logicalrep_read_stream_abort (StringInfo in, TransactionId *xid, TransactionId *subxid)
 
char * logicalrep_message_type (LogicalRepMsgType action)
 

Macro Definition Documentation

◆ LOGICALREP_COLUMN_BINARY

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

Definition at line 94 of file logicalproto.h.

◆ LOGICALREP_COLUMN_NULL

#define LOGICALREP_COLUMN_NULL   'n'

Definition at line 91 of file logicalproto.h.

◆ LOGICALREP_COLUMN_TEXT

#define LOGICALREP_COLUMN_TEXT   't'

Definition at line 93 of file logicalproto.h.

◆ LOGICALREP_COLUMN_UNCHANGED

#define LOGICALREP_COLUMN_UNCHANGED   'u'

Definition at line 92 of file logicalproto.h.

◆ LOGICALREP_PROTO_MAX_VERSION_NUM

#define LOGICALREP_PROTO_MAX_VERSION_NUM   LOGICALREP_PROTO_TWOPHASE_VERSION_NUM

Definition at line 40 of file logicalproto.h.

◆ LOGICALREP_PROTO_MIN_VERSION_NUM

#define LOGICALREP_PROTO_MIN_VERSION_NUM   1

Definition at line 36 of file logicalproto.h.

◆ LOGICALREP_PROTO_STREAM_VERSION_NUM

#define LOGICALREP_PROTO_STREAM_VERSION_NUM   2

Definition at line 38 of file logicalproto.h.

◆ LOGICALREP_PROTO_TWOPHASE_VERSION_NUM

#define LOGICALREP_PROTO_TWOPHASE_VERSION_NUM   3

Definition at line 39 of file logicalproto.h.

◆ LOGICALREP_PROTO_VERSION_NUM

#define LOGICALREP_PROTO_VERSION_NUM   1

Definition at line 37 of file logicalproto.h.

Typedef Documentation

◆ LogicalRepBeginData

◆ LogicalRepCommitData

◆ LogicalRepCommitPreparedTxnData

◆ LogicalRepMsgType

◆ LogicalRepPreparedTxnData

◆ LogicalRepRelation

◆ LogicalRepRelId

Definition at line 96 of file logicalproto.h.

◆ LogicalRepRollbackPreparedTxnData

◆ 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 52 of file logicalproto.h.

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

Function Documentation

◆ logicalrep_message_type()

char* logicalrep_message_type ( LogicalRepMsgType  action)

Definition at line 1197 of file proto.c.

1198 {
1199  switch (action)
1200  {
1201  case LOGICAL_REP_MSG_BEGIN:
1202  return "BEGIN";
1204  return "COMMIT";
1206  return "ORIGIN";
1208  return "INSERT";
1210  return "UPDATE";
1212  return "DELETE";
1214  return "TRUNCATE";
1216  return "RELATION";
1217  case LOGICAL_REP_MSG_TYPE:
1218  return "TYPE";
1220  return "MESSAGE";
1222  return "BEGIN PREPARE";
1224  return "PREPARE";
1226  return "COMMIT PREPARED";
1228  return "ROLLBACK PREPARED";
1230  return "STREAM START";
1232  return "STREAM STOP";
1234  return "STREAM COMMIT";
1236  return "STREAM ABORT";
1238  return "STREAM PREPARE";
1239  }
1240 
1241  elog(ERROR, "invalid logical replication message type \"%c\"", action);
1242 
1243  return NULL; /* keep compiler quiet */
1244 }
#define ERROR
Definition: elog.h:33
#define elog(elevel,...)
Definition: elog.h:218

References generate_unaccent_rules::action, elog, ERROR, 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, and LOGICAL_REP_MSG_UPDATE.

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 }
unsigned int pq_getmsgint(StringInfo msg, int b)
Definition: pqformat.c:417
int64 pq_getmsgint64(StringInfo msg)
Definition: pqformat.c:455
XLogRecPtr final_lsn
Definition: logicalproto.h:124
TransactionId xid
Definition: logicalproto.h:126
TimestampTz committime
Definition: logicalproto.h:125
#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:581

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:439
int pq_getmsgbyte(StringInfo msg)
Definition: pqformat.c:401
TimestampTz committime
Definition: logicalproto.h:133

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 563 of file proto.c.

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

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:1305

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 699 of file proto.c.

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

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,
TransactionId xid,
TransactionId subxid 
)

Definition at line 1184 of file proto.c.

1186 {
1187  Assert(xid && subxid);
1188 
1189  *xid = pq_getmsgint(in, 4);
1190  *subxid = pq_getmsgint(in, 4);
1191 }
Assert(fmt[strlen(fmt) - 1] !='\n')

References Assert(), and pq_getmsgint().

Referenced by apply_handle_stream_abort().

◆ logicalrep_read_stream_commit()

TransactionId logicalrep_read_stream_commit ( StringInfo  out,
LogicalRepCommitData commit_data 
)

Definition at line 1142 of file proto.c.

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

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 1092 of file proto.c.

1093 {
1094  TransactionId xid;
1095 
1096  Assert(first_segment);
1097 
1098  xid = pq_getmsgint(in, 4);
1099  *first_segment = (pq_getmsgbyte(in) == 1);
1100 
1101  return xid;
1102 }

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 617 of file proto.c.

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

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  out,
LogicalRepTyp ltyp 
)

Definition at line 755 of file proto.c.

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

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:145
static void pq_sendbyte(StringInfo buf, uint8 byt)
Definition: pqformat.h:161
static void pq_sendint64(StringInfo buf, uint64 i)
Definition: pqformat.h:153
TimestampTz commit_time
XLogRecPtr final_lsn
TransactionId xid
union ReorderBufferTXN::@111 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:197
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 oldtuple,
bool  binary 
)

Definition at line 533 of file proto.c.

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

645 {
646  uint8 flags = 0;
647 
649 
650  /* encode and send message flags */
651  if (transactional)
652  flags |= MESSAGE_TRANSACTIONAL;
653 
654  /* transaction ID (if not valid, we're not streaming) */
655  if (TransactionIdIsValid(xid))
656  pq_sendint32(out, xid);
657 
658  pq_sendint8(out, flags);
659  pq_sendint64(out, lsn);
660  pq_sendstring(out, prefix);
661  pq_sendint32(out, sz);
662  pq_sendbytes(out, message, sz);
663 }
void pq_sendbytes(StringInfo buf, const char *data, int datalen)
Definition: pqformat.c:125
static void pq_sendint8(StringInfo buf, uint8 i)
Definition: pqformat.h:129
#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 669 of file proto.c.

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

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 
)

Definition at line 1168 of file proto.c.

1170 {
1172 
1174 
1175  /* transaction ID */
1176  pq_sendint32(out, xid);
1177  pq_sendint32(out, subxid);
1178 }

References Assert(), LOGICAL_REP_MSG_STREAM_ABORT, pq_sendbyte(), pq_sendint32(), 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 1117 of file proto.c.

1119 {
1120  uint8 flags = 0;
1121 
1123 
1125 
1126  /* transaction ID */
1127  pq_sendint32(out, txn->xid);
1128 
1129  /* send the flags field (unused for now) */
1130  pq_sendbyte(out, flags);
1131 
1132  /* send fields */
1133  pq_sendint64(out, commit_lsn);
1134  pq_sendint64(out, txn->end_lsn);
1135  pq_sendint64(out, txn->xact_time.commit_time);
1136 }

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 1074 of file proto.c.

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

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 1108 of file proto.c.

1109 {
1111 }

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 585 of file proto.c.

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

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 724 of file proto.c.

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

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

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, NULL);
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().