Debian Codegraph @

src/backend/replication/repl_scanner.l

raw
1 %top{
2 /*-------------------------------------------------------------------------
3 *
4 * repl_scanner.l
5 * a lexical scanner for the replication commands
6 *
7 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 *
11 * IDENTIFICATION
12 * src/backend/replication/repl_scanner.l
13 *
14 *-------------------------------------------------------------------------
15 */
16 #include "postgres.h"
17
18 #include "nodes/parsenodes.h"
19 #include "utils/builtins.h"
20 #include "parser/scansup.h"
21
22 /*
23 * NB: include repl_gram.h only AFTER including walsender_private.h, because
24 * walsender_private includes headers that define XLogRecPtr.
25 */
26 #include "replication/walsender_private.h"
27 #include "repl_gram.h"
28 }
29
30 %{
31 /* Avoid exit() on fatal scanner errors (a bit ugly -- see yy_fatal_error) */
32 #undef fprintf
33 #define fprintf(file, fmt, msg) fprintf_to_ereport(fmt, msg)
34
35 static void
36 fprintf_to_ereport(const char *fmt, const char *msg)
37 {
38 ereport(ERROR, (errmsg_internal("%s", msg)));
39 }
40
41 struct replication_yy_extra_type
42 {
43 /* Pushed-back token (we only handle one) */
44 int repl_pushed_back_token;
45
46 /* Work area for collecting literals */
47 StringInfoData litbuf;
48 };
49
50 static void startlit(yyscan_t yyscanner);
51 static char *litbufdup(yyscan_t yyscanner);
52 static void addlit(char *ytext, int yleng, yyscan_t yyscanner);
53 static void addlitchar(unsigned char ychar, yyscan_t yyscanner);
54
55 /* LCOV_EXCL_START */
56
57 %}
58
59 %option reentrant
60 %option bison-bridge
61 %option 8bit
62 %option never-interactive
63 %option nodefault
64 %option noinput
65 %option nounput
66 %option noyywrap
67 %option noyyalloc
68 %option noyyrealloc
69 %option noyyfree
70 %option warn
71 %option prefix="replication_yy"
72 %option extra-type="struct replication_yy_extra_type *"
73
74 /*
75 * Exclusive states:
76 * <xd> delimited identifiers (double-quoted identifiers)
77 * <xq> standard single-quoted strings
78 */
79 %x xd
80 %x xq
81
82 space [ \t\n\r\f\v]
83
84 quote '
85 quotestop {quote}
86
87 /* Extended quote
88 * xqdouble implements embedded quote, ''''
89 */
90 xqstart {quote}
91 xqdouble {quote}{quote}
92 xqinside [^']+
93
94 /* Double quote
95 * Allows embedded spaces and other special characters into identifiers.
96 */
97 dquote \"
98 xdstart {dquote}
99 xdstop {dquote}
100 xddouble {dquote}{dquote}
101 xdinside [^"]+
102
103 digit [0-9]
104 hexdigit [0-9A-Fa-f]
105
106 ident_start [A-Za-z\200-\377_]
107 ident_cont [A-Za-z\200-\377_0-9\$]
108
109 identifier {ident_start}{ident_cont}*
110
111 %%
112
113 %{
114 /* This code is inserted at the start of replication_yylex() */
115
116 /* If we have a pushed-back token, return that. */
117 if (yyextra->repl_pushed_back_token)
118 {
119 int result = yyextra->repl_pushed_back_token;
120
121 yyextra->repl_pushed_back_token = 0;
122 return result;
123 }
124 %}
125
126 BASE_BACKUP { return K_BASE_BACKUP; }
127 IDENTIFY_SYSTEM { return K_IDENTIFY_SYSTEM; }
128 READ_REPLICATION_SLOT { return K_READ_REPLICATION_SLOT; }
129 SHOW { return K_SHOW; }
130 TIMELINE { return K_TIMELINE; }
131 START_REPLICATION { return K_START_REPLICATION; }
132 CREATE_REPLICATION_SLOT { return K_CREATE_REPLICATION_SLOT; }
133 DROP_REPLICATION_SLOT { return K_DROP_REPLICATION_SLOT; }
134 ALTER_REPLICATION_SLOT { return K_ALTER_REPLICATION_SLOT; }
135 TIMELINE_HISTORY { return K_TIMELINE_HISTORY; }
136 PHYSICAL { return K_PHYSICAL; }
137 RESERVE_WAL { return K_RESERVE_WAL; }
138 LOGICAL { return K_LOGICAL; }
139 SLOT { return K_SLOT; }
140 TEMPORARY { return K_TEMPORARY; }
141 TWO_PHASE { return K_TWO_PHASE; }
142 EXPORT_SNAPSHOT { return K_EXPORT_SNAPSHOT; }
143 NOEXPORT_SNAPSHOT { return K_NOEXPORT_SNAPSHOT; }
144 USE_SNAPSHOT { return K_USE_SNAPSHOT; }
145 WAIT { return K_WAIT; }
146 UPLOAD_MANIFEST { return K_UPLOAD_MANIFEST; }
147
148 {space}+ { /* do nothing */ }
149
150 {digit}+ {
151 yylval->uintval = strtoul(yytext, NULL, 10);
152 return UCONST;
153 }
154
155 {hexdigit}+\/{hexdigit}+ {
156 uint32 hi,
157 lo;
158 if (sscanf(yytext, "%X/%X", &hi, &lo) != 2)
159 replication_yyerror(NULL, yyscanner, "invalid streaming start location");
160 yylval->recptr = ((uint64) hi) << 32 | lo;
161 return RECPTR;
162 }
163
164 {xqstart} {
165 BEGIN(xq);
166 startlit(yyscanner);
167 }
168
169 <xq>{quotestop} {
170 yyless(1);
171 BEGIN(INITIAL);
172 yylval->str = litbufdup(yyscanner);
173 return SCONST;
174 }
175
176 <xq>{xqdouble} {
177 addlitchar('\'', yyscanner);
178 }
179
180 <xq>{xqinside} {
181 addlit(yytext, yyleng, yyscanner);
182 }
183
184 {xdstart} {
185 BEGIN(xd);
186 startlit(yyscanner);
187 }
188
189 <xd>{xdstop} {
190 int len;
191
192 yyless(1);
193 BEGIN(INITIAL);
194 yylval->str = litbufdup(yyscanner);
195 len = strlen(yylval->str);
196 truncate_identifier(yylval->str, len, true);
197 return IDENT;
198 }
199
200 <xd>{xddouble} {
201 addlitchar('"', yyscanner);
202 }
203
204 <xd>{xdinside} {
205 addlit(yytext, yyleng, yyscanner);
206 }
207
208 {identifier} {
209 int len = strlen(yytext);
210
211 yylval->str = downcase_truncate_identifier(yytext, len, true);
212 return IDENT;
213 }
214
215 . {
216 /* Any char not recognized above is returned as itself */
217 return yytext[0];
218 }
219
220 <xq,xd><<EOF>> { replication_yyerror(NULL, yyscanner, "unterminated quoted string"); }
221
222
223 <<EOF>> {
224 yyterminate();
225 }
226
227 %%
228
229 /* LCOV_EXCL_STOP */
230
231 /* see scan.l */
232 #undef yyextra
233 #define yyextra (((struct yyguts_t *) yyscanner)->yyextra_r)
234
235 static void
236 startlit(yyscan_t yyscanner)
237 {
238 initStringInfo(&yyextra->litbuf);
239 }
240
241 static char *
242 litbufdup(yyscan_t yyscanner)
243 {
244 return yyextra->litbuf.data;
245 }
246
247 static void
248 addlit(char *ytext, int yleng, yyscan_t yyscanner)
249 {
250 appendBinaryStringInfo(&yyextra->litbuf, ytext, yleng);
251 }
252
253 static void
254 addlitchar(unsigned char ychar, yyscan_t yyscanner)
255 {
256 appendStringInfoChar(&yyextra->litbuf, ychar);
257 }
258
259 /*
260 * (The first argument is enforced by Bison to match the first argument of
261 * yyparse(), but it is not used here.)
262 */
263 void
264 replication_yyerror(Node **replication_parse_result_p, yyscan_t yyscanner, const char *message)
265 {
266 ereport(ERROR,
267 (errcode(ERRCODE_SYNTAX_ERROR),
268 errmsg_internal("%s", message)));
269 }
270
271 void
272 replication_scanner_init(const char *str, yyscan_t *yyscannerp)
273 {
274 yyscan_t yyscanner;
275 struct replication_yy_extra_type *yyext = palloc0_object(struct replication_yy_extra_type);
276
277 if (yylex_init(yyscannerp) != 0)
278 elog(ERROR, "yylex_init() failed: %m");
279
280 yyscanner = *yyscannerp;
281
282 yyset_extra(yyext, yyscanner);
283
284 yy_scan_string(str, yyscanner);
285 }
286
287 void
288 replication_scanner_finish(yyscan_t yyscanner)
289 {
290 pfree(yyextra);
291 yylex_destroy(yyscanner);
292 }
293
294 /*
295 * Check to see if the first token of a command is a WalSender keyword.
296 *
297 * To keep repl_scanner.l minimal, we don't ask it to know every construct
298 * that the core lexer knows. Therefore, we daren't lex more than the
299 * first token of a general SQL command. That will usually look like an
300 * IDENT token here, although some other cases are possible.
301 */
302 bool
303 replication_scanner_is_replication_command(yyscan_t yyscanner)
304 {
305 YYSTYPE dummy;
306 int first_token = replication_yylex(&dummy, yyscanner);
307
308 switch (first_token)
309 {
310 case K_IDENTIFY_SYSTEM:
311 case K_BASE_BACKUP:
312 case K_START_REPLICATION:
313 case K_CREATE_REPLICATION_SLOT:
314 case K_DROP_REPLICATION_SLOT:
315 case K_ALTER_REPLICATION_SLOT:
316 case K_READ_REPLICATION_SLOT:
317 case K_TIMELINE_HISTORY:
318 case K_UPLOAD_MANIFEST:
319 case K_SHOW:
320 /* Yes; push back the first token so we can parse later. */
321 yyextra->repl_pushed_back_token = first_token;
322 return true;
323 default:
324 /* Nope; we don't bother to push back the token. */
325 return false;
326 }
327 }
328
329 /*
330 * Interface functions to make flex use palloc() instead of malloc().
331 * It'd be better to make these static, but flex insists otherwise.
332 */
333
334 void *
335 yyalloc(yy_size_t size, yyscan_t yyscanner)
336 {
337 return palloc(size);
338 }
339
340 void *
341 yyrealloc(void *ptr, yy_size_t size, yyscan_t yyscanner)
342 {
343 if (ptr)
344 return repalloc(ptr, size);
345 else
346 return palloc(size);
347 }
348
349 void
350 yyfree(void *ptr, yyscan_t yyscanner)
351 {
352 if (ptr)
353 pfree(ptr);
354 }