MySQL 8.0.30
Source Code Documentation
sql_error.h
Go to the documentation of this file.
1/* Copyright (c) 2005, 2022, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23#ifndef SQL_ERROR_H
24#define SQL_ERROR_H
25
26#include <assert.h>
27#include <stdio.h>
28#include <string.h>
29#include <sys/types.h>
30
31#include "lex_string.h"
32#include "m_ctype.h"
33#include "m_string.h"
34#include "my_alloc.h"
35#include "my_compiler.h"
36
37#include "my_inttypes.h"
38#include "mysql_com.h" /* MYSQL_ERRMSG_SIZE */
39#include "sql/sql_list.h"
40#include "sql/sql_plist.h" /* I_P_List */
41#include "sql_string.h" /* String */
42
43class THD;
44class my_decimal;
45struct MYSQL_TIME;
47
48constexpr const size_t WARN_ALLOC_BLOCK_SIZE{2048};
49
50///////////////////////////////////////////////////////////////////////////
51
52/**
53 Representation of a SQL condition.
54 A SQL condition can be a completion condition (note, warning),
55 or an exception condition (error, not found).
56*/
58 public:
59 /**
60 Enumeration value describing the severity of the condition.
61 */
63
64 /**
65 Get the MESSAGE_TEXT of this condition.
66 @return the message text.
67 */
68 const char *message_text() const { return m_message_text.ptr(); }
69
70 /**
71 Get the MESSAGE_OCTET_LENGTH of this condition.
72 @return the length in bytes of the message text.
73 */
74 size_t message_octet_length() const { return m_message_text.length(); }
75
76 /**
77 Get the RETURNED_SQLSTATE of this condition.
78 @return the sql state.
79 */
80 const char *returned_sqlstate() const { return m_returned_sqlstate; }
81
82 /**
83 Get the MYSQL_ERRNO of this condition.
84 @return the sql error number condition item.
85 */
86 uint mysql_errno() const { return m_mysql_errno; }
87
88 /**
89 Get the severity level of this condition.
90 @return the severity level condition item.
91 */
93 return m_severity_level;
94 }
95
96 private:
97 /*
98 The interface of Sql_condition is mostly private, by design,
99 so that only the following code:
100 - various raise_error() or raise_warning() methods in class THD,
101 - the implementation of SIGNAL / RESIGNAL / GET DIAGNOSTICS
102 - catch / re-throw of SQL conditions in stored procedures (sp_rcontext)
103 is allowed to create / modify a SQL condition.
104 Enforcing this policy prevents confusion, since the only public
105 interface available to the rest of the server implementation
106 is the interface offered by the THD methods (THD::raise_error()),
107 which should be used.
108 */
109 friend class THD;
110 friend class Diagnostics_area;
112 friend class Sql_cmd_signal;
113 friend class Sql_cmd_resignal;
114 friend class sp_rcontext;
116
117 /**
118 Constructor.
119
120 @param mem_root Memory root to use for the condition items
121 of this condition.
122 */
124
125 /**
126 Constructor.
127
128 @param mem_root Memory root to use for the condition items
129 of this condition.
130 @param mysql_errno MYSQL_ERRNO
131 @param returned_sqlstate RETURNED_SQLSTATE
132 @param severity Severity level - error, warning or note.
133 @param message_text MESSAGE_TEXT
134 */
136 const char *returned_sqlstate,
138 const char *message_text);
139
140 /** Destructor. */
141 ~Sql_condition() = default;
142
143 /**
144 Copy optional condition items attributes.
145 @param cond the condition to copy.
146 */
147 void copy_opt_attributes(const Sql_condition *cond);
148
149 /**
150 Set the condition message test.
151 @param message_text Message text, expressed in the character set derived
152 from the server --language option
153 */
154 void set_message_text(const char *message_text);
155
156 /** Set the RETURNED_SQLSTATE of this condition. */
157 void set_returned_sqlstate(const char *sqlstate) {
158 memcpy(m_returned_sqlstate, sqlstate, SQLSTATE_LENGTH);
160 }
161
162 /** Set the CLASS_ORIGIN and SUBCLASS_ORIGIN of this condition. */
163 void set_class_origins();
164
165 private:
166 /** SQL CLASS_ORIGIN condition item. */
168
169 /** SQL SUBCLASS_ORIGIN condition item. */
171
172 /** SQL CONSTRAINT_CATALOG condition item. */
174
175 /** SQL CONSTRAINT_SCHEMA condition item. */
177
178 /** SQL CONSTRAINT_NAME condition item. */
180
181 /** SQL CATALOG_NAME condition item. */
183
184 /** SQL SCHEMA_NAME condition item. */
186
187 /** SQL TABLE_NAME condition item. */
189
190 /** SQL COLUMN_NAME condition item. */
192
193 /** SQL CURSOR_NAME condition item. */
195
196 /** Message text, expressed in the character set implied by --language. */
198
199 /** MySQL extension, MYSQL_ERRNO condition item. */
201
202 /**
203 SQL RETURNED_SQLSTATE condition item.
204 This member is always NUL terminated.
205 */
207
208 /** Severity (error, warning, note) of this condition. */
210
211 /** Pointers for participating in the list of conditions. */
214
215 /** Memory root to use to hold condition item values. */
217};
218
219///////////////////////////////////////////////////////////////////////////
220
221size_t err_conv(char *buff, size_t to_length, const char *from,
222 size_t from_length, const CHARSET_INFO *from_cs);
223
227
228 public:
229 explicit ErrConvString(const String *str) {
230 buf_length = err_conv(err_buffer, sizeof(err_buffer), str->ptr(),
231 str->length(), str->charset());
232 }
233
234 ErrConvString(const char *str, size_t length) {
237 }
238
239 ErrConvString(const char *str, size_t length, const CHARSET_INFO *cs) {
241 }
242
244 buf_length = snprintf(err_buffer, sizeof(err_buffer), "%lld", nr);
245 }
246
247 ErrConvString(longlong nr, bool unsigned_flag) {
248 buf_length = longlong10_to_str(nr, err_buffer, unsigned_flag ? 10 : -10) -
250 }
251
252 ErrConvString(double nr);
253 ErrConvString(const my_decimal *nr);
254 ErrConvString(const MYSQL_TIME *ltime, uint dec);
255
256 const char *ptr() const { return err_buffer; }
257 size_t length() const { return buf_length; }
258};
259
260///////////////////////////////////////////////////////////////////////////
261
262/**
263 Stores status of the currently executed statement.
264 Cleared at the beginning of the statement, and then
265 can hold either OK, ERROR, or EOF status.
266 Can not be assigned twice per statement.
267*/
269 /** The type of the counted and doubly linked list of conditions. */
270 typedef I_P_List<
276
277 public:
278 /** Const iterator used to iterate through the condition list. */
280
282 /** The area is cleared at start of a statement. */
284 /** Set whenever one calls my_ok(). */
286 /** Set whenever one calls my_eof(). */
288 /** Set whenever one calls my_error() or my_message(). */
290 /** Set in case of a custom response, such as one from COM_STMT_PREPARE. */
292 };
293
294 Diagnostics_area(bool allow_unlimited_conditions);
296
297 void set_overwrite_status(bool can_overwrite_status) {
298 m_can_overwrite_status = can_overwrite_status;
299 }
300
301 bool is_sent() const { return m_is_sent; }
302
304
305 /**
306 Set OK status -- ends commands that do not return a
307 result set, e.g. INSERT/UPDATE/DELETE.
308
309 @param affected_rows The number of rows affected by the last statement.
310 @sa Diagnostics_area::m_affected_rows.
311 @param last_insert_id The value to be returned by LAST_INSERT_ID().
312 @sa Diagnostics_area::m_last_insert_id.
313 @param message_text The OK-message text.
314 */
316 const char *message_text);
317
318 /**
319 Set EOF status.
320
321 @param thd Thread context.
322 */
323 void set_eof_status(THD *thd);
324
325 /**
326 Set ERROR status in the Diagnostics Area. This function should be used to
327 report fatal errors (such as out-of-memory errors) when no further
328 processing is possible.
329
330 @param thd Thread handle
331 @param mysql_errno SQL-condition error number
332 */
334
335 /**
336 Set ERROR status in the Diagnostics Area.
337
338 @param mysql_errno SQL-condition error number
339 @param message_text SQL-condition message
340 @param returned_sqlstate SQL-condition state
341 */
343 const char *returned_sqlstate);
344
345 /**
346 Mark the Diagnostics Area as 'DISABLED'.
347
348 This is used in rare cases when the COM_ command at hand sends a response
349 in a custom format. One example is COM_STMT_PREPARE.
350 */
352 assert(m_status == DA_EMPTY);
354 }
355
356 /**
357 Clear this Diagnostics Area.
358
359 Normally called at the end of a statement.
360 */
362
363 bool is_set() const { return m_status != DA_EMPTY; }
364
365 bool is_error() const { return m_status == DA_ERROR; }
366
367 bool is_eof() const { return m_status == DA_EOF; }
368
369 bool is_ok() const { return m_status == DA_OK; }
370
371 bool is_disabled() const { return m_status == DA_DISABLED; }
372
374
375 const char *message_text() const {
376 assert(m_status == DA_ERROR || m_status == DA_OK);
377 return m_message_text;
378 }
379
381 assert(m_status == DA_ERROR);
382 return m_mysql_errno;
383 }
384
385 const char *returned_sqlstate() const {
386 assert(m_status == DA_ERROR);
387 return m_returned_sqlstate;
388 }
389
391 assert(m_status == DA_OK);
392 return m_affected_rows;
393 }
394
396 assert(m_status == DA_OK);
397 return m_last_insert_id;
398 }
399
401 assert(m_status == DA_OK || m_status == DA_EOF);
403 }
404
405 /** Return the number of conditions raised by the current statement. */
408 }
409
410 /**
411 Reset between two COM_ commands. Conditions are preserved
412 between commands, but m_current_statement_cond_count indicates
413 the number of conditions of this particular statement only.
414 */
416
417 /**
418 Checks if the condition list contains SQL-condition with the given message.
419
420 @param message_text Message text
421 @param message_length Length of message_text
422
423 @return true if the condition list contains an SQL-condition with the given
424 message text.
425 */
426 bool has_sql_condition(const char *message_text, size_t message_length) const;
427
428 /**
429 Checks if the condition list contains SQL-condition with the given error
430 code.
431
432 @param sql_errno Error code
433
434 @return true if the condition list contains an SQL-condition with the given
435 error code.
436 */
437 bool has_sql_condition(uint sql_errno) const;
438
439 /**
440 Reset the current condition information stored in the Diagnostics Area.
441 Clear all conditions, the number of conditions, reset current row counter
442 to point to the first row.
443 */
444 void reset_condition_info(THD *thd);
445
446 /** Return the current counter value. */
449 }
450
451 /** Increment the current row counter to point at the next row. */
453
454 /** Set the current row counter to point to the given row number. */
457 }
458
459 /** Reset the current row counter. Start counting from 1. */
461
462 /**
463 The number of errors, or number of rows returned by SHOW ERRORS,
464 also the value of session variable @@error_count.
465 */
466 ulong error_count(THD *thd) const;
467
468 /**
469 Used for @@warning_count system variable, which prints
470 the number of rows returned by SHOW WARNINGS.
471 */
472 ulong warn_count(THD *thd) const;
473
474 /**
475 The number of conditions (errors, warnings and notes) in the list.
476 */
478
480
481 const char *get_first_condition_message();
482
483 /** Make sure there is room for the given number of conditions. */
485
486 /**
487 Add a new SQL-condition to the current list and increment the respective
488 counters.
489
490 @param thd Thread context.
491 @param mysql_errno SQL-condition error number.
492 @param returned_sqlstate SQL-condition state.
493 @param severity SQL-condition severity.
494 @param message_text SQL-condition message.
495
496 @return a pointer to the added SQL-condition.
497 */
499 const char *returned_sqlstate,
501 const char *message_text);
502
503 /**
504 Mark current SQL-conditions so that we can later know which
505 SQL-conditions have been added.
506 */
508
509 /**
510 Copy SQL-conditions that have been added since
511 mark_preexisting_sql_conditions() was called.
512
513 @param thd Thread context.
514 @param src_da Diagnostics Area to copy from.
515 */
516 void copy_new_sql_conditions(THD *thd, const Diagnostics_area *src_da);
517
518 /**
519 Copy all SQL-conditions from src_da to this DA.
520
521 @param thd Thread context.
522 @param src_da Diagnostics Area to copy from.
523 */
524 void copy_sql_conditions_from_da(THD *thd, const Diagnostics_area *src_da);
525
526 /**
527 Copy Sql_conditions that are not SL_ERROR from the source
528 Diagnostics Area to the current Diagnostics Area.
529
530 @param thd Thread context.
531 @param src_da Diagnostics Area to copy from.
532 */
533 void copy_non_errors_from_da(THD *thd, const Diagnostics_area *src_da);
534
535 /**
536 @return SQL-condition, which corresponds to the error state in
537 Diagnostics Area.
538 */
540
541 private:
542 /**
543 Add a new SQL-condition to the current list and increment the respective
544 counters.
545
546 @param thd Thread context.
547 @param sql_condition SQL-condition to copy values from.
548
549 @return a pointer to the added SQL-condition.
550 */
551 Sql_condition *push_warning(THD *thd, const Sql_condition *sql_condition);
552
553 /**
554 Push the given Diagnostics Area on top of the stack.
555 "This" will then become the stacked Diagnostics Area.
556 Conditions present in the new stacked Diagnostics Area
557 will be copied to the new top Diagnostics Area.
558
559 @note This function will not set THD::m_stmt_da.
560 Use THD::push_diagnostics_area() instead.
561
562 @param thd Thread context
563 @param da Diagnostics Area to be come the top of
564 the Diagnostics Area stack.
565 @param copy_conditions
566 Copy the conditions from the new second Diagnostics Area
567 to the new first Diagnostics Area, as per SQL standard.
568 */
570 bool copy_conditions);
571
572 /**
573 Pop "this" off the Diagnostics Area stack.
574
575 @note This function will not set THD::m_stmt_da.
576 Use THD::pop_diagnostics_area() instead.
577
578 @returns The new top of the Diagnostics Area stack.
579 */
581
582 /**
583 Returns the Diagnostics Area below the current diagnostics
584 area on the stack.
585 */
586 const Diagnostics_area *stacked_da() const { return m_stacked_da; }
587
588 private:
589 /** Pointer to the Diagnostics Area below on the stack. */
591
592 /** A memory root to allocate conditions */
594
595 /** List of conditions of all severities. */
597
598 /** List of conditions present in DA at handler activation. */
600
601 /** True if status information is sent to the client. */
603
604 /** Set to make set_error_status after set_{ok,eof}_status possible. */
606
607 /** Indicates if push_warning() allows unlimited number of conditions. */
609
611
612 private:
613 /*
614 This section contains basic attributes of Sql_condition to store
615 information about error (SQL-condition of error severity) or OK-message.
616 The attributes are inlined here (instead of using Sql_condition) to be able
617 to store the information in case of out-of-memory error.
618 */
619
620 /**
621 Message buffer. It is used only when DA is in OK or ERROR status.
622 If DA status is ERROR, it's the MESSAGE_TEXT attribute of SQL-condition.
623 If DA status is OK, it's the OK-message to be sent.
624 */
626
627 /**
628 SQL RETURNED_SQLSTATE condition item.
629 This member is always NUL terminated.
630 */
632
633 /**
634 SQL error number. One of ER_ codes from share/errmsg.txt.
635 Set by set_error_status.
636 */
638
639 /**
640 The number of rows affected by the last statement. This is
641 semantically close to thd->row_count_func, but has a different
642 life cycle. thd->row_count_func stores the value returned by
643 function ROW_COUNT() and is cleared only by statements that
644 update its value, such as INSERT, UPDATE, DELETE and few others.
645 This member is cleared at the beginning of the next statement.
646
647 We could possibly merge the two, but life cycle of thd->row_count_func
648 can not be changed.
649 */
651
652 /**
653 Similarly to the previous member, this is a replacement of
654 thd->first_successful_insert_id_in_prev_stmt, which is used
655 to implement LAST_INSERT_ID().
656 */
658
659 /**
660 Number of conditions of this last statement. May differ from
661 the number of conditions returned by SHOW WARNINGS e.g. in case
662 the statement doesn't clear the conditions, and doesn't generate
663 them.
664 */
666
667 /**
668 The number of conditions of the current statement. m_conditions_list
669 life cycle differs from statement life cycle -- it may span
670 multiple statements. In that case we get
671 m_current_statement_cond_count 0, whereas m_conditions_list is not empty.
672 */
674
675 /** A break down of the number of conditions per severity (level). */
677
678 /**
679 Row counter, to print in errors and warnings. Not increased in
680 create_sort_index(); may differ from examined_row_count.
681 */
683
684 /** Save @@error_count before pre-clearing the DA. */
686
687 /** Save @@warning_count before pre-clearing the DA. */
689
690 friend class THD;
691};
692
693///////////////////////////////////////////////////////////////////////////
694
696 uint code, const char *message_text);
697
698/**
699 Convenience function for sending a warning with level SL_WARNING and no
700 arguments to the message.
701
702 @param thd The session to send the warning to.
703 @param code The warning number.
704*/
705void push_warning(THD *thd, uint code);
706
707/*
708 Note that this MY_ATTRIBUTE check cannot detect number/type mismatch
709 since the format string is not known at compile time.
710 It can however detect if push_warning_printf() is used without any
711 printf arguments. In such cases, use push_warning() instead.
712*/
714 uint code, const char *format, ...)
715 MY_ATTRIBUTE((format(printf, 4, 5)));
716
717/**
718 Generates a warning that a feature is deprecated.
719
720 Using it as
721 push_deprecated_warn(thd, "BAD", "'GOOD'");
722 Will result in a warning:
723 "The syntax 'BAD' is deprecated and will be removed in a
724 future release. Please use 'GOOD' instead"
725
726 If a function is deprecated, it should implement
727 Item_func::is_deprecated() to return true to prevent the
728 usage of the function in the generated column expression.
729
730 @param thd Thread context. If NULL, warning is written
731 to the error log, otherwise the warning is
732 sent to the client.
733 @param old_syntax Deprecated syntax.
734 @param new_syntax Replacement syntax.
735*/
736void push_deprecated_warn(THD *thd, const char *old_syntax,
737 const char *new_syntax);
738
739/**
740 Generates a warning that a feature is deprecated.
741
742 Using it as
743 push_deprecated_warn_no_replacement(thd, "old");
744 Will result in a warning:
745 "The syntax 'old' is deprecated and will be removed in a
746 future release.
747
748 If a function is deprecated, it should implement
749 Item_func::is_deprecated() to return true to prevent the
750 usage of the function in the generated column expression.
751
752 @param thd Thread context. If NULL, warning is written
753 to the error log, otherwise the warning is
754 sent to the client.
755 @param old_syntax Deprecated syntax.
756*/
757void push_deprecated_warn_no_replacement(THD *thd, const char *old_syntax);
758
759bool mysqld_show_warnings(THD *thd, ulong levels_to_show);
760
761size_t convert_error_message(char *to, size_t to_length,
762 const CHARSET_INFO *to_cs, const char *from,
763 size_t from_length, const CHARSET_INFO *from_cs,
764 uint *errors);
765
766extern const LEX_CSTRING warning_level_names[];
767
768bool is_sqlstate_valid(const LEX_STRING *sqlstate);
769
770/**
771 Checks if the specified SQL-state-string defines COMPLETION condition.
772 This function assumes that the given string contains a valid SQL-state.
773
774 @param s the condition SQLSTATE.
775
776 @retval true if the given string defines COMPLETION condition.
777 @retval false otherwise.
778*/
779inline bool is_sqlstate_completion(const char *s) {
780 return s[0] == '0' && s[1] == '0';
781}
782
783/**
784 Checks if the specified SQL-state-string defines WARNING condition.
785 This function assumes that the given string contains a valid SQL-state.
786
787 @param s the condition SQLSTATE.
788
789 @retval true if the given string defines WARNING condition.
790 @retval false otherwise.
791*/
792inline bool is_sqlstate_warning(const char *s) {
793 return s[0] == '0' && s[1] == '1';
794}
795
796/**
797 Checks if the specified SQL-state-string defines NOT FOUND condition.
798 This function assumes that the given string contains a valid SQL-state.
799
800 @param s the condition SQLSTATE.
801
802 @retval true if the given string defines NOT FOUND condition.
803 @retval false otherwise.
804*/
805inline bool is_sqlstate_not_found(const char *s) {
806 return s[0] == '0' && s[1] == '2';
807}
808
809/**
810 Checks if the specified SQL-state-string defines EXCEPTION condition.
811 This function assumes that the given string contains a valid SQL-state.
812
813 @param s the condition SQLSTATE.
814
815 @retval true if the given string defines EXCEPTION condition.
816 @retval false otherwise.
817*/
818inline bool is_sqlstate_exception(const char *s) {
819 return s[0] != '0' || s[1] > '2';
820}
821
823 const char *alias,
824 const char *option = nullptr);
826 const char *option = nullptr);
827
830#endif // SQL_ERROR_H
A condition information item.
Definition: sql_get_diagnostics.h:223
Stores status of the currently executed statement.
Definition: sql_error.h:268
void reserve_number_of_conditions(THD *thd, uint count)
Make sure there is room for the given number of conditions.
Definition: sql_error.cc:585
void set_error_status(THD *thd, uint mysql_errno)
Set ERROR status in the Diagnostics Area.
Definition: sql_error.cc:412
void inc_current_row_for_condition()
Increment the current row counter to point at the next row.
Definition: sql_error.h:452
Sql_condition * push_warning(THD *thd, uint mysql_errno, const char *returned_sqlstate, Sql_condition::enum_severity_level severity, const char *message_text)
Add a new SQL-condition to the current list and increment the respective counters.
Definition: sql_error.cc:592
bool is_ok() const
Definition: sql_error.h:369
ulong error_count(THD *thd) const
The number of errors, or number of rows returned by SHOW ERRORS, also the value of session variable @...
Definition: sql_error.cc:506
uint last_statement_cond_count() const
Definition: sql_error.h:400
bool is_sent() const
Definition: sql_error.h:301
ulong current_row_for_condition() const
Return the current counter value.
Definition: sql_error.h:447
void reset_condition_info(THD *thd)
Reset the current condition information stored in the Diagnostics Area.
Definition: sql_error.cc:479
ulong m_current_row_for_condition
Row counter, to print in errors and warnings.
Definition: sql_error.h:682
void set_eof_status(THD *thd)
Set EOF status.
Definition: sql_error.cc:391
const char * get_first_condition_message()
Definition: sql_error.cc:473
void disable_status()
Mark the Diagnostics Area as 'DISABLED'.
Definition: sql_error.h:351
void set_ok_status(ulonglong affected_rows, ulonglong last_insert_id, const char *message_text)
Set OK status – ends commands that do not return a result set, e.g.
Definition: sql_error.cc:370
void set_is_sent(bool is_sent)
Definition: sql_error.h:303
bool m_is_sent
True if status information is sent to the client.
Definition: sql_error.h:602
enum_diagnostics_status m_status
Definition: sql_error.h:610
void mark_preexisting_sql_conditions()
Mark current SQL-conditions so that we can later know which SQL-conditions have been added.
Definition: sql_error.cc:548
Diagnostics_area(bool allow_unlimited_conditions)
Definition: sql_error.cc:331
bool is_error() const
Definition: sql_error.h:365
Sql_condition_list::Const_Iterator Sql_condition_iterator
Const iterator used to iterate through the condition list.
Definition: sql_error.h:279
uint m_mysql_errno
SQL error number.
Definition: sql_error.h:637
MEM_ROOT m_condition_root
A memory root to allocate conditions.
Definition: sql_error.h:593
~Diagnostics_area()
Definition: sql_error.cc:352
uint m_current_statement_cond_count
The number of conditions of the current statement.
Definition: sql_error.h:673
Diagnostics_area * m_stacked_da
Pointer to the Diagnostics Area below on the stack.
Definition: sql_error.h:590
ulong current_statement_cond_count() const
Return the number of conditions raised by the current statement.
Definition: sql_error.h:406
uint m_last_statement_cond_count
Number of conditions of this last statement.
Definition: sql_error.h:665
void reset_diagnostics_area()
Clear this Diagnostics Area.
Definition: sql_error.cc:354
enum_diagnostics_status
Definition: sql_error.h:281
@ DA_OK
Set whenever one calls my_ok().
Definition: sql_error.h:285
@ DA_EMPTY
The area is cleared at start of a statement.
Definition: sql_error.h:283
@ DA_ERROR
Set whenever one calls my_error() or my_message().
Definition: sql_error.h:289
@ DA_DISABLED
Set in case of a custom response, such as one from COM_STMT_PREPARE.
Definition: sql_error.h:291
@ DA_EOF
Set whenever one calls my_eof().
Definition: sql_error.h:287
void set_current_row_for_condition(ulong rowno)
Set the current row counter to point to the given row number.
Definition: sql_error.h:455
void copy_new_sql_conditions(THD *thd, const Diagnostics_area *src_da)
Copy SQL-conditions that have been added since mark_preexisting_sql_conditions() was called.
Definition: sql_error.cc:556
ulong m_saved_warn_count
Save @warning_count before pre-clearing the DA.
Definition: sql_error.h:688
void copy_non_errors_from_da(THD *thd, const Diagnostics_area *src_da)
Copy Sql_conditions that are not SL_ERROR from the source Diagnostics Area to the current Diagnostics...
Definition: sql_error.cc:535
void set_overwrite_status(bool can_overwrite_status)
Definition: sql_error.h:297
List< const Sql_condition > m_preexisting_sql_conditions
List of conditions present in DA at handler activation.
Definition: sql_error.h:599
Diagnostics_area * pop_diagnostics_area()
Pop "this" off the Diagnostics Area stack.
Definition: sql_error.cc:631
enum_diagnostics_status status() const
Definition: sql_error.h:373
bool is_disabled() const
Definition: sql_error.h:371
const char * message_text() const
Definition: sql_error.h:375
bool m_allow_unlimited_conditions
Indicates if push_warning() allows unlimited number of conditions.
Definition: sql_error.h:608
I_P_List< Sql_condition, I_P_List_adapter< Sql_condition, &Sql_condition::m_next_condition, &Sql_condition::m_prev_condition >, I_P_List_counter, I_P_List_fast_push_back< Sql_condition > > Sql_condition_list
The type of the counted and doubly linked list of conditions.
Definition: sql_error.h:275
uint mysql_errno() const
Definition: sql_error.h:380
Sql_condition_list m_conditions_list
List of conditions of all severities.
Definition: sql_error.h:596
ulonglong last_insert_id() const
Definition: sql_error.h:395
Sql_condition * error_condition() const
Definition: sql_error.cc:572
uint m_current_statement_cond_count_by_qb[(uint) Sql_condition::SEVERITY_END]
A break down of the number of conditions per severity (level).
Definition: sql_error.h:676
void reset_statement_cond_count()
Reset between two COM_ commands.
Definition: sql_error.h:415
void copy_sql_conditions_from_da(THD *thd, const Diagnostics_area *src_da)
Copy all SQL-conditions from src_da to this DA.
Definition: sql_error.cc:524
uint cond_count() const
The number of conditions (errors, warnings and notes) in the list.
Definition: sql_error.h:477
const char * returned_sqlstate() const
Definition: sql_error.h:385
ulonglong affected_rows() const
Definition: sql_error.h:390
void reset_current_row_for_condition()
Reset the current row counter.
Definition: sql_error.h:460
bool m_can_overwrite_status
Set to make set_error_status after set_{ok,eof}_status possible.
Definition: sql_error.h:605
char m_returned_sqlstate[SQLSTATE_LENGTH+1]
SQL RETURNED_SQLSTATE condition item.
Definition: sql_error.h:631
bool is_set() const
Definition: sql_error.h:363
Sql_condition_iterator sql_conditions() const
Definition: sql_error.h:479
ulong m_saved_error_count
Save @error_count before pre-clearing the DA.
Definition: sql_error.h:685
bool is_eof() const
Definition: sql_error.h:367
ulong warn_count(THD *thd) const
Used for @warning_count system variable, which prints the number of rows returned by SHOW WARNINGS.
Definition: sql_error.cc:512
const Diagnostics_area * stacked_da() const
Returns the Diagnostics Area below the current diagnostics area on the stack.
Definition: sql_error.h:586
void push_diagnostics_area(THD *thd, Diagnostics_area *da, bool copy_conditions)
Push the given Diagnostics Area on top of the stack.
Definition: sql_error.cc:620
char m_message_text[MYSQL_ERRMSG_SIZE]
Message buffer.
Definition: sql_error.h:625
ulonglong m_last_insert_id
Similarly to the previous member, this is a replacement of thd->first_successful_insert_id_in_prev_st...
Definition: sql_error.h:657
bool has_sql_condition(const char *message_text, size_t message_length) const
Checks if the condition list contains SQL-condition with the given message.
Definition: sql_error.cc:450
ulonglong m_affected_rows
The number of rows affected by the last statement.
Definition: sql_error.h:650
Definition: sql_error.h:224
ErrConvString(const char *str, size_t length)
Definition: sql_error.h:234
size_t length() const
Definition: sql_error.h:257
ErrConvString(const String *str)
Definition: sql_error.h:229
const char * ptr() const
Definition: sql_error.h:256
char err_buffer[MYSQL_ERRMSG_SIZE]
Definition: sql_error.h:225
ErrConvString(longlong nr)
Definition: sql_error.h:243
size_t buf_length
Definition: sql_error.h:226
ErrConvString(const char *str, size_t length, const CHARSET_INFO *cs)
Definition: sql_error.h:239
ErrConvString(longlong nr, bool unsigned_flag)
Definition: sql_error.h:247
Element counting policy class for I_P_List which provides basic element counting.
Definition: sql_plist.h:221
uint elements() const
Definition: sql_plist.h:232
An insertion policy class for I_P_List which can be used when fast push_back() operation is required.
Definition: sql_plist.h:259
Iterator for I_P_List.
Definition: sql_plist.h:167
Intrusive parameterized list.
Definition: sql_plist.h:74
Definition: sql_list.h:433
Sql_cmd_common_signal represents the common properties of the SIGNAL and RESIGNAL statements.
Definition: sql_signal.h:87
Sql_cmd_resignal represents a RESIGNAL statement.
Definition: sql_signal.h:167
Sql_cmd_signal represents a SIGNAL statement.
Definition: sql_signal.h:147
Representation of a SQL condition.
Definition: sql_error.h:57
String m_catalog_name
SQL CATALOG_NAME condition item.
Definition: sql_error.h:182
Sql_condition(MEM_ROOT *mem_root)
Constructor.
Definition: sql_error.cc:215
String m_cursor_name
SQL CURSOR_NAME condition item.
Definition: sql_error.h:194
String m_message_text
Message text, expressed in the character set implied by –language.
Definition: sql_error.h:197
void set_message_text(const char *message_text)
Set the condition message test.
Definition: sql_error.cc:276
size_t message_octet_length() const
Get the MESSAGE_OCTET_LENGTH of this condition.
Definition: sql_error.h:74
String m_schema_name
SQL SCHEMA_NAME condition item.
Definition: sql_error.h:185
String m_table_name
SQL TABLE_NAME condition item.
Definition: sql_error.h:188
String m_constraint_name
SQL CONSTRAINT_NAME condition item.
Definition: sql_error.h:179
void set_returned_sqlstate(const char *sqlstate)
Set the RETURNED_SQLSTATE of this condition.
Definition: sql_error.h:157
const char * message_text() const
Get the MESSAGE_TEXT of this condition.
Definition: sql_error.h:68
MEM_ROOT * m_mem_root
Memory root to use to hold condition item values.
Definition: sql_error.h:216
String m_class_origin
SQL CLASS_ORIGIN condition item.
Definition: sql_error.h:167
Sql_condition * m_next_condition
Pointers for participating in the list of conditions.
Definition: sql_error.h:212
String m_constraint_schema
SQL CONSTRAINT_SCHEMA condition item.
Definition: sql_error.h:176
uint mysql_errno() const
Get the MYSQL_ERRNO of this condition.
Definition: sql_error.h:86
void copy_opt_attributes(const Sql_condition *cond)
Copy optional condition items attributes.
Definition: sql_error.cc:262
enum_severity_level
Enumeration value describing the severity of the condition.
Definition: sql_error.h:62
@ SL_NOTE
Definition: sql_error.h:62
@ SL_ERROR
Definition: sql_error.h:62
@ SL_WARNING
Definition: sql_error.h:62
@ SEVERITY_END
Definition: sql_error.h:62
Sql_condition::enum_severity_level m_severity_level
Severity (error, warning, note) of this condition.
Definition: sql_error.h:209
String m_subclass_origin
SQL SUBCLASS_ORIGIN condition item.
Definition: sql_error.h:170
char m_returned_sqlstate[SQLSTATE_LENGTH+1]
SQL RETURNED_SQLSTATE condition item.
Definition: sql_error.h:206
void set_class_origins()
Set the CLASS_ORIGIN and SUBCLASS_ORIGIN of this condition.
Definition: sql_error.cc:287
Sql_condition::enum_severity_level severity() const
Get the severity level of this condition.
Definition: sql_error.h:92
~Sql_condition()=default
Destructor.
const char * returned_sqlstate() const
Get the RETURNED_SQLSTATE of this condition.
Definition: sql_error.h:80
String m_constraint_catalog
SQL CONSTRAINT_CATALOG condition item.
Definition: sql_error.h:173
uint m_mysql_errno
MySQL extension, MYSQL_ERRNO condition item.
Definition: sql_error.h:200
String m_column_name
SQL COLUMN_NAME condition item.
Definition: sql_error.h:191
Sql_condition ** m_prev_condition
Definition: sql_error.h:213
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:166
const char * ptr() const
Definition: sql_string.h:248
size_t length() const
Definition: sql_string.h:240
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_class.h:922
my_decimal class limits 'decimal_t' type to what we need in MySQL.
Definition: my_decimal.h:93
Definition: sp_rcontext.h:76
static MEM_ROOT mem_root
Definition: client_plugin.cc:109
static const std::string dec("DECRYPTION")
static constexpr unsigned PSI_INSTRUMENT_ME
Definition: psi_bits.h:42
A better implementation of the UNIX ctype(3) library.
MYSQL_PLUGIN_IMPORT CHARSET_INFO my_charset_latin1
Definition: ctype-latin1.cc:367
char * longlong10_to_str(int64_t val, char *dst, int radix)
Converts a 64-bit integer to its string representation in decimal notation.
Definition: int2str.cc:100
This file follows Google coding style, except for the name MEM_ROOT (which is kept for historical rea...
Header for compiler-dependent features.
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
long long int longlong
Definition: my_inttypes.h:54
static int count
Definition: myisam_ftdump.cc:42
Common definition between mysql server & client.
#define MYSQL_ERRMSG_SIZE
Max length of a error message.
Definition: mysql_com.h:877
#define SQLSTATE_LENGTH
Definition: mysql_com.h:74
const char * collation
Definition: audit_api_message_emit.cc:183
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1055
Definition: commit_order_queue.h:33
required uint32 status
Definition: replication_asynchronous_connection_failover.proto:60
const LEX_CSTRING warning_level_names[]
Definition: sql_error.cc:715
size_t err_conv(char *buff, size_t to_length, const char *from, size_t from_length, const CHARSET_INFO *from_cs)
Convert value for dispatch to error message(see WL#751).
Definition: sql_error.cc:836
bool is_sqlstate_completion(const char *s)
Checks if the specified SQL-state-string defines COMPLETION condition.
Definition: sql_error.h:779
void check_deprecated_datetime_format(THD *thd, const CHARSET_INFO *cs, MYSQL_TIME_STATUS &status)
Check if status contains a deprecation warning.
Definition: sql_error.cc:1043
bool is_sqlstate_not_found(const char *s)
Checks if the specified SQL-state-string defines NOT FOUND condition.
Definition: sql_error.h:805
void push_deprecated_warn_no_replacement(THD *thd, const char *old_syntax)
Generates a warning that a feature is deprecated.
Definition: sql_error.cc:705
void warn_on_deprecated_collation(THD *thd, const CHARSET_INFO *collation, const char *option=nullptr)
Output warnings on deprecated character collations.
Definition: sql_error.cc:1016
void push_warning(THD *thd, Sql_condition::enum_severity_level severity, uint code, const char *message_text)
Push the warning to error list if there is still room in the list.
Definition: sql_error.cc:647
size_t convert_error_message(char *to, size_t to_length, const CHARSET_INFO *to_cs, const char *from, size_t from_length, const CHARSET_INFO *from_cs, uint *errors)
Convert string for dispatch to client(see WL#751).
Definition: sql_error.cc:893
bool is_sqlstate_exception(const char *s)
Checks if the specified SQL-state-string defines EXCEPTION condition.
Definition: sql_error.h:818
void push_warning_printf(THD *thd, Sql_condition::enum_severity_level severity, uint code, const char *format,...)
Push the warning to error list if there is still room in the list.
Definition: sql_error.cc:678
bool mysqld_show_warnings(THD *thd, ulong levels_to_show)
Send all notes, errors or warnings to the client in a result set.
Definition: sql_error.cc:730
void push_deprecated_warn(THD *thd, const char *old_syntax, const char *new_syntax)
Generates a warning that a feature is deprecated.
Definition: sql_error.cc:694
constexpr const size_t WARN_ALLOC_BLOCK_SIZE
Definition: sql_error.h:48
bool is_sqlstate_warning(const char *s)
Checks if the specified SQL-state-string defines WARNING condition.
Definition: sql_error.h:792
bool is_sqlstate_valid(const LEX_STRING *sqlstate)
Sanity check for SQLSTATEs.
Definition: sql_error.cc:959
void warn_on_deprecated_charset(THD *thd, const CHARSET_INFO *cs, const char *alias, const char *option=nullptr)
Output warnings on deprecated character sets.
Definition: sql_error.cc:985
Our own string classes, used pervasively throughout the executor.
Definition: m_ctype.h:354
Hook class which via its methods specifies which members of T should be used for participating in a i...
Definition: sql_plist.h:197
The MEM_ROOT is a simple arena, where allocations are carved out of larger blocks.
Definition: my_alloc.h:82
Definition: mysql_lex_string.h:39
Definition: mysql_lex_string.h:34
Structure to return status from str_to_datetime(), str_to_time(), number_to_datetime(),...
Definition: my_time.h:169
Definition: mysql_time.h:81
unsigned int uint
Definition: uca-dump.cc:29