%{
/*-------------------------------------------------------------------------
 *
 * repl_gram.y				- Parser for the replication commands
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *	  src/backend/replication/repl_gram.y
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include "access/xlogdefs.h"
#include "nodes/makefuncs.h"
#include "nodes/parsenodes.h"
#include "nodes/replnodes.h"
#include "replication/walsender.h"
#include "replication/walsender_private.h"

#include "repl_gram.h"


/*
 * Bison doesn't allocate anything that needs to live across parser calls,
 * so we can easily have it use palloc instead of malloc.  This prevents
 * memory leaks if we error out during parsing.
 */
#define YYMALLOC palloc
#define YYFREE   pfree

%}

%parse-param {Node **replication_parse_result_p}
%parse-param {yyscan_t yyscanner}
%lex-param   {yyscan_t yyscanner}
%pure-parser
%expect 0
%name-prefix="replication_yy"

%union
{
	char	   *str;
	bool		boolval;
	uint32		uintval;
	XLogRecPtr	recptr;
	Node	   *node;
	List	   *list;
	DefElem	   *defelt;
}

/* Non-keyword tokens */
%token <str> SCONST IDENT
%token <uintval> UCONST
%token <recptr> RECPTR

/* Keyword tokens. */
%token K_BASE_BACKUP
%token K_IDENTIFY_SYSTEM
%token K_READ_REPLICATION_SLOT
%token K_SHOW
%token K_START_REPLICATION
%token K_CREATE_REPLICATION_SLOT
%token K_DROP_REPLICATION_SLOT
%token K_ALTER_REPLICATION_SLOT
%token K_TIMELINE_HISTORY
%token K_WAIT
%token K_TIMELINE
%token K_PHYSICAL
%token K_LOGICAL
%token K_SLOT
%token K_RESERVE_WAL
%token K_TEMPORARY
%token K_TWO_PHASE
%token K_EXPORT_SNAPSHOT
%token K_NOEXPORT_SNAPSHOT
%token K_USE_SNAPSHOT
%token K_UPLOAD_MANIFEST

%type <node>	command
%type <node>	base_backup start_replication start_logical_replication
				create_replication_slot drop_replication_slot
				alter_replication_slot identify_system read_replication_slot
				timeline_history show upload_manifest
%type <list>	generic_option_list
%type <defelt>	generic_option
%type <uintval>	opt_timeline
%type <list>	plugin_options plugin_opt_list
%type <defelt>	plugin_opt_elem
%type <node>	plugin_opt_arg
%type <str>		opt_slot var_name ident_or_keyword
%type <boolval>	opt_temporary
%type <list>	create_slot_options create_slot_legacy_opt_list
%type <defelt>	create_slot_legacy_opt

%%

firstcmd: command opt_semicolon
				{
					*replication_parse_result_p = $1;

					(void) yynerrs; /* suppress compiler warning */
				}
			;

opt_semicolon:	';'
				| /* EMPTY */
				;

command:
			identify_system
			| base_backup
			| start_replication
			| start_logical_replication
			| create_replication_slot
			| drop_replication_slot
			| alter_replication_slot
			| read_replication_slot
			| timeline_history
			| show
			| upload_manifest
			;

/*
 * IDENTIFY_SYSTEM
 */
identify_system:
			K_IDENTIFY_SYSTEM
				{
					$$ = (Node *) makeNode(IdentifySystemCmd);
				}
			;

/*
 * READ_REPLICATION_SLOT %s
 */
read_replication_slot:
			K_READ_REPLICATION_SLOT var_name
				{
					ReadReplicationSlotCmd *n = makeNode(ReadReplicationSlotCmd);
					n->slotname = $2;
					$$ = (Node *) n;
				}
			;

/*
 * SHOW setting
 */
show:
			K_SHOW var_name
				{
					VariableShowStmt *n = makeNode(VariableShowStmt);
					n->name = $2;
					$$ = (Node *) n;
				}

var_name:	IDENT	{ $$ = $1; }
			| var_name '.' IDENT
				{ $$ = psprintf("%s.%s", $1, $3); }
		;

/*
 * BASE_BACKUP [ ( option [ 'value' ] [, ...] ) ]
 */
base_backup:
			K_BASE_BACKUP '(' generic_option_list ')'
				{
					BaseBackupCmd *cmd = makeNode(BaseBackupCmd);
					cmd->options = $3;
					$$ = (Node *) cmd;
				}
			| K_BASE_BACKUP
				{
					BaseBackupCmd *cmd = makeNode(BaseBackupCmd);
					$$ = (Node *) cmd;
				}
			;

