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