MySQL 8.3.0
Source Code Documentation
sql_lexer_input_stream.h
Go to the documentation of this file.
1/*
2 Copyright (c) 2022, 2023, Oracle and/or its affiliates.
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License, version 2.0,
6 as published by the Free Software Foundation.
7
8 This program is also distributed with certain software (including
9 but not limited to OpenSSL) that is licensed under separate terms,
10 as designated in a particular file or component or in included license
11 documentation. The authors of MySQL hereby grant you an additional
12 permission to link the program and your derivative works with the
13 separately licensed software that they have included with MySQL.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23*/
24
25#ifndef ROUTING_SQL_LEXER_INPUT_STREAM_INCLUDED
26#define ROUTING_SQL_LEXER_INPUT_STREAM_INCLUDED
27
28#include <cassert>
29#include <cstddef>
30#include <cstring> // memcpy
31
32#include "lex_string.h" // LEX_STRING
33#include "my_inttypes.h" // uchar, uint, ...
34#include "mysql/strings/m_ctype.h" // my_charset_...
35#include "sql/lexer_yystype.h"
37#include "strings/sql_chars.h" // my_lex_states
38
39#include "sql_lexer_error.h" // warn_on_...
40
41class THD;
42
43/**
44 The state of the lexical parser, when parsing comments.
45 */
47 /**
48 Not parsing comments.
49 */
51
52 /**
53 Parsing comments that need to be preserved.
54 (Copy '/' '*' and '*' '/' sequences to the preprocessed buffer.)
55 Typically, these are user comments '/' '*' ... '*' '/'.
56 */
58
59 /**
60 Parsing comments that need to be discarded.
61 (Don't copy '/' '*' '!' and '*' '/' sequences to the preprocessed buffer.)
62 Typically, these are special comments '/' '*' '!' ... '*' '/',
63 or '/' '*' '!' 'M' 'M' 'm' 'm' 'm' ... '*' '/', where the comment
64 markers should not be expanded.
65 */
67};
68
70 public:
71 /**
72 Constructor
73
74 @param grammar_selector_token_arg See grammar_selector_token.
75 */
76
77 explicit Lex_input_stream(uint grammar_selector_token_arg)
78 : grammar_selector_token(grammar_selector_token_arg) {}
79
80 /**
81 Object initializer. Must be called before usage.
82
83 @retval false OK
84 @retval true Error
85 */
86 bool init(THD *thd, const char *buff, size_t length);
87
88 void reset(const char *buff, size_t length);
89
90 /**
91 Set the echo mode.
92
93 When echo is true, characters parsed from the raw input stream are
94 preserved. When false, characters parsed are silently ignored.
95 @param echo the echo mode.
96 */
97 void set_echo(bool echo) { m_echo = echo; }
98
102 }
103
107 }
108
109 /**
110 Skip binary from the input stream.
111 @param n number of bytes to accept.
112 */
113 void skip_binary(int n) {
114 assert(m_ptr + n <= m_end_of_query);
115 if (m_echo) {
116 memcpy(m_cpp_ptr, m_ptr, n);
117 m_cpp_ptr += n;
118 }
119 m_ptr += n;
120 }
121
122 /**
123 Get a character, and advance in the stream.
124 @return the next character to parse.
125 */
126 unsigned char yyGet() {
127 assert(m_ptr <= m_end_of_query);
128 char c = *m_ptr++;
129 if (m_echo) *m_cpp_ptr++ = c;
130 return c;
131 }
132
133 /**
134 Get the last character accepted.
135 @return the last character accepted.
136 */
137 unsigned char yyGetLast() const { return m_ptr[-1]; }
138
139 /**
140 Look at the next character to parse, but do not accept it.
141 */
142 unsigned char yyPeek() const {
143 assert(m_ptr <= m_end_of_query);
144 return m_ptr[0];
145 }
146
147 /**
148 Look ahead at some character to parse.
149 @param n offset of the character to look up
150 */
151 unsigned char yyPeekn(int n) const {
152 assert(m_ptr + n <= m_end_of_query);
153 return m_ptr[n];
154 }
155
156 /**
157 Cancel the effect of the last yyGet() or yySkip().
158 Note that the echo mode should not change between calls to yyGet / yySkip
159 and yyUnget. The caller is responsible for ensuring that.
160 */
161 void yyUnget() {
162 m_ptr--;
163 if (m_echo) m_cpp_ptr--;
164 }
165
166 /**
167 Accept a character, by advancing the input stream.
168 */
169 void yySkip() {
170 assert(m_ptr <= m_end_of_query);
171 if (m_echo)
172 *m_cpp_ptr++ = *m_ptr++;
173 else
174 m_ptr++;
175 }
176
177 /**
178 Accept multiple characters at once.
179 @param n the number of characters to accept.
180 */
181 void yySkipn(int n) {
182 assert(m_ptr + n <= m_end_of_query);
183 if (m_echo) {
184 memcpy(m_cpp_ptr, m_ptr, n);
185 m_cpp_ptr += n;
186 }
187 m_ptr += n;
188 }
189
190 /**
191 Puts a character back into the stream, canceling
192 the effect of the last yyGet() or yySkip().
193 Note that the echo mode should not change between calls
194 to unput, get, or skip from the stream.
195 */
196 char *yyUnput(char ch) {
197 *--m_ptr = ch;
198 if (m_echo) m_cpp_ptr--;
199 return m_ptr;
200 }
201
202 /**
203 Inject a character into the pre-processed stream.
204
205 Note, this function is used to inject a space instead of multi-character
206 C-comment. Thus there is no boundary checks here (basically, we replace
207 N-chars by 1-char here).
208 */
209 char *cpp_inject(char ch) {
210 *m_cpp_ptr = ch;
211 return ++m_cpp_ptr;
212 }
213
214 /**
215 End of file indicator for the query text to parse.
216 @return true if there are no more characters to parse
217 */
218 bool eof() const { return (m_ptr >= m_end_of_query); }
219
220 /**
221 End of file indicator for the query text to parse.
222 @param n number of characters expected
223 @return true if there are less than n characters to parse
224 */
225 bool eof(int n) const { return ((m_ptr + n) >= m_end_of_query); }
226
227 /** Get the raw query buffer. */
228 const char *get_buf() const { return m_buf; }
229
230 /** Get the pre-processed query buffer. */
231 const char *get_cpp_buf() const { return m_cpp_buf; }
232
233 /** Get the end of the raw query buffer. */
234 const char *get_end_of_query() const { return m_end_of_query; }
235
236 /** Mark the stream position as the start of a new token. */
237 void start_token() {
240
243 }
244
245 /**
246 Adjust the starting position of the current token.
247 This is used to compensate for starting whitespace.
248 */
252 }
253
254 /** Get the token start position, in the raw buffer. */
255 const char *get_tok_start() const { return m_tok_start; }
256
257 /** Get the token start position, in the pre-processed buffer. */
258 const char *get_cpp_tok_start() const { return m_cpp_tok_start; }
259
260 /** Get the token end position, in the raw buffer. */
261 const char *get_tok_end() const { return m_tok_end; }
262
263 /** Get the token end position, in the pre-processed buffer. */
264 const char *get_cpp_tok_end() const { return m_cpp_tok_end; }
265
266 /** Get the current stream pointer, in the raw buffer. */
267 const char *get_ptr() const { return m_ptr; }
268
269 /** Get the current stream pointer, in the pre-processed buffer. */
270 const char *get_cpp_ptr() const { return m_cpp_ptr; }
271
272 /** Get the length of the current token, in the raw buffer. */
273 uint yyLength() const {
274 /*
275 The assumption is that the lexical analyser is always 1 character ahead,
276 which the -1 account for.
277 */
278 assert(m_ptr > m_tok_start);
279 return (uint)((m_ptr - m_tok_start) - 1);
280 }
281
282 /** Get the utf8-body string. */
283 const char *get_body_utf8_str() const { return m_body_utf8; }
284
285 /** Get the utf8-body length. */
286 uint get_body_utf8_length() const {
287 return (uint)(m_body_utf8_ptr - m_body_utf8);
288 }
289
290 void body_utf8_start(THD *thd, const char *begin_ptr);
291 void body_utf8_append(const char *ptr);
292 void body_utf8_append(const char *ptr, const char *end_ptr);
293 void body_utf8_append_literal(THD *thd, const LEX_STRING *txt,
294 const CHARSET_INFO *txt_cs,
295 const char *end_ptr);
296
297 uint get_lineno(const char *raw_ptr) const;
298
299 /** Current thread. */
301
302 /** Current line number. */
304
305 /** Length of the last token parsed. */
307
308 /** Interface with bison, value of the last token parsed. */
310
311 /**
312 LALR(2) resolution, look ahead token.
313 Value of the next token to return, if any,
314 or -1, if no token was parsed in advance.
315 Note: 0 is a legal token, and represents YYEOF.
316 */
318
319 /** LALR(2) resolution, value of the look ahead token.*/
321
322 /// Skip adding of the current token's digest since it is already added
323 ///
324 /// Usually we calculate a digest token by token at the top-level function
325 /// of the lexer: MYSQLlex(). However, some complex ("hintable") tokens break
326 /// that data flow: for example, the `SELECT /*+ HINT(t) */` is the single
327 /// token from the main parser's point of view, and we add the "SELECT"
328 /// keyword to the digest buffer right after the lex_one_token() call,
329 /// but the "/*+ HINT(t) */" is a sequence of separate tokens from the hint
330 /// parser's point of view, and we add those tokens to the digest buffer
331 /// *inside* the lex_one_token() call. Thus, the usual data flow adds
332 /// tokens from the "/*+ HINT(t) */" string first, and only than it appends
333 /// the "SELECT" keyword token to that stream: "/*+ HINT(t) */ SELECT".
334 /// This is not acceptable, since we use the digest buffer to restore
335 /// query strings in their normalized forms, so the order of added tokens is
336 /// important. Thus, we add tokens of "hintable" keywords to a digest buffer
337 /// right in the hint parser and skip adding of them at the caller with the
338 /// help of skip_digest flag.
340
341 void add_digest_token(uint token, Lexer_yystype *yylval);
342
343 void reduce_digest_token(uint token_left, uint token_right);
344
345 /**
346 True if this scanner tokenizes a partial query (partition expression,
347 generated column expression etc.)
348
349 @return true if parsing a partial query, otherwise false.
350 */
351 bool is_partial_parser() const { return grammar_selector_token >= 0; }
352
353 /**
354 Outputs warnings on deprecated charsets in complete SQL statements
355
356 @param [in] cs The character set/collation to check for a deprecation.
357 @param [in] alias The name/alias of @p cs.
358 */
360 const char *alias) const {
361 if (!is_partial_parser()) {
363 }
364 }
365
366 /**
367 Outputs warnings on deprecated collations in complete SQL statements
368
369 @param [in] collation The collation to check for a deprecation.
370 */
372 if (!is_partial_parser()) {
374 }
375 }
376
378
379 private:
380 /** Pointer to the current position in the raw input stream. */
381 char *m_ptr;
382
383 /** Starting position of the last token parsed, in the raw buffer. */
384 const char *m_tok_start;
385
386 /** Ending position of the previous token parsed, in the raw buffer. */
387 const char *m_tok_end;
388
389 /** End of the query text in the input stream, in the raw buffer. */
390 const char *m_end_of_query;
391
392 /** Begining of the query text in the input stream, in the raw buffer. */
393 const char *m_buf;
394
395 /** Length of the raw buffer. */
397
398 /** Echo the parsed stream to the pre-processed buffer. */
399 bool m_echo;
401
402 /** Pre-processed buffer. */
404
405 /** Pointer to the current position in the pre-processed input stream. */
407
408 /**
409 Starting position of the last token parsed,
410 in the pre-processed buffer.
411 */
412 const char *m_cpp_tok_start;
413
414 /**
415 Ending position of the previous token parsed,
416 in the pre-processed buffer.
417 */
418 const char *m_cpp_tok_end;
419
420 /** UTF8-body buffer created during parsing. */
422
423 /** Pointer to the current position in the UTF8-body buffer. */
425
426 /**
427 Position in the pre-processed buffer. The query from m_cpp_buf to
428 m_cpp_utf_processed_ptr is converted to UTF8-body.
429 */
431
432 public:
433 /** Current state of the lexical analyser. */
435
436 /**
437 Position of ';' in the stream, to delimit multiple queries.
438 This delimiter is in the raw buffer.
439 */
440 const char *found_semicolon;
441
442 /** Token character bitmaps, to detect 7bit strings. */
444
445 /** SQL_MODE = IGNORE_SPACE. */
447
448 /**
449 true if we're parsing a prepared statement: in this mode
450 we should allow placeholders.
451 */
453 /**
454 true if we should allow multi-statements.
455 */
457
458 /** State of the lexical analyser for comments. */
461
462 /**
463 Starting position of the TEXT_STRING or IDENT in the pre-processed
464 buffer.
465
466 NOTE: this member must be used within MYSQLlex() function only.
467 */
468 const char *m_cpp_text_start;
469
470 /**
471 Ending position of the TEXT_STRING or IDENT in the pre-processed
472 buffer.
473
474 NOTE: this member must be used within MYSQLlex() function only.
475 */
476 const char *m_cpp_text_end;
477
478 /**
479 Character set specified by the character-set-introducer.
480
481 NOTE: this member must be used within MYSQLlex() function only.
482 */
484
485 /**
486 Current statement digest instrumentation.
487 */
489
490 /**
491 The synthetic 1st token to prepend token stream with.
492
493 This token value tricks parser to simulate multiple %start-ing points.
494 Currently the grammar is aware of 4 such synthetic tokens:
495 1. GRAMMAR_SELECTOR_PART for partitioning stuff from DD,
496 2. GRAMMAR_SELECTOR_GCOL for generated column stuff from DD,
497 3. GRAMMAR_SELECTOR_EXPR for generic single expressions from DD/.frm.
498 4. GRAMMAR_SELECTOR_CTE for generic subquery expressions from CTEs.
499 5. -1 when parsing with the main grammar (no grammar selector available).
500
501 @note yylex() is expected to return the value of type int:
502 0 is for EOF and everything else for real token numbers.
503 Bison, in its turn, generates positive token numbers.
504 So, the negative grammar_selector_token means "not a token".
505 In other words, -1 is "empty value".
506 */
508
509 bool text_string_is_7bit() const { return !(tok_bitmap & 0x80); }
510};
511
512#endif
This class represents the character input stream consumed during lexical analysis.
Definition: sql_lexer_input_stream.h:69
void restart_token()
Adjust the starting position of the current token.
Definition: sql_lexer_input_stream.h:249
void body_utf8_start(THD *thd, const char *begin_ptr)
The operation is called from the parser in order to 1) designate the intention to have utf8 body; 1) ...
Definition: sql_lexer.cc:153
const int grammar_selector_token
The synthetic 1st token to prepend token stream with.
Definition: sql_lexer_input_stream.h:507
void skip_binary(int n)
Skip binary from the input stream.
Definition: sql_lexer_input_stream.h:113
bool skip_digest
Skip adding of the current token's digest since it is already added.
Definition: sql_lexer_input_stream.h:339
const char * m_cpp_text_end
Ending position of the TEXT_STRING or IDENT in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:476
const char * get_end_of_query() const
Get the end of the raw query buffer.
Definition: sql_lexer_input_stream.h:234
sql_digest_state * m_digest
Current statement digest instrumentation.
Definition: sql_lexer_input_stream.h:488
const char * get_cpp_tok_start() const
Get the token start position, in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:258
void body_utf8_append(const char *ptr)
The operation appends unprocessed part of the pre-processed buffer till the given pointer (ptr) and s...
Definition: sql_lexer.cc:214
char * m_cpp_ptr
Pointer to the current position in the pre-processed input stream.
Definition: sql_lexer_input_stream.h:406
uchar tok_bitmap
Token character bitmaps, to detect 7bit strings.
Definition: sql_lexer_input_stream.h:443
void restore_in_comment_state()
Definition: sql_lexer_input_stream.h:104
THD * m_thd
Current thread.
Definition: sql_lexer_input_stream.h:300
const char * get_tok_start() const
Get the token start position, in the raw buffer.
Definition: sql_lexer_input_stream.h:255
const CHARSET_INFO * query_charset
Definition: sql_lexer_input_stream.h:377
const char * get_buf() const
Get the raw query buffer.
Definition: sql_lexer_input_stream.h:228
bool multi_statements
true if we should allow multi-statements.
Definition: sql_lexer_input_stream.h:456
char * yyUnput(char ch)
Puts a character back into the stream, canceling the effect of the last yyGet() or yySkip().
Definition: sql_lexer_input_stream.h:196
uint get_body_utf8_length() const
Get the utf8-body length.
Definition: sql_lexer_input_stream.h:286
bool m_echo_saved
Definition: sql_lexer_input_stream.h:400
const char * m_cpp_tok_end
Ending position of the previous token parsed, in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:418
char * cpp_inject(char ch)
Inject a character into the pre-processed stream.
Definition: sql_lexer_input_stream.h:209
const char * found_semicolon
Position of ';' in the stream, to delimit multiple queries.
Definition: sql_lexer_input_stream.h:440
void warn_on_deprecated_collation(const CHARSET_INFO *collation) const
Outputs warnings on deprecated collations in complete SQL statements.
Definition: sql_lexer_input_stream.h:371
Lexer_yystype * lookahead_yylval
LALR(2) resolution, value of the look ahead token.
Definition: sql_lexer_input_stream.h:320
bool init(THD *thd, const char *buff, size_t length)
Object initializer.
Definition: sql_lexer.cc:73
enum my_lex_states next_state
Current state of the lexical analyser.
Definition: sql_lexer_input_stream.h:434
const char * get_tok_end() const
Get the token end position, in the raw buffer.
Definition: sql_lexer_input_stream.h:261
uint yyLength() const
Get the length of the current token, in the raw buffer.
Definition: sql_lexer_input_stream.h:273
char * m_body_utf8
UTF8-body buffer created during parsing.
Definition: sql_lexer_input_stream.h:421
const char * get_ptr() const
Get the current stream pointer, in the raw buffer.
Definition: sql_lexer_input_stream.h:267
enum_comment_state in_comment_saved
Definition: sql_lexer_input_stream.h:460
bool eof(int n) const
End of file indicator for the query text to parse.
Definition: sql_lexer_input_stream.h:225
uint get_lineno(const char *raw_ptr) const
Definition: sql_lex.cc:1190
bool text_string_is_7bit() const
Definition: sql_lexer_input_stream.h:509
bool stmt_prepare_mode
true if we're parsing a prepared statement: in this mode we should allow placeholders.
Definition: sql_lexer_input_stream.h:452
const char * get_body_utf8_str() const
Get the utf8-body string.
Definition: sql_lexer_input_stream.h:283
void add_digest_token(uint token, Lexer_yystype *yylval)
Definition: sql_lexer.cc:258
const char * m_cpp_utf8_processed_ptr
Position in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:430
size_t m_buf_length
Length of the raw buffer.
Definition: sql_lexer_input_stream.h:396
const char * get_cpp_tok_end() const
Get the token end position, in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:264
const char * get_cpp_buf() const
Get the pre-processed query buffer.
Definition: sql_lexer_input_stream.h:231
void reduce_digest_token(uint token_left, uint token_right)
Definition: sql_lexer.cc:264
char * m_cpp_buf
Pre-processed buffer.
Definition: sql_lexer_input_stream.h:403
const char * m_cpp_text_start
Starting position of the TEXT_STRING or IDENT in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:468
const char * m_tok_start
Starting position of the last token parsed, in the raw buffer.
Definition: sql_lexer_input_stream.h:384
Lex_input_stream(uint grammar_selector_token_arg)
Constructor.
Definition: sql_lexer_input_stream.h:77
void save_in_comment_state()
Definition: sql_lexer_input_stream.h:99
unsigned char yyGet()
Get a character, and advance in the stream.
Definition: sql_lexer_input_stream.h:126
void warn_on_deprecated_charset(const CHARSET_INFO *cs, const char *alias) const
Outputs warnings on deprecated charsets in complete SQL statements.
Definition: sql_lexer_input_stream.h:359
void yySkip()
Accept a character, by advancing the input stream.
Definition: sql_lexer_input_stream.h:169
bool m_echo
Echo the parsed stream to the pre-processed buffer.
Definition: sql_lexer_input_stream.h:399
char * m_body_utf8_ptr
Pointer to the current position in the UTF8-body buffer.
Definition: sql_lexer_input_stream.h:424
uint yylineno
Current line number.
Definition: sql_lexer_input_stream.h:303
void yySkipn(int n)
Accept multiple characters at once.
Definition: sql_lexer_input_stream.h:181
enum_comment_state in_comment
State of the lexical analyser for comments.
Definition: sql_lexer_input_stream.h:459
int lookahead_token
LALR(2) resolution, look ahead token.
Definition: sql_lexer_input_stream.h:317
void body_utf8_append_literal(THD *thd, const LEX_STRING *txt, const CHARSET_INFO *txt_cs, const char *end_ptr)
The operation converts the specified text literal to the utf8 and appends the result to the utf8-body...
Definition: sql_lexer.cc:230
unsigned char yyGetLast() const
Get the last character accepted.
Definition: sql_lexer_input_stream.h:137
bool ignore_space
SQL_MODE = IGNORE_SPACE.
Definition: sql_lexer_input_stream.h:446
void set_echo(bool echo)
Set the echo mode.
Definition: sql_lexer_input_stream.h:97
Lexer_yystype * yylval
Interface with bison, value of the last token parsed.
Definition: sql_lexer_input_stream.h:309
void start_token()
Mark the stream position as the start of a new token.
Definition: sql_lexer_input_stream.h:237
void reset(const char *buff, size_t length)
Prepare Lex_input_stream instance state for use for handling next SQL statement.
Definition: sql_lexer.cc:101
void yyUnget()
Cancel the effect of the last yyGet() or yySkip().
Definition: sql_lexer_input_stream.h:161
char * m_ptr
Pointer to the current position in the raw input stream.
Definition: sql_lexer_input_stream.h:381
const char * m_end_of_query
End of the query text in the input stream, in the raw buffer.
Definition: sql_lexer_input_stream.h:390
unsigned char yyPeekn(int n) const
Look ahead at some character to parse.
Definition: sql_lexer_input_stream.h:151
unsigned char yyPeek() const
Look at the next character to parse, but do not accept it.
Definition: sql_lexer_input_stream.h:142
bool eof() const
End of file indicator for the query text to parse.
Definition: sql_lexer_input_stream.h:218
const CHARSET_INFO * m_underscore_cs
Character set specified by the character-set-introducer.
Definition: sql_lexer_input_stream.h:483
const char * m_tok_end
Ending position of the previous token parsed, in the raw buffer.
Definition: sql_lexer_input_stream.h:387
bool is_partial_parser() const
True if this scanner tokenizes a partial query (partition expression, generated column expression etc...
Definition: sql_lexer_input_stream.h:351
const char * m_buf
Begining of the query text in the input stream, in the raw buffer.
Definition: sql_lexer_input_stream.h:393
const char * m_cpp_tok_start
Starting position of the last token parsed, in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:412
uint yytoklen
Length of the last token parsed.
Definition: sql_lexer_input_stream.h:306
const char * get_cpp_ptr() const
Get the current stream pointer, in the pre-processed buffer.
Definition: sql_lexer_input_stream.h:270
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:35
@ NO_COMMENT
Not parsing comments.
Definition: sql_lexer_input_stream.h:50
@ DISCARD_COMMENT
Parsing comments that need to be discarded.
Definition: sql_lexer_input_stream.h:66
@ PRESERVE_COMMENT
Parsing comments that need to be preserved.
Definition: sql_lexer_input_stream.h:57
A better implementation of the UNIX ctype(3) library.
Some integer typedefs for easier portability.
unsigned char uchar
Definition: my_inttypes.h:51
const char * collation
Definition: audit_api_message_emit.cc:183
Definition: commit_order_queue.h:33
bool length(const dd::Spatial_reference_system *srs, const Geometry *g1, double *length, bool *null) noexcept
Computes the length of linestrings and multilinestrings.
Definition: length.cc:75
my_lex_states
Definition: sql_chars.h:36
enum_comment_state
The state of the lexical parser, when parsing comments.
Definition: sql_lexer_input_stream.h:46
Definition: m_ctype.h:422
Definition: mysql_lex_string.h:34
State data storage for digest_start, digest_add_token.
Definition: sql_digest_stream.h:35
Definition: lexer_yystype.h:32
int n
Definition: xcom_base.cc:508