create_replication_slot:
			/* CREATE_REPLICATION_SLOT slot [TEMPORARY] PHYSICAL [options] */
			K_CREATE_REPLICATION_SLOT IDENT opt_temporary K_PHYSICAL create_slot_options
				{
					CreateReplicationSlotCmd *cmd;
					cmd = makeNode(CreateReplicationSlotCmd);
					cmd->kind = REPLICATION_KIND_PHYSICAL;
					cmd->slotname = $2;
					cmd->temporary = $3;
					cmd->options = $5;
					$$ = (Node *) cmd;
				}
			/* CREATE_REPLICATION_SLOT slot [TEMPORARY] LOGICAL plugin [options] */
			| K_CREATE_REPLICATION_SLOT IDENT opt_temporary K_LOGICAL IDENT create_slot_options
				{
					CreateReplicationSlotCmd *cmd;
					cmd = makeNode(CreateReplicationSlotCmd);
					cmd->kind = REPLICATION_KIND_LOGICAL;
					cmd->slotname = $2;
					cmd->temporary = $3;
					cmd->plugin = $5;
					cmd->options = $6;
					$$ = (Node *) cmd;
				}
			;

create_slot_options:
			'(' generic_option_list ')'			{ $$ = $2; }
			| create_slot_legacy_opt_list		{ $$ = $1; }
			;

create_slot_legacy_opt_list:
			create_slot_legacy_opt_list create_slot_legacy_opt
				{ $$ = lappend($1, $2); }
			| /* EMPTY */
				{ $$ = NIL; }
			;

create_slot_legacy_opt:
			K_EXPORT_SNAPSHOT
				{
				  $$ = makeDefElem("snapshot",
								   (Node *) makeString("export"), -1);
				}
			| K_NOEXPORT_SNAPSHOT
				{
				  $$ = makeDefElem("snapshot",
								   (Node *) makeString("nothing"), -1);
				}
			| K_USE_SNAPSHOT
				{
				  $$ = makeDefElem("snapshot",
								   (Node *) makeString("use"), -1);
				}
			| K_RESERVE_WAL
				{
				  $$ = makeDefElem("reserve_wal",
								   (Node *) makeBoolean(true), -1);
				}
			| K_TWO_PHASE
				{
				  $$ = makeDefElem("two_phase",
								   (Node *) makeBoolean(true), -1);
				}
			;

/* DROP_REPLICATION_SLOT slot */
drop_replication_slot:
			K_DROP_REPLICATION_SLOT IDENT
				{
					DropReplicationSlotCmd *cmd;
					cmd = makeNode(DropReplicationSlotCmd);
					cmd->slotname = $2;
					cmd->wait = false;
					$$ = (Node *) cmd;
				}
			| K_DROP_REPLICATION_SLOT IDENT K_WAIT
				{
					DropReplicationSlotCmd *cmd;
					cmd = makeNode(DropReplicationSlotCmd);
					cmd->slotname = $2;
					cmd->wait = true;
					$$ = (Node *) cmd;
				}
			;

/* ALTER_REPLICATION_SLOT slot (options) */
alter_replication_slot:
			K_ALTER_REPLICATION_SLOT IDENT '(' generic_option_list ')'
				{
					AlterReplicationSlotCmd *cmd;
					cmd = makeNode(AlterReplicationSlotCmd);
					cmd->slotname = $2;
					cmd->options = $4;
					$$ = (Node *) cmd;
				}
			;

/*
 * START_REPLICATION [SLOT slot] [PHYSICAL] %X/%X [TIMELINE %u]
 */
start_replication:
			K_START_REPLICATION opt_slot opt_physical RECPTR opt_timeline
				{
					StartReplicationCmd *cmd;

					cmd = makeNode(StartReplicationCmd);
					cmd->kind = REPLICATION_KIND_PHYSICAL;
					cmd->slotname = $2;
					cmd->startpoint = $4;
					cmd->timeline = $5;
					$$ = (Node *) cmd;
				}
			;

/* START_REPLICATION SLOT slot LOGICAL %X/%X options */
start_logical_replication:
			K_START_REPLICATION K_SLOT IDENT K_LOGICAL RECPTR plugin_options
				{
					StartReplicationCmd *cmd;
					cmd = makeNode(StartReplicationCmd);
					cmd->kind = REPLICATION_KIND_LOGICAL;
					cmd->slotname = $3;
					cmd->startpoint = $5;
					cmd->options = $6;
					$$ = (Node *) cmd;
				}
			;
/*
 * TIMELINE_HISTORY %u
 */
timeline_history:
			K_TIMELINE_HISTORY UCONST
				{
					TimeLineHistoryCmd *cmd;

					if ($2 <= 0)
						ereport(ERROR,
								(errcode(ERRCODE_SYNTAX_ERROR),
								 errmsg("invalid timeline %u", $2)));

					cmd = makeNode(TimeLineHistoryCmd);
					cmd->timeline = $2;

					$$ = (Node *) cmd;
				}
			;

/* UPLOAD_MANIFEST doesn't currently accept any arguments */
upload_manifest:
			K_UPLOAD_MANIFEST
				{
					UploadManifestCmd *cmd = makeNode(UploadManifestCmd);

					$$ = (Node *) cmd;
				}

opt_physical:
			K_PHYSICAL
			| /* EMPTY */
			;

opt_temporary:
			K_TEMPORARY						{ $$ = true; }
			| /* EMPTY */					{ $$ = false; }
			;

opt_slot:
			K_SLOT IDENT
				{ $$ = $2; }
			| /* EMPTY */
				{ $$ = NULL; }
			;

opt_timeline:
			K_TIMELINE UCONST
				{
					if ($2 <= 0)
						ereport(ERROR,
								(errcode(ERRCODE_SYNTAX_ERROR),
								 errmsg("invalid timeline %u", $2)));
					$$ = $2;
				}
				| /* EMPTY */			{ $$ = 0; }
			;


plugin_options:
			'(' plugin_opt_list ')'			{ $$ = $2; }
			| /* EMPTY */					{ $$ = NIL; }
		;

plugin_opt_list:
			plugin_opt_elem
				{
					$$ = list_make1($1);
				}
			| plugin_opt_list ',' plugin_opt_elem
				{
					$$ = lappend($1, $3);
				}
		;

plugin_opt_elem:
			IDENT plugin_opt_arg
				{
					$$ = makeDefElem($1, $2, -1);
				}
		;

plugin_opt_arg:
			SCONST							{ $$ = (Node *) makeString($1); }
			| /* EMPTY */					{ $$ = NULL; }
		;

generic_option_list:
			generic_option_list ',' generic_option
				{ $$ = lappend($1, $3); }
			| generic_option
				{ $$ = list_make1($1); }
			;

generic_option:
			ident_or_keyword
				{
					$$ = makeDefElem($1, NULL, -1);
				}
			| ident_or_keyword IDENT
				{
					$$ = makeDefElem($1, (Node *) makeString($2), -1);
				}
			| ident_or_keyword SCONST
				{
					$$ = makeDefElem($1, (Node *) makeString($2), -1);
				}
			| ident_or_keyword UCONST
				{
					$$ = makeDefElem($1, (Node *) makeInteger($2), -1);
				}
			;

ident_or_keyword:
			IDENT							{ $$ = $1; }
			| K_BASE_BACKUP					{ $$ = "base_backup"; }
			| K_IDENTIFY_SYSTEM				{ $$ = "identify_system"; }
			| K_SHOW						{ $$ = "show"; }
			| K_START_REPLICATION			{ $$ = "start_replication"; }
			| K_CREATE_REPLICATION_SLOT	{ $$ = "create_replication_slot"; }
			| K_DROP_REPLICATION_SLOT		{ $$ = "drop_replication_slot"; }
			| K_ALTER_REPLICATION_SLOT		{ $$ = "alter_replication_slot"; }
			| K_TIMELINE_HISTORY			{ $$ = "timeline_history"; }
			| K_WAIT						{ $$ = "wait"; }
			| K_TIMELINE					{ $$ = "timeline"; }
			| K_PHYSICAL					{ $$ = "physical"; }
			| K_LOGICAL						{ $$ = "logical"; }
			| K_SLOT						{ $$ = "slot"; }
			| K_RESERVE_WAL					{ $$ = "reserve_wal"; }
			| K_TEMPORARY					{ $$ = "temporary"; }
			| K_TWO_PHASE					{ $$ = "two_phase"; }
			| K_EXPORT_SNAPSHOT				{ $$ = "export_snapshot"; }
			| K_NOEXPORT_SNAPSHOT			{ $$ = "noexport_snapshot"; }
			| K_USE_SNAPSHOT				{ $$ = "use_snapshot"; }
			| K_UPLOAD_MANIFEST				{ $$ = "upload_manifest"; }
		;

%%