MySQL 8.4.0
Source Code Documentation
field.h
Go to the documentation of this file.
1#ifndef FIELD_INCLUDED
2#define FIELD_INCLUDED
3
4/* Copyright (c) 2000, 2024, Oracle and/or its affiliates.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License, version 2.0,
8 as published by the Free Software Foundation.
9
10 This program is designed to work with certain software (including
11 but not limited to OpenSSL) that is licensed under separate terms,
12 as designated in a particular file or component or in included license
13 documentation. The authors of MySQL hereby grant you an additional
14 permission to link the program and your derivative works with the
15 separately licensed software that they have either included with
16 the program or referenced in the documentation.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License, version 2.0, for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
26
27#include <assert.h>
28#include <limits.h>
29#include <stddef.h>
30#include <stdio.h>
31#include <stdlib.h>
32#include <string.h>
33#include <sys/types.h>
34
35#include <algorithm>
36#include <optional>
37
38#include "decimal.h" // E_DEC_OOM
39#include "field_types.h" // enum_field_types
40#include "lex_string.h"
41#include "my_alloc.h"
42#include "my_base.h" // ha_storage_media
43#include "my_bitmap.h"
44#include "my_dbug.h"
45#include "my_double2ulonglong.h"
46#include "my_inttypes.h"
47#include "my_time.h" // MYSQL_TIME_NOTE_TRUNCATED
48#include "mysql/binlog/event/export/binary_log_funcs.h" // my_time_binary_length
49#include "mysql/strings/dtoa.h"
52#include "mysql_com.h"
53#include "mysql_time.h"
54#include "sql/dd/types/column.h"
56#include "sql/gis/srid.h"
57#include "sql/sql_bitmap.h"
58#include "sql/sql_const.h"
59#include "sql/sql_error.h" // Sql_condition
60#include "sql/table.h"
61#include "sql_string.h" // String
62#include "template_utils.h"
63
64class Create_field;
65class CostOfItem;
66class Field;
67class Field_bit;
69class Field_blob;
70class Field_datetime;
71class Field_decimal;
72class Field_double;
73class Field_enum;
74class Field_float;
75class Field_json;
76class Field_long;
77class Field_longlong;
78class Field_medium;
80class Field_newdate;
81class Field_num;
82class Field_real;
83class Field_set;
84class Field_short;
85class Field_str;
86class Field_string;
87class Field_temporal;
91class Field_time;
93class Field_timef;
94class Field_timestamp;
95class Field_tiny;
96class Field_varstring;
97class Field_year;
98class Item;
99class Item_field;
100class Json_array;
101class Json_diff_vector;
102class Json_wrapper;
103class KEY;
104class Protocol;
105class Relay_log_info;
106class Send_field;
107class THD;
108class Time_zone;
109class my_decimal;
110struct my_timeval;
111struct TYPELIB;
112
113/*
114 Inside an in-memory data record, memory pointers to pieces of the
115 record (like BLOBs) are stored in their native byte order and in
116 this amount of bytes.
117*/
118#define portable_sizeof_char_ptr 8
119
120/*
121
122Field class hierarchy
123
124
125Field (abstract)
126|
127+--Field_bit
128| +--Field_bit_as_char
129|
130+--Field_num (abstract)
131| | +--Field_real (abstract)
132| | +--Field_decimal
133| | +--Field_float
134| | +--Field_double
135| |
136| +--Field_new_decimal
137| +--Field_short
138| +--Field_medium
139| +--Field_long
140| +--Field_longlong
141| +--Field_tiny
142| +--Field_year
143|
144+--Field_str (abstract)
145| +--Field_longstr
146| | +--Field_string
147| | +--Field_varstring
148| | +--Field_blob
149| | +--Field_geom
150| | +--Field_json
151| | +--Field_typed_array
152| |
153| +--Field_null
154| +--Field_enum
155| +--Field_set
156|
157+--Field_temporal (abstract)
158 +--Field_time_common (abstract)
159 | +--Field_time
160 | +--Field_timef
161 |
162 +--Field_temporal_with_date (abstract)
163 +--Field_newdate
164 +--Field_temporal_with_date_and_time (abstract)
165 +--Field_timestamp
166 +--Field_datetime
167 +--Field_temporal_with_date_and_timef (abstract)
168 +--Field_timestampf
169 +--Field_datetimef
170*/
171
177
178/// For use @see DTCollation::aggregate()
188
189/* Specifies data storage format for individual columns */
191 COLUMN_FORMAT_TYPE_DEFAULT = 0, /* Not specified (use engine default) */
192 COLUMN_FORMAT_TYPE_FIXED = 1, /* FIXED format */
193 COLUMN_FORMAT_TYPE_DYNAMIC = 2 /* DYNAMIC format */
195
196/**
197 Status when storing a value in a field or converting from one
198 datatype to another. The values should be listed in order of
199 increasing seriousness so that if two type_conversion_status
200 variables are compared, the bigger one is most serious.
201*/
203 /// Storage/conversion went fine.
205 /**
206 A minor problem when converting between temporal values, e.g.
207 if datetime is converted to date the time information is lost.
208 */
210 /**
211 Value was stored, but something was cut. What was cut is
212 considered insignificant enough to only issue a note. Example:
213 trying to store a number with 5 decimal places into a field that
214 can only store 3 decimals. The number rounded to 3 decimal places
215 should be stored. Another example: storing the string "foo " into
216 a VARCHAR(3). The string "foo" is stored in this case, so only
217 whitespace is cut.
218 */
220 /**
221 Value outside min/max limit of datatype. The min/max value is
222 stored by Field::store() instead (if applicable)
223 */
225 /**
226 Value was stored, but something was cut. What was cut is
227 considered significant enough to issue a warning. Example: storing
228 the string "foo" into a VARCHAR(2). The string "fo" is stored in
229 this case. Another example: storing the string "2010-01-01foo"
230 into a DATE. The garbage in the end of the string is cut in this
231 case.
232 */
234 /**
235 Value has invalid string data. When present in a predicate with
236 equality operator, range optimizer returns an impossible where.
237 */
239 /// Trying to store NULL in a NOT NULL field.
241 /**
242 Store/convert incompatible values, like converting "foo" to a
243 date.
244 */
246 /// Out of memory
249
250/*
251 Some defines for exit codes for ::is_equal class functions.
252*/
253#define IS_EQUAL_NO 0
254#define IS_EQUAL_YES 1
255#define IS_EQUAL_PACK_LENGTH 2
256
257#define my_charset_numeric my_charset_latin1
258#define MY_REPERTOIRE_NUMERIC MY_REPERTOIRE_ASCII
259
260/**
261 Check if one can copy from “from” to “to” with a simple memcpy(), with
262 pack_length() as the length. This is the case if the types of the two fields
263 are the same and we don't have special copying rules for the type
264 (e.g., blobs, which require allocation, or time functions that require
265 checking for special SQL modes).
266
267 You should never call this with to == from, as such copies are no-ops
268 and memcpy() has undefined behavior with overlapping memory areas.
269 */
270bool fields_are_memcpyable(const Field *to, const Field *from);
271
272/**
273 Copy the value in "from" (assumed to be non-NULL) to "to", doing any
274 required conversions in the process.
275
276 Note that you should only call this if fields_are_memcpyable() is false,
277 since it does an actual conversion on the slow path (and it is not properly
278 tested whether it gives the correct result in all cases if
279 fields_are_memcpyable() is true).
280
281 You should never call this with to == from, as they are no-ops.
282 */
284
285inline uint get_enum_pack_length(int elements) {
286 return elements < 256 ? 1 : 2;
287}
288
289inline uint get_set_pack_length(int elements) {
290 const uint len = (elements + 7) / 8;
291 return len > 4 ? 8 : len;
292}
293
295 if (dec_error & E_DEC_OOM) return TYPE_ERR_OOM;
296
297 if (dec_error & (E_DEC_DIV_ZERO | E_DEC_BAD_NUM)) return TYPE_ERR_BAD_VALUE;
298
299 if (dec_error & E_DEC_TRUNCATED) return TYPE_NOTE_TRUNCATED;
300
301 if (dec_error & E_DEC_OVERFLOW) return TYPE_WARN_OUT_OF_RANGE;
302
303 if (dec_error == E_DEC_OK) return TYPE_OK;
304
305 // impossible
306 assert(false);
307 return TYPE_ERR_BAD_VALUE;
308}
309
310/**
311 Convert warnings returned from str_to_time() and str_to_datetime()
312 to their corresponding type_conversion_status codes.
313*/
315 const int warn) {
317
319
321
323 return TYPE_ERR_BAD_VALUE;
324
326 // date was fine but pointed to daylight saving time switch gap
327 return TYPE_OK;
328
329 assert(!warn);
330 return TYPE_OK;
331}
332
333#define ASSERT_COLUMN_MARKED_FOR_READ \
334 assert(!table || \
335 (!table->read_set || bitmap_is_set(table->read_set, field_index())))
336#define ASSERT_COLUMN_MARKED_FOR_WRITE \
337 assert(!table || (!table->write_set || \
338 bitmap_is_set(table->write_set, field_index())))
339
340/**
341 Tests if field real type is temporal, i.e. represents
342 all existing implementations of
343 DATE, TIME, DATETIME or TIMESTAMP types in SQL.
344
345 @param type Field real type, as returned by field->real_type()
346 @retval true If field real type is temporal
347 @retval false If field real type is not temporal
348*/
350 switch (type) {
351 case MYSQL_TYPE_TIME2:
354 return true;
355 default:
356 return is_temporal_type(type);
357 }
358}
359
360/**
361 Tests if field real type can have "DEFAULT CURRENT_TIMESTAMP",
362 i.e. represents TIMESTAMP types in SQL.
363
364 @param type Field type, as returned by field->real_type().
365 @retval true If field real type can have "DEFAULT CURRENT_TIMESTAMP".
366 @retval false If field real type can not have "DEFAULT CURRENT_TIMESTAMP".
367*/
371}
372
373/**
374 Tests if field real type can have "ON UPDATE CURRENT_TIMESTAMP",
375 i.e. represents TIMESTAMP types in SQL.
376
377 @param type Field type, as returned by field->real_type().
378 @retval true If field real type can have "ON UPDATE CURRENT_TIMESTAMP".
379 @retval false If field real type can not have "ON UPDATE CURRENT_TIMESTAMP".
380*/
384}
385
386/**
387 Convert temporal real types as returned by field->real_type()
388 to field type as returned by field->type().
389
390 @param real_type Real type.
391 @retval Field type.
392*/
394 switch (real_type) {
395 case MYSQL_TYPE_TIME2:
396 return MYSQL_TYPE_TIME;
398 return MYSQL_TYPE_DATETIME;
402 return MYSQL_TYPE_DATE;
403 /* Note: NEWDECIMAL is a type, not only a real_type */
404 default:
405 return real_type;
406 }
407}
408
409/**
410 Return the appropriate MYSQL_TYPE_X_BLOB value based on the
411 pack_length.
412
413 @param pack_length pack_length for BLOB
414 @retval MYSQL_TYPE_X_BLOB corresponding to pack_length.
415*/
418 switch (pack_length) {
419 case 1:
421 case 2:
422 return MYSQL_TYPE_BLOB;
423 case 3:
425 case 4:
427 default:
428 assert(false);
430 }
431}
432
433/**
434 Copies an integer value to a format comparable with memcmp(). The
435 format is characterized by the following:
436
437 - The sign bit goes first and is unset for negative values.
438 - The representation is big endian.
439
440 The function template can be instantiated to copy from little or
441 big endian values.
442
443 @tparam Is_big_endian True if the source integer is big endian.
444
445 @param to Where to write the integer.
446 @param to_length Size in bytes of the destination buffer.
447 @param from Where to read the integer.
448 @param from_length Size in bytes of the source integer
449 @param is_unsigned True if the source integer is an unsigned value.
450*/
451template <bool Is_big_endian>
452void copy_integer(uchar *to, size_t to_length, const uchar *from,
453 size_t from_length, bool is_unsigned) {
454 if (to_length == 0) return;
455 if (Is_big_endian) {
456 std::copy(from, from + std::min(to_length, from_length), to);
457 if (!is_unsigned)
458 to[0] = static_cast<char>(to[0] ^ 128); // Reverse the sign bit.
459 } else {
460 const uchar *from_end = from + from_length;
461 const uchar *from_start = from_end - std::min(from_length, to_length);
462 std::reverse_copy(from_start, from_end, to);
463 if (!is_unsigned)
464 to[0] = static_cast<char>(to[0] ^ 128); // Reverse the sign bit.
465 }
466}
467
468/**
469 Enum to indicate source for which value generator is used. This is needed
470 while unpacking value generator expression and pre-validating the
471 expression for generated column, default expression or check constraint.
472*/
474 VGS_GENERATED_COLUMN = 0, // Value generator for GENERATED_COLUMN.
475 VGS_DEFAULT_EXPRESSION, // Value generator for Default expression.
476 VGS_CHECK_CONSTRAINT // Value generator for check constraints.
478
479/**
480 Used for storing information associated with generated column, default
481 values generated from expression or check constraint expression.
482*/
484 public:
485 /**
486 Item representing the generation expression.
487 This is non-NULL for every Field of a TABLE, if that field is a generated
488 column.
489 Contrast this with the Field of a TABLE_SHARE, which has expr_item==NULL
490 even if it's a generated column; that makes sense, as an Item tree cannot
491 be shared.
492 */
493 Item *expr_item{nullptr};
494 /**
495 Text of the expression. Used in only one case:
496 - the text read from the DD is put into the Value_generator::expr_str of
497 the Field of the TABLE_SHARE; then this expr_str is used as source
498 to produce expr_item for the Field of every TABLE derived from this
499 TABLE_SHARE.
500 */
501 LEX_STRING expr_str{nullptr, 0};
502
503 /**
504 Bit field indicating the type of statement for binary logging.
505 It needs to be saved because this is determined only once when it is parsed
506 but it needs to be set on the lex for each statement that uses this
507 value generator. And since unpacking is done once on table open, it will
508 be set for the rest of the statements in bind_value_generator_to_fields.
509 */
511
512 /// List of all items created when parsing and resolving generated expression
513 Item *item_list{nullptr};
514 /// Bitmap records base columns which a generated column depends on.
516
518
519 void set_field_type(enum_field_types fld_type) { field_type = fld_type; }
520
521 /**
522 Set the binary log flags in m_backup_binlog_stmt_flags
523 @param backup_binlog_stmt_flags the flags to be backed up
524 */
525 void backup_stmt_unsafe_flags(uint32 backup_binlog_stmt_flags) {
526 m_backup_binlog_stmt_flags = backup_binlog_stmt_flags;
527 }
528
529 /**
530 Get the binary log flags from m_backup_binlog_stmt_flags
531 @return the flags backed up by unpack_value_generator
532 */
534
535 bool get_field_stored() const { return stored_in_db; }
536 void set_field_stored(bool stored) { stored_in_db = stored; }
538 /**
539 Get the number of non virtual base columns that this generated
540 column needs.
541
542 @return number of non virtual base columns
543 */
545
546 /**
547 Duplicates a string into expr_str.
548
549 @param root MEM_ROOT to use for allocation
550 @param src source string
551 @param len length of 'src' in bytes
552 */
553 void dup_expr_str(MEM_ROOT *root, const char *src, size_t len);
554
555 /**
556 Writes the generation expression into a String with proper syntax.
557 @param thd THD
558 @param out output String
559 */
560 void print_expr(THD *thd, String *out);
561
562 /*
563 The following data is only updated by the parser and read
564 when a Create_field object is created/initialized.
565 */
566 private:
567 /// Real field type
569 /// Indicates if the field is physically stored in the database
570 bool stored_in_db{false};
571 /// How many non-virtual base columns in base_columns_map
573};
574
575class Field {
576 public:
577 /*
578 Field(const Item &) = delete;
579 The original intention was seemingly for Field to be non-copyable,
580 but due to a typo, this was never enforced, and now there's lots of
581 code that copies Field objects around. Thus, the default copy
582 constructor needs to stay (assignment is blocked off), but it's probably
583 better not to write code that depends on it.
584 */
585 Field(const Field &) = default;
586 void operator=(Field &) = delete;
587
588 /**
589 Checks if the field is marked as having a general expression to generate
590 default values.
591
592 @retval true The field has general expression as default
593 @retval false The field doesn't have any general expression as default
594 */
597 }
598
599 /**
600 Checks if the field is marked as having a datetime value expression to
601 generate default values on inserts.
602
603 @retval true The field has datetime expression as default
604 @retval false The field doesn't have a datime value expression as default
605 */
607 return auto_flags & DEFAULT_NOW;
608 }
609
610 /**
611 Checks if the field is marked as having a datetime value expression to
612 generate default values on updates.
613
614 @retval true The field has datetime expression as default for on update
615 @retval false The field doesn't have a datime value expression as default
616 for on update
617 */
619 return auto_flags & ON_UPDATE_NOW;
620 }
621
622 /**
623 Checks if the field is marked as having a constant expression to generate
624 default values. Relevant when re-creating a Create_field from a Field
625 during ALTER.
626
627 @retval true The field has a constant expression as default
628 @retval false The field doesn't have a constant expression as default
629 */
631 // For now this is true whenever neither GENERATED_FROM_EXPRESSION nor
632 // DEFAULT_NOW is set. If this changes in the future, we can add a separate
633 // flag for this.
635 }
636
637 protected:
638 /// Holds the position to the field in record
640
641 private:
643
644 /**
645 Byte where the @c NULL bit is stored inside a record. If this Field is a
646 @c NOT @c NULL field, this member is @c NULL.
647 */
649
650 /**
651 Flag: if the NOT-NULL field can be temporary NULL.
652 */
654
655 /**
656 This is a flag with the following semantics:
657 - it can be changed only when m_is_tmp_nullable is true;
658 - it specifies if this field in the first current record
659 (TABLE::record[0]) was set to NULL (temporary NULL).
660
661 This flag is used for trigger handling.
662 */
664
665 /**
666 The value of THD::check_for_truncated_fields at the moment of setting
667 m_is_tmp_null attribute.
668 */
670
671 protected:
672 /*
673 null_ptr buffer to be used for Fields that are nullable but
674 cannot store null. Typically used from create_tmp_field().
675 */
677
678 public:
680 /// Pointer to TABLE object that owns this field
682 /// Pointer to original database name, only non-NULL for a temporary table
683 const char *orig_db_name{nullptr};
684 /// Pointer to original table name, only non-NULL for a temporary table
685 const char *orig_table_name{nullptr};
686 const char **table_name, *field_name;
688 /* Field is part of the following keys */
689 Key_map key_start; /* Keys that starts with this field */
690 Key_map part_of_key; ///< Keys that includes this field
691 ///< except of prefix keys.
692 Key_map part_of_prefixkey; ///< Prefix keys
693 Key_map part_of_sortkey; /* ^ but only keys usable for sorting */
694 /**
695 All keys that include this field, but not extended by the storage engine to
696 include primary key columns.
697 */
699
700 /**
701 Flags for Field::auto_flags / Create_field::auto_flags bitmaps.
702
703 @note NEXT_NUMBER and DEFAULT_NOW/ON_UPDATE_NOW/GENERATED flags should
704 never be set at the same time. Also DEFAULT_NOW and GENERATED
705 should not be set at the same time.
706
707 @warning The values of this enum are used as bit masks for uchar
708 Field::auto_flags.
709 */
711 NONE = 0,
712 NEXT_NUMBER = 1, ///< AUTO_INCREMENT
713 DEFAULT_NOW = 2, ///< DEFAULT CURRENT_TIMESTAMP
714 ON_UPDATE_NOW = 4, ///< ON UPDATE CURRENT_TIMESTAMP
715 GENERATED_FROM_EXPRESSION = 8 ///< DEFAULT (expression)
716 };
717
727 };
729
730 // Max width for a VARCHAR column, in number of bytes
731 static constexpr size_t MAX_VARCHAR_WIDTH{65535};
732
733 // Maximum sizes of the four BLOB types, in number of bytes
734 static constexpr size_t MAX_TINY_BLOB_WIDTH{255};
735 static constexpr size_t MAX_SHORT_BLOB_WIDTH{65535};
736 static constexpr size_t MAX_MEDIUM_BLOB_WIDTH{16777215};
737 static constexpr size_t MAX_LONG_BLOB_WIDTH{4294967295};
738
739 // Length of field. Never write to this member directly; instead, use
740 // set_field_length().
743
744 /// Update '*cost' with the fact that this Field is accessed.
745 virtual void add_to_cost(CostOfItem *cost) const;
746
747 private:
749 uint16 m_field_index; // field number in fields array
750
751 public:
752 bool is_flag_set(unsigned flag) const { return flags & flag; }
753 void set_flag(unsigned flag) { flags |= flag; }
754 void clear_flag(unsigned flag) { flags &= ~flag; }
755 // Avoid using this function as it makes it harder to change the internal
756 // representation.
757 uint32 all_flags() const { return flags; }
758 uchar null_bit; // Bit used to test null bit
759 /**
760 Bitmap of flags indicating if field value is auto-generated by default
761 and/or on update, and in which way.
762
763 @sa Field::enum_auto_flags for possible options.
764
765 @sa Field::utype and Field::unireg_check in pre-8.0 versions of server
766 for historical perspective.
767 */
769 /**
770 If true, this field was created in create_tmp_field_from_item from a NULL
771 value. This means that the type of the field is just a guess, and the type
772 may be freely coerced to another type.
773
774 @see create_tmp_field_from_item
775 @see Item_type_holder::get_real_type
776
777 */
779 /**
780 True if this field belongs to some index (unlike part_of_key, the index
781 might have only a prefix).
782 */
784
787
788 private:
793 };
794
795 /*
796 Bitmask specifying which warnings have been already pushed in order
797 not to repeat the same warning for the collmn multiple times.
798 Uses values of enum_pushed_warnings to control pushed warnings.
799 */
800 unsigned int m_warnings_pushed;
801
802 public:
803 /* Generated column data */
805 /**
806 Indication that the field is physically stored in tables
807 rather than just generated on SQL queries.
808 As of now, false can only be set for virtual generated columns.
809 */
811 /**
812 Whether the field is signed or not. Meaningful only for numeric fields
813 and numeric arrays.
814 */
815 virtual bool is_unsigned() const { return false; }
816 bool is_gcol() const { return gcol_info; }
817 bool is_virtual_gcol() const { return gcol_info && !stored_in_db; }
818
819 /// Holds the expression to be used to generate default values.
821
822 /**
823 Sets the hidden type for this field.
824
825 @param hidden the new hidden type to set.
826 */
828
829 /// @returns the hidden type for this field.
831
832 /**
833 @retval true if this field should be hidden away from users.
834 @retval false is this field is visible to the user.
835 */
836 bool is_hidden() const {
838 DBUG_EVALUATE_IF("show_hidden_columns", false, true);
839 }
840
841 /**
842 @retval true If this column is hidden either in the storage engine
843 or SQL layer. Either way, it is completely hidden from
844 the user.
845 @retval false Otherwise.
846 */
847 bool is_hidden_by_system() const {
850 DBUG_EVALUATE_IF("show_hidden_columns", false, true);
851 }
852
853 /**
854 @retval true If this column is hidden by the user.
855 @retval false otherwise.
856 */
857 bool is_hidden_by_user() const {
859 }
860
861 /**
862 @returns true if this is a hidden field that is used for implementing
863 functional indexes. Note that if we need different types of hidden
864 fields in the future (like invisible columns), this function needs
865 to be changed so it can distinguish between the different "types"
866 of hidden.
867 */
870 gcol_info != nullptr;
871 }
872
873 Field(uchar *ptr_arg, uint32 length_arg, uchar *null_ptr_arg,
874 uchar null_bit_arg, uchar auto_flags_arg, const char *field_name_arg);
875
876 virtual ~Field() = default;
877
879
880 /**
881 Turn on temporary nullability for the field.
882 */
884
885 /**
886 Turn off temporary nullability for the field.
887 */
889
890 /**
891 Reset temporary NULL value for field
892 */
893 void reset_tmp_null() { m_is_tmp_null = false; }
894
895 void set_tmp_null();
896
897 /**
898 @return temporary NULL-ability flag.
899 @retval true if NULL can be assigned temporary to the Field.
900 @retval false if NULL can not be assigned even temporary to the Field.
901 */
902 bool is_tmp_nullable() const { return m_is_tmp_nullable; }
903
904 /**
905 @return whether Field has temporary value NULL.
906 @retval true if the Field has temporary value NULL.
907 @retval false if the Field's value is NOT NULL, or if the temporary
908 NULL-ability flag is reset.
909 */
910 bool is_tmp_null() const { return is_tmp_nullable() && m_is_tmp_null; }
911
912 /* Store functions returns 1 on overflow and -1 on fatal error */
913 virtual type_conversion_status store(const char *to, size_t length,
914 const CHARSET_INFO *cs) = 0;
915 virtual type_conversion_status store(double nr) = 0;
916 virtual type_conversion_status store(longlong nr, bool unsigned_val) = 0;
917 /**
918 Store a temporal value in packed longlong format into a field.
919 The packed value is compatible with TIME_to_longlong_time_packed(),
920 TIME_to_longlong_date_packed() or TIME_to_longlong_datetime_packed().
921 Note, the value must be properly rounded or truncated according
922 according to field->decimals().
923
924 @param nr temporal value in packed longlong format.
925 @retval false on success
926 @retval true on error
927 */
929 return store(nr, false);
930 }
932 /**
933 Store MYSQL_TIME value with the given amount of decimal digits
934 into a field.
935
936 Note, the "dec" parameter represents number of digits of the Item
937 that previously created the MYSQL_TIME value. It's needed when we
938 store the value into a CHAR/VARCHAR/TEXT field to display
939 the proper amount of fractional digits.
940 For other field types the "dec" value does not matter and is ignored.
941
942 @param ltime Time, date or datetime value.
943 @param dec_arg Number of decimals in ltime.
944 @retval false on success
945 @retval true on error
946 */
947 virtual type_conversion_status store_time(MYSQL_TIME *ltime, uint8 dec_arg);
948 /**
949 Store MYSQL_TYPE value into a field when the number of fractional
950 digits is not important or is not know.
951
952 @param ltime Time, date or datetime value.
953 @retval false on success
954 @retval true on error
955 */
957 return store_time(ltime, 0);
958 }
959 type_conversion_status store(const char *to, size_t length,
960 const CHARSET_INFO *cs,
961 enum_check_fields check_level);
962 virtual double val_real() const = 0;
963 virtual longlong val_int() const = 0;
964 /**
965 Returns TIME value in packed longlong format.
966 This method should not be called for non-temporal types.
967 Temporal field types override the default method.
968 */
969 virtual longlong val_time_temporal() const {
970 assert(0);
971 return 0;
972 }
973 /**
974 Returns DATE/DATETIME value in packed longlong format.
975 This method should not be called for non-temporal types.
976 Temporal field types override the default method.
977 */
978 virtual longlong val_date_temporal() const {
979 assert(0);
980 return 0;
981 }
982
984 return val_time_temporal();
985 }
986
988 return val_date_temporal();
989 }
990
991 /**
992 Returns "native" packed longlong representation of
993 a TIME or DATE/DATETIME field depending on field type.
994 */
996 // Return longlong TIME or DATETIME representation, depending on field type
997 const enum_field_types field_type = type();
998 if (field_type == MYSQL_TYPE_TIME) return val_time_temporal();
999 assert(is_temporal_type_with_date(field_type));
1000 return val_date_temporal();
1001 }
1002 virtual my_decimal *val_decimal(my_decimal *) const = 0;
1003 String *val_str(String *str) const { return val_str(str, str); }
1004 /*
1005 val_str(buf1, buf2) gets two buffers and should use them as follows:
1006 if it needs a temp buffer to convert result to string - use buf1
1007 example Field_tiny::val_str()
1008 if the value exists as a string already - use buf2
1009 example Field_string::val_str()
1010 consequently, buf2 may be created as 'String buf;' - no memory
1011 will be allocated for it. buf1 will be allocated to hold a
1012 value if it's too small. Using allocated buffer for buf2 may result in
1013 an unnecessary free (and later, may be an alloc).
1014 This trickery is used to decrease a number of malloc calls.
1015 */
1016 virtual String *val_str(String *, String *) const = 0;
1017 String *val_int_as_str(String *val_buffer, bool unsigned_flag) const;
1018 /*
1019 str_needs_quotes() returns true if the value returned by val_str() needs
1020 to be quoted when used in constructing an SQL query.
1021 */
1022 virtual bool str_needs_quotes() const { return false; }
1023 virtual Item_result result_type() const = 0;
1024 /**
1025 Returns Item_result type of a field when it appears
1026 in numeric context such as:
1027 SELECT time_column + 1;
1028 SELECT SUM(time_column);
1029 Examples:
1030 - a column of type TIME, DATETIME, TIMESTAMP act as INT.
1031 - a column of type TIME(1), DATETIME(1), TIMESTAMP(1)
1032 act as DECIMAL with 1 fractional digits.
1033 */
1035 return result_type();
1036 }
1037 virtual Item_result cmp_type() const { return result_type(); }
1038 virtual Item_result cast_to_int_type() const { return result_type(); }
1042 bool gcol_expr_is_equal(const Create_field *field) const;
1043 virtual bool eq(const Field *field) const {
1044 return (ptr == field->ptr && m_null_ptr == field->m_null_ptr &&
1045 null_bit == field->null_bit && field->type() == type());
1046 }
1047 virtual bool eq_def(const Field *field) const;
1048
1049 /*
1050 pack_length() returns size (in bytes) used to store field data in memory
1051 (i.e. it returns the maximum size of the field in a row of the table,
1052 which is located in RAM).
1053 */
1054 virtual uint32 pack_length() const { return (uint32)field_length; }
1055
1056 /*
1057 pack_length_in_rec() returns size (in bytes) used to store field data on
1058 storage (i.e. it returns the maximal size of the field in a row of the
1059 table, which is located on disk).
1060 */
1061 virtual uint32 pack_length_in_rec() const { return pack_length(); }
1062 virtual bool compatible_field_size(uint metadata, Relay_log_info *, uint16,
1063 int *order) const;
1064 virtual uint pack_length_from_metadata(uint field_metadata) const {
1065 DBUG_TRACE;
1066 return field_metadata;
1067 }
1068 virtual uint row_pack_length() const { return 0; }
1069 int save_field_metadata(uchar *first_byte) {
1070 return do_save_field_metadata(first_byte);
1071 }
1072
1073 /*
1074 data_length() return the "real size" of the data in memory.
1075 Useful only for variable length datatypes where it's overloaded.
1076 By default assume the length is constant.
1077 */
1078 virtual uint32 data_length(ptrdiff_t row_offset [[maybe_unused]] = 0) const {
1079 return pack_length();
1080 }
1081
1082 /**
1083 Get the maximum size of the data in packed format.
1084
1085 @return Maximum data length of the field when packed using the
1086 Field::pack() function.
1087 */
1088 virtual uint32 max_data_length() const { return pack_length(); }
1089
1091 memset(ptr, 0, pack_length());
1092 return TYPE_OK;
1093 }
1094 /**
1095 Returns a UTC component in `struct timeval` format. This interface
1096 makes any column appear to be `TIMESTAMP`, i.e. stored in UTC, and
1097 returns the UTC component in (optionally fractional) seconds. This means
1098 converting _to_ UTC from the current session's time zone for types other
1099 than `TIMESTAMP`.
1100
1101 This method was expressly written for `SELECT UNIX_TIMESTAMP(field)`
1102 to avoid conversion from timestamp to MYSQL_TIME and back.
1103 */
1104 virtual bool get_timestamp(my_timeval *tm, int *warnings) const;
1105 /**
1106 Stores a timestamp value in timeval format in a field.
1107
1108 @note
1109 - store_timestamp(), get_timestamp() and store_time() do not depend on
1110 timezone and always work "in UTC".
1111
1112 - The default implementation of this interface expects that storing the
1113 value will not fail. For most Field descendent classes, this is not the
1114 case. However, this interface is only used when the function
1115 CURRENT_TIMESTAMP is used as a column default expression, and currently we
1116 only allow TIMESTAMP and DATETIME columns to be declared with this as the
1117 column default. Hence it is enough that the classes implementing columns
1118 with these types either override this interface, or that
1119 store_time(MYSQL_TIME*, uint8) does not fail.
1120
1121 - The column types above interpret decimals() to mean the scale of the
1122 fractional seconds.
1123
1124 - We also have the limitation that the scale of a column must be the same as
1125 the scale of the CURRENT_TIMESTAMP. I.e. we only allow
1126
1127 @code
1128
1129 [ TIMESTAMP | DATETIME ] (n) [ DEFAULT | ON UPDATE ] CURRENT_TIMESTAMP (n)
1130
1131 @endcode
1132
1133 Since this interface relies on the caller to truncate the value according to
1134 this Field's scale, it will work with all constructs that we currently allow.
1135 */
1136 virtual void store_timestamp(const my_timeval *) { assert(false); }
1137
1138 virtual void set_default();
1139
1140 /**
1141 Evaluates the @c INSERT default function and stores the result in the
1142 field. If no such function exists for the column, or the function is not
1143 valid for the column's data type, invoking this function has no effect.
1144 */
1146
1147 /**
1148 Evaluates the @c UPDATE default function, if one exists, and stores the
1149 result in the record buffer. If no such function exists for the column,
1150 or the function is not valid for the column's data type, invoking this
1151 function has no effect.
1152 */
1154 virtual bool binary() const { return true; }
1155 virtual bool zero_pack() const { return true; }
1156 virtual enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
1157 virtual uint32 key_length() const { return pack_length(); }
1158 virtual enum_field_types type() const = 0;
1159 virtual enum_field_types real_type() const { return type(); }
1161 /*
1162 Binlog stores field->type() as type code by default.
1163 This puts MYSQL_TYPE_STRING in case of CHAR, VARCHAR, SET and ENUM,
1164 with extra data type details put into metadata.
1165
1166 We cannot store field->type() in case of temporal types with
1167 fractional seconds: TIME(n), DATETIME(n) and TIMESTAMP(n),
1168 because binlog records with MYSQL_TYPE_TIME, MYSQL_TYPE_DATETIME
1169 type codes do not have metadata.
1170 So for temporal data types with fractional seconds we'll store
1171 real_type() type codes instead, i.e.
1172 MYSQL_TYPE_TIME2, MYSQL_TYPE_DATETIME2, MYSQL_TYPE_TIMESTAMP2,
1173 and put precision into metatada.
1174
1175 Note: perhaps binlog should eventually be modified to store
1176 real_type() instead of type() for all column types.
1177 */
1178 return type();
1179 }
1180 int cmp(const uchar *str) const { return cmp(ptr, str); }
1181 virtual int cmp_max(const uchar *a, const uchar *b,
1182 uint max_len [[maybe_unused]]) const {
1183 return cmp(a, b);
1184 }
1185 virtual int cmp(const uchar *, const uchar *) const = 0;
1186 virtual int cmp_binary(const uchar *a, const uchar *b,
1187 uint32 max_length [[maybe_unused]] = ~0L) const {
1188 return memcmp(a, b, pack_length());
1189 }
1190 virtual int cmp_offset(ptrdiff_t row_offset) const {
1191 return cmp(ptr, ptr + row_offset);
1192 }
1193 virtual int cmp_binary_offset(ptrdiff_t row_offset) const {
1194 return cmp_binary(ptr, ptr + row_offset);
1195 }
1196 virtual int key_cmp(const uchar *a, const uchar *b) const {
1197 return cmp(a, b);
1198 }
1199 virtual int key_cmp(const uchar *str, uint length [[maybe_unused]]) const {
1200 return cmp(ptr, str);
1201 }
1202 virtual uint decimals() const { return 0; }
1203 virtual bool is_text_key_type() const { return false; }
1204
1205 /*
1206 Caller beware: sql_type can change str.Ptr, so check
1207 ptr() to see if it changed if you are using your own buffer
1208 in str and restore it with set() if needed
1209 */
1210 virtual void sql_type(String &str) const = 0;
1211
1212 /**
1213 Check whether the full table's row is NULL or the Field has value NULL.
1214
1215 @return true if the full table's row is NULL or the Field has value NULL
1216 false if neither table's row nor the Field has value NULL
1217 */
1218 bool is_null(ptrdiff_t row_offset = 0) const {
1219 /*
1220 if the field is NULLable, it returns NULLity based
1221 on m_null_ptr[row_offset] value. Otherwise it returns
1222 NULL flag depending on TABLE::has_null_row() value.
1223
1224 The table may have been marked as containing only NULL values
1225 for all fields if it is a NULL-complemented row of an OUTER JOIN
1226 or if the query is an implicitly grouped query (has aggregate
1227 functions but no GROUP BY clause) with no qualifying rows. If
1228 this is the case (in which TABLE::has_null_row() is true) and the
1229 field is not nullable, the field is considered to be NULL.
1230
1231 Do not change the order of testing. Fields may be associated
1232 with a TABLE object without being part of the current row.
1233 For NULL value check to work for these fields, they must
1234 have a valid m_null_ptr, and this pointer must be checked before
1235 TABLE::has_null_row().
1236 */
1237 if (is_nullable()) return (m_null_ptr[row_offset] & null_bit);
1238
1239 if (is_tmp_nullable()) return m_is_tmp_null;
1240
1241 return table->has_null_row();
1242 }
1243
1244 /**
1245 Check whether the Field has value NULL (temporary or actual).
1246
1247 @return true if the Field has value NULL (temporary or actual)
1248 false if the Field has value NOT NULL.
1249 */
1250 bool is_real_null(ptrdiff_t row_offset = 0) const {
1251 if (is_nullable()) return (m_null_ptr[row_offset] & null_bit);
1252
1253 if (is_tmp_nullable()) return m_is_tmp_null;
1254
1255 return false;
1256 }
1257
1258 /**
1259 Check if the Field has value NULL or the record specified by argument
1260 has value NULL for this Field.
1261
1262 @return true if the Field has value NULL or the record has value NULL
1263 for thois Field.
1264 */
1265 bool is_null_in_record(const uchar *record) const {
1266 if (is_nullable()) return (record[null_offset()] & null_bit);
1267
1268 return is_tmp_nullable() ? m_is_tmp_null : false;
1269 }
1270
1271 void set_null(ptrdiff_t row_offset = 0);
1272
1273 void set_notnull(ptrdiff_t row_offset = 0);
1274
1275 // Cannot be const as it calls set_warning
1277
1278 /**
1279 Remember the value of THD::check_for_truncated_fields to handle possible
1280 NOT-NULL constraint errors after BEFORE-trigger execution is finished.
1281 We should save the value of THD::check_for_truncated_fields before starting
1282 BEFORE-trigger processing since during triggers execution the
1283 value of THD::check_for_truncated_fields could be changed.
1284 */
1286 enum_check_fields check_for_truncated_fields) {
1287 m_check_for_truncated_fields_saved = check_for_truncated_fields;
1288 }
1289
1290 /// @return true if this field is NULL-able, false otherwise.
1291 bool is_nullable() const { return m_null_ptr != nullptr; }
1292
1293 uint null_offset(const uchar *record) const {
1294 return (uint)(m_null_ptr - record);
1295 }
1296
1297 uint null_offset() const;
1298
1299 void set_null_ptr(uchar *p_null_ptr, uint p_null_bit) {
1300 m_null_ptr = p_null_ptr;
1301 null_bit = p_null_bit;
1302 }
1303
1304 /**
1305 Populates a Send_field object with metadata about the column represented by
1306 this Field object. The Send_field object is used for sending column metadata
1307 to the client.
1308
1309 @param[out] send_field the Send_field object to populate
1310 */
1311 virtual void make_send_field(Send_field *send_field) const;
1312
1313 /**
1314 Writes a copy of the current value in the record buffer, suitable for
1315 sorting using byte-by-byte comparison. Integers are always in big-endian
1316 regardless of hardware architecture. At most length bytes are written
1317 into the buffer.
1318
1319 @param buff The buffer, assumed to be at least length bytes.
1320
1321 @param length Number of bytes to write.
1322
1323 @retval The number of bytes actually written.
1324
1325 @note This is now only used by replication; filesort makes its own
1326 sort keys based off of Items, not Fields.
1327 */
1328 virtual size_t make_sort_key(uchar *buff, size_t length) const = 0;
1329
1330 /**
1331 Writes a copy of the current value in the record buffer, suitable for
1332 sorting using byte-by-byte comparison. Integers are always in big-endian
1333 regardless of hardware architecture. At most length bytes are written
1334 into the buffer. Field_string, Field_varstring and Field_blob classes
1335 are truncated after pos number of characters.
1336
1337 @param buff The buffer, assumed to be at least length bytes.
1338
1339 @param length Number of bytes to write.
1340
1341 @param trunc_pos Number of characters which should be included before
1342 truncation.
1343
1344 @retval The number of bytes actually written.
1345
1346 @note This is now only used by replication; filesort makes its own
1347 sort keys based off of Items, not Fields.
1348 */
1349 virtual size_t make_sort_key(uchar *buff, size_t length,
1350 size_t trunc_pos [[maybe_unused]]) const {
1351 return make_sort_key(buff, length);
1352 }
1353
1354 /**
1355 Whether this field can be used for index range scans when in
1356 the given keypart of the given index.
1357 */
1358 virtual bool optimize_range(uint idx, uint part) const;
1359 /*
1360 This should be true for fields which, when compared with constant
1361 items, can be casted to longlong. In this case we will at 'fix_fields'
1362 stage cast the constant items to longlongs and at the execution stage
1363 use field->val_int() for comparison. Used to optimize clauses like
1364 'a_column BETWEEN date_const, date_const'.
1365 */
1366 virtual bool can_be_compared_as_longlong() const { return false; }
1367 virtual void mem_free() {}
1368
1369 virtual Field *new_field(MEM_ROOT *root, TABLE *new_table) const;
1370
1371 Field *new_field(MEM_ROOT *root, TABLE *new_table, uchar *new_ptr,
1372 uchar *new_null_ptr, uint new_null_bit) const {
1373 Field *field = new_field(root, new_table);
1374 field->move_field(new_ptr, new_null_ptr, new_null_bit);
1375 return field;
1376 }
1377
1378 virtual Field *new_key_field(MEM_ROOT *root, TABLE *new_table, uchar *new_ptr,
1379 uchar *new_null_ptr, uint new_null_bit) const;
1380
1381 Field *new_key_field(MEM_ROOT *root, TABLE *new_table, uchar *new_ptr) const {
1382 return new_key_field(root, new_table, new_ptr, m_null_ptr, null_bit);
1383 }
1384
1385 /**
1386 Makes a shallow copy of the Field object.
1387
1388 @note This member function must be overridden in all concrete
1389 subclasses. Several of the Field subclasses are concrete even though they
1390 are not leaf classes, so the compiler will not always catch this.
1391
1392 @param mem_root MEM_ROOT to use for memory allocation.
1393 @retval NULL If memory allocation failed.
1394 */
1395 virtual Field *clone(MEM_ROOT *mem_root) const = 0;
1396
1397 void move_field(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg) {
1398 ptr = ptr_arg;
1399 m_null_ptr = null_ptr_arg;
1400 null_bit = null_bit_arg;
1401 }
1402
1403 virtual void move_field_offset(ptrdiff_t ptr_diff) {
1404 ptr += ptr_diff;
1405 if (is_nullable()) m_null_ptr += ptr_diff;
1406 }
1407
1408 virtual void get_image(uchar *buff, size_t length,
1409 const CHARSET_INFO *) const {
1410 memcpy(buff, ptr, length);
1411 }
1412
1413 virtual void set_image(const uchar *buff, size_t length,
1414 const CHARSET_INFO *) {
1415 memcpy(ptr, buff, length);
1416 }
1417
1418 /*
1419 Copy a field part into an output buffer.
1420
1421 SYNOPSIS
1422 Field::get_key_image()
1423 buff [out] output buffer
1424 length output buffer size
1425 type itMBR for geometry blobs, otherwise itRAW
1426
1427 DESCRIPTION
1428 This function makes a copy of field part of size equal to or
1429 less than "length" parameter value.
1430 For fields of string types (CHAR, VARCHAR, TEXT) the rest of buffer
1431 is padded by zero byte.
1432
1433 NOTES
1434 For variable length character fields (i.e. UTF-8) the "length"
1435 parameter means a number of output buffer bytes as if all field
1436 characters have maximal possible size (mbmaxlen). In the other words,
1437 "length" parameter is a number of characters multiplied by
1438 field_charset->mbmaxlen.
1439
1440 RETURN
1441 Number of copied bytes (excluding padded zero bytes -- see above).
1442 */
1443
1444 virtual size_t get_key_image(uchar *buff, size_t length,
1445 imagetype type [[maybe_unused]]) const {
1447 return length;
1448 }
1449 virtual void set_key_image(const uchar *buff, size_t length) {
1451 }
1452 longlong val_int_offset(ptrdiff_t row_offset) {
1453 ptr += row_offset;
1454 const longlong tmp = val_int();
1455 ptr -= row_offset;
1456 return tmp;
1457 }
1459 uchar *old_ptr = ptr;
1460 longlong return_value;
1461 ptr = new_ptr;
1462 return_value = val_int();
1463 ptr = old_ptr;
1464 return return_value;
1465 }
1467 uchar *old_ptr = ptr;
1468 ptr = new_ptr;
1469 val_str(str);
1470 ptr = old_ptr;
1471 return str;
1472 }
1473
1474 /**
1475 Send the value of this field over the protocol using the correct
1476 Protocol::store*() function which matches the type of the field.
1477 */
1478 virtual bool send_to_protocol(Protocol *protocol) const;
1479
1480 /**
1481 Pack the field into a format suitable for storage and transfer.
1482
1483 To implement packing functionality, only the virtual function
1484 should be overridden. The other functions are just convenience
1485 functions and hence should not be overridden.
1486
1487 The actual format is opaque and will vary between types of Field
1488 (it is meant to be unpacked by unpack(), but be aware that it is
1489 used among others in the replication log, so you cannot change it
1490 without incurring a format break.
1491
1492 @note The default implementation just copies the raw bytes
1493 of the record into the destination, but never more than
1494 <code>max_length</code> characters.
1495
1496 @param to
1497 Pointer to memory area where representation of field should be put.
1498
1499 @param from
1500 Pointer to memory area where record representation of field is
1501 stored, typically field->field_ptr().
1502
1503 @param max_length
1504 Available space in “to”, in bytes. pack() will not write more bytes than
1505 this; if the field is too short, the contents _are not unpackable by
1506 unpack()_. (It is nominally supposed to be a prefix of what would have
1507 been written with a full buffer, ie., the same as packing and then
1508 truncating the output, but not all Field classes follow this.)
1509
1510 @return The byte after the last byte in “to” written to. If the return
1511 value is equal to (to + max_length), it could either be that the value
1512 fit exactly, or that the buffer was too small; you cannot distinguish
1513 between the two cases based on the return value alone.
1514 */
1515 virtual uchar *pack(uchar *to, const uchar *from, size_t max_length) const;
1516
1517 uchar *pack(uchar *to) const { return pack(to, ptr, UINT_MAX); }
1518
1519 virtual const uchar *unpack(uchar *to, const uchar *from, uint param_data);
1520
1521 const uchar *unpack(const uchar *from) { return unpack(ptr, from, 0U); }
1522
1523 /**
1524 This function does the same thing as pack(), except for the difference
1525 that max_length does not mean the number of bytes in the output, but the
1526 maximum field length from the input (which must be exactly
1527 field->max_field_length()). The difference is currently only relevant for
1528 Field_blob, but can be summed up as follows:
1529
1530 - If the actual field length is longer than "max_length", by way of
1531 software bug or otherwise, the function may behave as if it were shorter,
1532 and write something that is still readable by unpack().
1533 - There is no bounds checking; the caller must verify that there is
1534 sufficient space in "to". Even in the case of truncation, "to" must
1535 be long enough to hold the untruncated field, as the return pointer
1536 would otherwise be invalid, causing undefined behavior as per the C++
1537 standard.
1538 */
1539 virtual uchar *pack_with_metadata_bytes(uchar *to, const uchar *from,
1540 uint max_length) const {
1541 return pack(to, from, max_length);
1542 }
1543
1544 /**
1545 Write the field for the binary log in diff format.
1546
1547 This should only write the field if the diff format is smaller
1548 than the full format. Otherwise it should leave the buffer
1549 untouched.
1550
1551 @param[in,out] to Pointer to buffer where the field will be
1552 written. This will be changed to point to the next byte after the
1553 last byte that was written.
1554
1555 @param value_options bitmap that indicates if full or partial
1556 JSON format is to be used.
1557
1558 @retval true The field was not written, either because the data
1559 type does not support it, or because it was disabled according to
1560 value_options, or because there was no diff information available
1561 from the optimizer, or because the the diff format was bigger than
1562 the full format. The 'to' parameter is unchanged in this case.
1563
1564 @retval false The field was written.
1565 */
1566 virtual bool pack_diff(uchar **to [[maybe_unused]],
1567 ulonglong value_options [[maybe_unused]]) const {
1568 return true;
1569 }
1570
1571 /**
1572 This is a wrapper around pack_length() used by filesort() to determine
1573 how many bytes we need for packing "addon fields".
1574 @returns maximum size of a row when stored in the filesort buffer.
1575 */
1576
1577 virtual uint max_packed_col_length() const { return pack_length(); }
1578
1579 uint offset(uchar *record) const { return (uint)(ptr - record); }
1580
1581 void copy_data(ptrdiff_t src_record_offset);
1582
1583 virtual bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const;
1584
1585 virtual bool get_time(MYSQL_TIME *ltime) const;
1586
1587 virtual const CHARSET_INFO *charset() const { return &my_charset_bin; }
1588
1590 return binary() ? &my_charset_bin : charset();
1591 }
1592 virtual const CHARSET_INFO *sort_charset() const { return charset(); }
1593 virtual bool has_charset() const { return false; }
1594 /*
1595 match_collation_to_optimize_range() is to distinguish in
1596 range optimizer (see opt_range.cc) between real string types:
1597 CHAR, VARCHAR, TEXT
1598 and the other string-alike types with result_type() == STRING_RESULT:
1599 DATE, TIME, DATETIME, TIMESTAMP
1600 We need it to decide whether to test if collation of the operation
1601 matches collation of the field (needed only for real string types).
1602 QQ: shouldn't DATE/TIME types have their own XXX_RESULT types eventually?
1603 */
1604
1605 virtual bool match_collation_to_optimize_range() const { return false; }
1606 virtual enum Derivation derivation() const { return DERIVATION_IMPLICIT; }
1607 virtual uint repertoire() const { return MY_REPERTOIRE_UNICODE30; }
1608 virtual void set_derivation(enum Derivation) {}
1609
1610 /**
1611 Produce warning or note about data saved into field.
1612
1613 @param level - level of message (Note/Warning/Error)
1614 @param code - error code of message to be produced
1615 @param cut_increment - whenever we should increase cut fields count
1616
1617 @note
1618 This function won't produce warning and increase cut fields counter
1619 if check_for_truncated_fields == CHECK_FIELD_IGNORE for current thread.
1620
1621 if check_for_truncated_fields == CHECK_FIELD_IGNORE then we ignore notes.
1622 This allows us to avoid notes in optimization, like
1623 convert_constant_item().
1624
1625 @retval
1626 1 if check_for_truncated_fields == CHECK_FIELD_IGNORE and error level
1627 is not NOTE
1628 @retval
1629 0 otherwise
1630 */
1632 int cut_increment) {
1633 return set_warning(level, code, cut_increment, nullptr, nullptr);
1634 }
1635
1636 bool set_warning(Sql_condition::enum_severity_level level, uint code,
1637 int cut_increment, const char *view_db,
1638 const char *view_name);
1639
1640 bool warn_if_overflow(int op_result);
1641 virtual void init(TABLE *table_arg);
1642
1643 /* maximum possible display length */
1644 virtual uint32 max_display_length() const = 0;
1645
1646 /**
1647 Whether a field being created is type-compatible with an existing one.
1648
1649 Used by the ALTER TABLE code to evaluate whether the new definition
1650 of a table is compatible with the old definition so that it can
1651 determine if data needs to be copied over (table data change).
1652 Constraints and generation clause (default value, generation expression)
1653 are not checked by this function.
1654
1655 @param new_field new field definition from alter.
1656 @retval IS_EQUAL_YES if there is no change.
1657 @retval IS_EQUAL_PACK_LENGTH if the data are unchanged, but the length
1658 requirements have changed
1659 @retval IS_EQUAL_NO if there is an incompatible change requiring copy.
1660 */
1661
1662 virtual uint is_equal(const Create_field *new_field) const;
1663
1664 /* convert decimal to longlong with overflow check */
1665 longlong convert_decimal2longlong(const my_decimal *val, bool unsigned_flag,
1666 bool *has_overflow);
1667 /* The max. number of characters */
1668 virtual uint32 char_length() const {
1669 return field_length / charset()->mbmaxlen;
1670 }
1671
1673 /* shouldn't get here. */
1674 assert(0);
1675 return GEOM_GEOMETRY;
1676 }
1677#ifndef NDEBUG
1678 /* Print field value into debug trace, in NULL-aware way. */
1679 void dbug_print() const {
1680 if (is_real_null())
1681 fprintf(DBUG_FILE, "NULL");
1682 else {
1683 char buf[256];
1684 String str(buf, sizeof(buf), &my_charset_bin);
1685 str.length(0);
1686 String *pstr;
1687 pstr = val_str(&str);
1688 fprintf(DBUG_FILE, "'%s'", pstr->c_ptr_safe());
1689 }
1690 }
1691#endif
1692
1695 }
1696
1697 void set_storage_type(ha_storage_media storage_type_arg) {
1698 assert(field_storage_type() == HA_SM_DEFAULT);
1699 flags |= (storage_type_arg << FIELD_FLAGS_STORAGE_MEDIA);
1700 }
1701
1704 }
1705
1706 void set_column_format(column_format_type column_format_arg) {
1708 flags |= (column_format_arg << FIELD_FLAGS_COLUMN_FORMAT);
1709 }
1710
1711 /* Validate the value stored in a field */
1713 [[maybe_unused]]) {
1714 return TYPE_OK;
1715 }
1716
1717 /* Hash value */
1718 virtual void hash(ulong *nr, ulong *nr2) const;
1719
1720 /**
1721 Get the upper limit of the MySQL integral and floating-point type.
1722
1723 @return maximum allowed value for the field
1724 */
1726 assert(false);
1727 return 0ULL;
1728 }
1729
1730 /**
1731 Return a const pointer to the actual data in the record buffer.
1732
1733 For most fields, this is the same as field_ptr(), but BLOBs and VARCHARs
1734 it is not. Ideally this function should not be used as it makes it hard
1735 to change the internal representation of Field.
1736 */
1737 virtual const uchar *data_ptr() const { return ptr; }
1738
1739 /**
1740 Return a const pointer to where the field is stored in the record buffer.
1741
1742 Ideally this function should not be used as it makes it hard
1743 to change the internal representation of Field.
1744 */
1745 const uchar *field_ptr() const { return ptr; }
1746
1747 /**
1748 Return a pointer to where the field is stored in the record buffer.
1749
1750 Ideally this function should not be used as it makes it hard
1751 to change the internal representation of Field.
1752 */
1753 uchar *field_ptr() { return ptr; }
1754
1755 void set_field_ptr(uchar *ptr_arg) { ptr = ptr_arg; }
1756
1757 /**
1758 Checks whether a string field is part of write_set.
1759
1760 @return
1761 false - If field is not char/varchar/....
1762 - If field is char/varchar/.. and is not part of write set.
1763 true - If field is char/varchar/.. and is part of write set.
1764 */
1765 virtual bool is_updatable() const { return false; }
1766
1767 /**
1768 Check whether field is part of the index taking the index extensions flag
1769 into account. Index extensions are also not applicable to UNIQUE indexes
1770 for loose index scans.
1771
1772 @param[in] thd THD object
1773 @param[in] cur_index Index of the key
1774 @param[in] cur_index_info key_info object
1775
1776 @retval true Field is part of the key
1777 @retval false otherwise
1778
1779 */
1780
1781 bool is_part_of_actual_key(THD *thd, uint cur_index,
1782 KEY *cur_index_info) const;
1783
1784 /**
1785 Get covering prefix keys.
1786
1787 @retval covering prefix keys.
1788 */
1790
1791 /// Whether the field is a typed array
1792 virtual bool is_array() const { return false; }
1793
1794 /**
1795 Return number of bytes the field's length takes
1796
1797 Valid only for varchar and typed arrays of varchar
1798 */
1799 virtual uint32 get_length_bytes() const {
1800 assert(0);
1801 return 0;
1802 }
1803
1804 /**
1805 Whether field's old valued have to be handled.
1806
1807 @returns
1808 true if field is virtual an either one of BLOB types or typed array
1809 false otherwise
1810 */
1811 bool handle_old_value() const {
1812 return (is_flag_set(BLOB_FLAG) || is_array()) && is_virtual_gcol();
1813 }
1814
1815 /**
1816 Sets field index.
1817
1818 @param[in] field_index Field index.
1819 */
1822 }
1823
1824 /**
1825 Returns field index.
1826
1827 @returns Field index.
1828 */
1830
1831 private:
1832 /**
1833 Retrieve the field metadata for fields.
1834
1835 This default implementation returns 0 and saves 0 in the metadata_ptr
1836 value.
1837
1838 @param metadata_ptr First byte of field metadata
1839
1840 @returns 0 no bytes written.
1841 */
1842 virtual int do_save_field_metadata(uchar *metadata_ptr
1843 [[maybe_unused]]) const {
1844 return 0;
1845 }
1846
1847 protected:
1848 uchar *pack_int16(uchar *to, const uchar *from, size_t max_length) const;
1849
1850 const uchar *unpack_int16(uchar *to, const uchar *from) const;
1851
1852 uchar *pack_int24(uchar *to, const uchar *from, size_t max_length) const;
1853
1854 const uchar *unpack_int24(uchar *to, const uchar *from) const;
1855
1856 uchar *pack_int32(uchar *to, const uchar *from, size_t max_length) const;
1857
1858 const uchar *unpack_int32(uchar *to, const uchar *from) const;
1859
1860 uchar *pack_int64(uchar *to, const uchar *from, size_t max_length) const;
1861
1862 const uchar *unpack_int64(uchar *to, const uchar *from) const;
1863};
1864
1865/**
1866 This class is a substitute for the Field classes during CREATE TABLE
1867
1868 When adding a functional index at table creation, we need to resolve the
1869 expression we are indexing. All functions that references one or more
1870 columns expect a Field to be available. But during CREATE TABLE, we only
1871 have access to Create_field. So this class acts as a substitute for the
1872 Field classes so that expressions can be properly resolved. Thus, trying
1873 to call store or val_* on this class will cause an assertion.
1874*/
1875class Create_field_wrapper final : public Field {
1877
1878 public:
1880 Item_result result_type() const final;
1882 enum_field_types type() const final;
1883 uint32 max_display_length() const final;
1884
1885 const CHARSET_INFO *charset() const final;
1886
1887 uint32 pack_length() const final;
1888
1889 // Since it's not a real field, functions below shouldn't be used.
1890 /* purecov: begin deadcode */
1891 type_conversion_status store(const char *, size_t,
1892 const CHARSET_INFO *) final {
1893 assert(false);
1894 return TYPE_ERR_BAD_VALUE;
1895 }
1897 assert(false);
1898 return TYPE_ERR_BAD_VALUE;
1899 }
1901 assert(false);
1902 return TYPE_ERR_BAD_VALUE;
1903 }
1905 assert(false);
1906 return TYPE_ERR_BAD_VALUE;
1907 }
1908 double val_real(void) const final {
1909 assert(false);
1910 return 0.0;
1911 }
1912 longlong val_int(void) const final {
1913 assert(false);
1914 return 0;
1915 }
1917 assert(false);
1918 return nullptr;
1919 }
1920 String *val_str(String *, String *) const final {
1921 assert(false);
1922 return nullptr;
1923 }
1924 int cmp(const uchar *, const uchar *) const final {
1925 assert(false);
1926 return -1;
1927 }
1928 void sql_type(String &) const final { assert(false); }
1930 size_t make_sort_key(uchar *, size_t) const final {
1931 assert(false);
1932 return 0;
1933 }
1934 Field *clone(MEM_ROOT *mem_root) const final {
1935 return new (mem_root) Create_field_wrapper(*this);
1936 }
1937 /* purecov: end */
1938};
1939
1940class Field_num : public Field {
1941 private:
1942 /**
1943 Whether the field is signed or not. Meaningful only for numeric fields
1944 and numeric arrays.
1945 */
1946 const bool unsigned_flag;
1947
1948 public:
1949 const uint8 dec;
1950 /**
1951 True if the column was declared with the ZEROFILL attribute. If it has the
1952 attribute, values should be zero-padded up to the declared display width
1953 when they are converted to strings.
1954 */
1955 bool zerofill; // Purify cannot handle bit fields
1956 Field_num(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
1957 uchar null_bit_arg, uchar auto_flags_arg,
1958 const char *field_name_arg, uint8 dec_arg, bool zero_arg,
1959 bool unsigned_arg);
1960 bool is_unsigned() const final { return unsigned_flag; }
1961 Item_result result_type() const override { return REAL_RESULT; }
1962 enum Derivation derivation() const final { return DERIVATION_NUMERIC; }
1963 uint repertoire() const final { return MY_REPERTOIRE_NUMERIC; }
1964 const CHARSET_INFO *charset() const final { return &my_charset_numeric; }
1965 void prepend_zeros(String *value) const;
1966 uint decimals() const final { return (uint)dec; }
1967 bool eq_def(const Field *field) const final;
1970 my_decimal *val_decimal(my_decimal *) const override;
1971 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const override;
1972 bool get_time(MYSQL_TIME *ltime) const override;
1973 uint is_equal(const Create_field *new_field) const override;
1974 uint row_pack_length() const final { return pack_length(); }
1975 uint32 pack_length_from_metadata(uint) const override {
1976 return pack_length();
1977 }
1979 size_t length, const char *int_end,
1980 int error);
1981 type_conversion_status get_int(const CHARSET_INFO *cs, const char *from,
1982 size_t len, longlong *rnd,
1983 ulonglong unsigned_max, longlong signed_min,
1984 longlong signed_max);
1985};
1986
1987class Field_str : public Field {
1988 protected:
1991
1992 public:
1993 Field_str(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
1994 uchar null_bit_arg, uchar auto_flags_arg,
1995 const char *field_name_arg, const CHARSET_INFO *charset);
1996 Item_result result_type() const override { return STRING_RESULT; }
1998 uint decimals() const override { return DECIMAL_NOT_SPECIFIED; }
1999 void make_send_field(Send_field *field) const override;
2000 type_conversion_status store(double nr) override;
2001 type_conversion_status store(longlong nr, bool unsigned_val) override = 0;
2003 type_conversion_status store(const char *to, size_t length,
2004 const CHARSET_INFO *cs) override = 0;
2005
2006 uint repertoire() const final { return my_charset_repertoire(field_charset); }
2007 const CHARSET_INFO *charset() const override { return field_charset; }
2008 void set_charset(const CHARSET_INFO *charset_arg) {
2009 field_charset = charset_arg;
2011 }
2015 }
2016 enum Derivation derivation() const final { return field_derivation; }
2017 void set_derivation(enum Derivation derivation_arg) final {
2018 field_derivation = derivation_arg;
2019 }
2020 bool binary() const override { return field_charset == &my_charset_bin; }
2021 uint32 max_display_length() const override { return field_length; }
2022 bool str_needs_quotes() const final { return true; }
2023 uint is_equal(const Create_field *new_field) const override;
2024
2025 void add_to_cost(CostOfItem *cost) const override;
2026
2027 // An always-updated cache of the result of char_length(), because
2028 // dividing by charset()->mbmaxlen can be surprisingly costly compared
2029 // to the rest of e.g. make_sort_key().
2031};
2032
2033/* base class for Field_string, Field_varstring and Field_blob */
2034
2035class Field_longstr : public Field_str {
2036 private:
2038 const char *end,
2039 bool count_spaces);
2040
2041 protected:
2043 const char *well_formed_error_pos, const char *cannot_convert_error_pos,
2044 const char *from_end_pos, const char *end, bool count_spaces,
2045 const CHARSET_INFO *cs);
2046
2047 public:
2048 Field_longstr(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2049 uchar null_bit_arg, uchar auto_flags_arg,
2050 const char *field_name_arg, const CHARSET_INFO *charset_arg)
2051 : Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2052 field_name_arg, charset_arg) {}
2053
2055 uint32 max_data_length() const override;
2056 bool is_updatable() const final;
2057};
2058
2059/* base class for float and double and decimal (old one) */
2060class Field_real : public Field_num {
2061 public:
2064 TR_OK = 0,
2065 TR_POSITIVE_OVERFLOW = 1,
2066 TR_NEGATIVE_OVERFLOW = 2
2068
2069 Field_real(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2070 uchar null_bit_arg, uchar auto_flags_arg,
2071 const char *field_name_arg, uint8 dec_arg, bool zero_arg,
2072 bool unsigned_arg)
2073 : Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2074 field_name_arg, dec_arg, zero_arg, unsigned_arg),
2075 not_fixed(dec_arg >= DECIMAL_NOT_SPECIFIED) {}
2078 my_decimal *val_decimal(my_decimal *) const final;
2079 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const final;
2080 bool get_time(MYSQL_TIME *ltime) const final;
2081 Truncate_result truncate(double *nr, double max_length);
2082 Truncate_result truncate(double *nr, double max_length) const;
2083 uint32 max_display_length() const final { return field_length; }
2084 const uchar *unpack(uchar *to, const uchar *from, uint param_data) override;
2085 uchar *pack(uchar *to, const uchar *from, size_t max_length) const override;
2086};
2087
2088class Field_decimal final : public Field_real {
2089 public:
2090 Field_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2091 uchar null_bit_arg, uchar auto_flags_arg,
2092 const char *field_name_arg, uint8 dec_arg, bool zero_arg,
2093 bool unsigned_arg)
2094 : Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2095 field_name_arg, dec_arg, zero_arg, unsigned_arg) {}
2096 enum_field_types type() const final { return MYSQL_TYPE_DECIMAL; }
2097 enum ha_base_keytype key_type() const final {
2099 }
2100 type_conversion_status store(const char *to, size_t length,
2101 const CHARSET_INFO *charset) final;
2102 type_conversion_status store(double nr) final;
2103 type_conversion_status store(longlong nr, bool unsigned_val) final;
2104 double val_real() const final;
2105 longlong val_int() const final;
2106 String *val_str(String *, String *) const final;
2107 int cmp(const uchar *, const uchar *) const final;
2109 size_t make_sort_key(uchar *buff, size_t length) const final;
2110 void overflow(bool negative);
2111 bool zero_pack() const final { return false; }
2112 void sql_type(String &str) const final;
2114 assert(type() == MYSQL_TYPE_DECIMAL);
2115 return new (mem_root) Field_decimal(*this);
2116 }
2117 const uchar *unpack(uchar *to, const uchar *from, uint param_data) final {
2118 return Field::unpack(to, from, param_data);
2119 }
2120 uchar *pack(uchar *to, const uchar *from, size_t max_length) const final {
2121 return Field::pack(to, from, max_length);
2122 }
2123};
2124
2125/* New decimal/numeric field which use fixed point arithmetic */
2127 private:
2128 /**
2129 Normally, the underlying decimal code will degrade values' excessive
2130 precision. E.g. value 0.0 stored as decimal(10,4) will be returned as
2131 decimal(4,4). This is fine for general purpose, but isn't usable for
2132 multi-valued index. Field_typed_array uses a field for conversion and it
2133 expects the value read from it to be exactly same as it would be stored
2134 in SE, i.e with preserved precision. Otherwise, SE won't be able to
2135 index it.
2136 TRUE here tells underlying DECIMAL reading code to keep the precision as
2137 is.
2138 */
2139 bool m_keep_precision{false};
2140 int do_save_field_metadata(uchar *first_byte) const final;
2141
2142 public:
2143 /* The maximum number of decimal digits can be stored */
2146 /*
2147 Constructors take max_length of the field as a parameter - not the
2148 precision as the number of decimal digits allowed.
2149 So for example we need to count length from precision handling
2150 CREATE TABLE ( DECIMAL(x,y))
2151 */
2152 Field_new_decimal(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2153 uchar null_bit_arg, uchar auto_flags_arg,
2154 const char *field_name_arg, uint8 dec_arg, bool zero_arg,
2155 bool unsigned_arg);
2156 Field_new_decimal(uint32 len_arg, bool is_nullable_arg,
2157 const char *field_name_arg, uint8 dec_arg,
2158 bool unsigned_arg);
2160 enum ha_base_keytype key_type() const final { return HA_KEYTYPE_BINARY; }
2161 Item_result result_type() const final { return DECIMAL_RESULT; }
2163 type_conversion_status store_value(const my_decimal *decimal_value);
2164 void set_value_on_overflow(my_decimal *decimal_value, bool sign) const;
2165 type_conversion_status store(const char *to, size_t length,
2166 const CHARSET_INFO *charset) final;
2167 type_conversion_status store(double nr) final;
2168 type_conversion_status store(longlong nr, bool unsigned_val) final;
2171 double val_real() const final;
2172 longlong val_int() const final;
2173 my_decimal *val_decimal(my_decimal *) const final;
2174 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const final;
2175 bool get_time(MYSQL_TIME *ltime) const final;
2176 String *val_str(String *, String *) const final;
2177 int cmp(const uchar *, const uchar *) const final;
2178 using Field_num::make_sort_key;
2179 size_t make_sort_key(uchar *buff, size_t length) const final;
2180 bool zero_pack() const final { return false; }
2181 void sql_type(String &str) const final;
2182 uint32 max_display_length() const final { return field_length; }
2183 uint32 pack_length() const final { return (uint32)bin_size; }
2184 uint pack_length_from_metadata(uint field_metadata) const final;
2185 bool compatible_field_size(uint field_metadata, Relay_log_info *, uint16,
2186 int *order_var) const final;
2187 uint is_equal(const Create_field *new_field) const final;
2189 assert(type() == MYSQL_TYPE_NEWDECIMAL);
2190 return new (mem_root) Field_new_decimal(*this);
2191 }
2192 const uchar *unpack(uchar *to, const uchar *from, uint param_data) final;
2193 static Field *create_from_item(const Item *item);
2194 bool send_to_protocol(Protocol *protocol) const final;
2195 void set_keep_precision(bool arg) { m_keep_precision = arg; }
2196};
2197
2198class Field_tiny : public Field_num {
2199 public:
2200 Field_tiny(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2201 uchar null_bit_arg, uchar auto_flags_arg,
2202 const char *field_name_arg, bool zero_arg, bool unsigned_arg)
2203 : Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2204 field_name_arg, 0, zero_arg, unsigned_arg) {}
2205 Field_tiny(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
2206 bool unsigned_arg)
2207 : Field_num(nullptr, len_arg,
2208 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
2209 field_name_arg, 0, false, unsigned_arg) {}
2210 enum Item_result result_type() const final { return INT_RESULT; }
2211 enum_field_types type() const override { return MYSQL_TYPE_TINY; }
2212 enum ha_base_keytype key_type() const final {
2214 }
2215 type_conversion_status store(const char *to, size_t length,
2216 const CHARSET_INFO *charset) override;
2217 type_conversion_status store(double nr) override;
2218 type_conversion_status store(longlong nr, bool unsigned_val) override;
2219 double val_real() const override;
2220 longlong val_int() const override;
2221 String *val_str(String *, String *) const override;
2222 bool send_to_protocol(Protocol *protocol) const override;
2223 int cmp(const uchar *, const uchar *) const final;
2225 size_t make_sort_key(uchar *buff, size_t length) const final;
2226 uint32 pack_length() const final { return 1; }
2227 void sql_type(String &str) const override;
2228 uint32 max_display_length() const final { return 4; }
2229 Field_tiny *clone(MEM_ROOT *mem_root) const override {
2230 assert(type() == MYSQL_TYPE_TINY);
2231 return new (mem_root) Field_tiny(*this);
2232 }
2233 uchar *pack(uchar *to, const uchar *from, size_t max_length) const final {
2234 if (max_length > 0) *to = *from;
2235 return to + 1;
2236 }
2237
2238 const uchar *unpack(uchar *to, const uchar *from,
2239 uint param_data [[maybe_unused]]) final {
2240 *to = *from;
2241 return from + 1;
2242 }
2243
2245 return is_unsigned() ? 0xFFULL : 0x7FULL;
2246 }
2247};
2248
2249class Field_short final : public Field_num {
2250 public:
2251 Field_short(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2252 uchar null_bit_arg, uchar auto_flags_arg,
2253 const char *field_name_arg, bool zero_arg, bool unsigned_arg)
2254 : Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2255 field_name_arg, 0, zero_arg, unsigned_arg) {}
2256 Field_short(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
2257 bool unsigned_arg)
2258 : Field_num(nullptr, len_arg,
2259 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
2260 field_name_arg, 0, false, unsigned_arg) {}
2261 Field_short(uint32 len_arg, const char *field_name_arg, bool unsigned_arg)
2262 : Field_short(len_arg, false, field_name_arg, unsigned_arg) {}
2263 enum Item_result result_type() const final { return INT_RESULT; }
2264 enum_field_types type() const final { return MYSQL_TYPE_SHORT; }
2265 enum ha_base_keytype key_type() const final {
2267 }
2268 type_conversion_status store(const char *to, size_t length,
2269 const CHARSET_INFO *charset) final;
2270 type_conversion_status store(double nr) final;
2271 type_conversion_status store(longlong nr, bool unsigned_val) final;
2272 double val_real() const final;
2273 longlong val_int() const final;
2274 String *val_str(String *, String *) const final;
2275 bool send_to_protocol(Protocol *protocol) const final;
2276 int cmp(const uchar *, const uchar *) const final;
2277 using Field_num::make_sort_key;
2278 size_t make_sort_key(uchar *buff, size_t length) const final;
2279 uint32 pack_length() const final { return 2; }
2280 void sql_type(String &str) const final;
2281 uint32 max_display_length() const final { return 6; }
2283 assert(type() == MYSQL_TYPE_SHORT);
2284 return new (mem_root) Field_short(*this);
2285 }
2286 uchar *pack(uchar *to, const uchar *from, size_t max_length) const final {
2287 return pack_int16(to, from, max_length);
2288 }
2289
2290 const uchar *unpack(uchar *to, const uchar *from,
2291 uint param_data [[maybe_unused]]) final {
2292 return unpack_int16(to, from);
2293 }
2294
2296 return is_unsigned() ? 0xFFFFULL : 0x7FFFULL;
2297 }
2298};
2299
2300class Field_medium final : public Field_num {
2301 public:
2302 Field_medium(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2303 uchar null_bit_arg, uchar auto_flags_arg,
2304 const char *field_name_arg, bool zero_arg, bool unsigned_arg)
2305 : Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2306 field_name_arg, 0, zero_arg, unsigned_arg) {}
2307 Field_medium(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
2308 bool unsigned_arg)
2309 : Field_num(nullptr, len_arg,
2310 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
2311 field_name_arg, 0, false, unsigned_arg) {}
2312 enum Item_result result_type() const final { return INT_RESULT; }
2313 enum_field_types type() const final { return MYSQL_TYPE_INT24; }
2314 enum ha_base_keytype key_type() const final {
2316 }
2317 type_conversion_status store(const char *to, size_t length,
2318 const CHARSET_INFO *charset) final;
2319 type_conversion_status store(double nr) final;
2320 type_conversion_status store(longlong nr, bool unsigned_val) final;
2321 double val_real() const final;
2322 longlong val_int() const final;
2323 String *val_str(String *, String *) const final;
2324 bool send_to_protocol(Protocol *protocol) const final;
2325 int cmp(const uchar *, const uchar *) const final;
2326 using Field_num::make_sort_key;
2327 size_t make_sort_key(uchar *buff, size_t length) const final;
2328 uint32 pack_length() const final { return 3; }
2329 void sql_type(String &str) const final;
2330 uint32 max_display_length() const final { return 8; }
2332 assert(type() == MYSQL_TYPE_INT24);
2333 return new (mem_root) Field_medium(*this);
2334 }
2336 return is_unsigned() ? 0xFFFFFFULL : 0x7FFFFFULL;
2337 }
2338};
2339
2340class Field_long : public Field_num {
2341 public:
2342 static const int PACK_LENGTH = 4;
2343
2344 Field_long(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2345 uchar null_bit_arg, uchar auto_flags_arg,
2346 const char *field_name_arg, bool zero_arg, bool unsigned_arg)
2347 : Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2348 field_name_arg, 0, zero_arg, unsigned_arg) {}
2349 Field_long(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
2350 bool unsigned_arg)
2351 : Field_num(nullptr, len_arg,
2352 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
2353 field_name_arg, 0, false, unsigned_arg) {}
2354 enum Item_result result_type() const final { return INT_RESULT; }
2355 enum_field_types type() const final { return MYSQL_TYPE_LONG; }
2356 enum ha_base_keytype key_type() const final {
2358 }
2359 type_conversion_status store(const char *to, size_t length,
2360 const CHARSET_INFO *charset) final;
2361 type_conversion_status store(double nr) final;
2362 type_conversion_status store(longlong nr, bool unsigned_val) override;
2363 double val_real() const final;
2364 longlong val_int() const final;
2365 bool send_to_protocol(Protocol *protocol) const final;
2366 String *val_str(String *, String *) const final;
2367 int cmp(const uchar *, const uchar *) const final;
2368 using Field_num::make_sort_key;
2369 size_t make_sort_key(uchar *buff, size_t length) const final;
2370 uint32 pack_length() const final { return PACK_LENGTH; }
2371 void sql_type(String &str) const final;
2374 }
2376 assert(type() == MYSQL_TYPE_LONG);
2377 return new (mem_root) Field_long(*this);
2378 }
2379 uchar *pack(uchar *to, const uchar *from, size_t max_length) const final {
2380 return pack_int32(to, from, max_length);
2381 }
2382 const uchar *unpack(uchar *to, const uchar *from,
2383 uint param_data [[maybe_unused]]) final {
2384 return unpack_int32(to, from);
2385 }
2386
2388 return is_unsigned() ? 0xFFFFFFFFULL : 0x7FFFFFFFULL;
2389 }
2390};
2391
2393 public:
2394 static const int PACK_LENGTH = 8;
2395
2396 Field_longlong(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2397 uchar null_bit_arg, uchar auto_flags_arg,
2398 const char *field_name_arg, bool zero_arg, bool unsigned_arg)
2399 : Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2400 field_name_arg, 0, zero_arg, unsigned_arg) {}
2401 Field_longlong(uint32 len_arg, bool is_nullable_arg,
2402 const char *field_name_arg, bool unsigned_arg)
2403 : Field_num(nullptr, len_arg,
2404 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
2405 field_name_arg, 0, false, unsigned_arg) {}
2406 enum Item_result result_type() const final { return INT_RESULT; }
2408 enum ha_base_keytype key_type() const final {
2410 }
2411 type_conversion_status store(const char *to, size_t length,
2412 const CHARSET_INFO *charset) final;
2413 type_conversion_status store(double nr) final;
2414 type_conversion_status store(longlong nr, bool unsigned_val) override;
2415 double val_real() const final;
2416 longlong val_int() const override;
2417 String *val_str(String *, String *) const final;
2418 bool send_to_protocol(Protocol *protocol) const final;
2419 int cmp(const uchar *, const uchar *) const final;
2420 using Field_num::make_sort_key;
2421 size_t make_sort_key(uchar *buff, size_t length) const final;
2422 uint32 pack_length() const final { return PACK_LENGTH; }
2423 void sql_type(String &str) const final;
2424 bool can_be_compared_as_longlong() const final { return true; }
2425 uint32 max_display_length() const final { return 20; }
2427 assert(type() == MYSQL_TYPE_LONGLONG);
2428 return new (mem_root) Field_longlong(*this);
2429 }
2430 uchar *pack(uchar *to, const uchar *from, size_t max_length) const final {
2431 return pack_int64(to, from, max_length);
2432 }
2433 const uchar *unpack(uchar *to, const uchar *from,
2434 uint param_data [[maybe_unused]]) final {
2435 return unpack_int64(to, from);
2436 }
2437
2439 return is_unsigned() ? 0xFFFFFFFFFFFFFFFFULL : 0x7FFFFFFFFFFFFFFFULL;
2440 }
2441};
2442
2443class Field_float final : public Field_real {
2444 public:
2445 Field_float(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2446 uchar null_bit_arg, uchar auto_flags_arg,
2447 const char *field_name_arg, uint8 dec_arg, bool zero_arg,
2448 bool unsigned_arg)
2449 : Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2450 field_name_arg, dec_arg, zero_arg, unsigned_arg) {}
2451 Field_float(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
2452 uint8 dec_arg, bool unsigned_arg)
2453 : Field_real(nullptr, len_arg,
2454 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
2455 field_name_arg, dec_arg, false, unsigned_arg) {}
2456 enum_field_types type() const final { return MYSQL_TYPE_FLOAT; }
2457 enum ha_base_keytype key_type() const final { return HA_KEYTYPE_FLOAT; }
2458 type_conversion_status store(const char *to, size_t length,
2459 const CHARSET_INFO *charset) final;
2460 type_conversion_status store(double nr) final;
2461 type_conversion_status store(longlong nr, bool unsigned_val) final;
2462 double val_real() const final;
2463 longlong val_int() const final;
2464 String *val_str(String *, String *) const final;
2465 bool send_to_protocol(Protocol *protocol) const final;
2466 int cmp(const uchar *, const uchar *) const final;
2468 size_t make_sort_key(uchar *buff, size_t length) const final;
2469 uint32 pack_length() const final { return sizeof(float); }
2470 void sql_type(String &str) const final;
2472 assert(type() == MYSQL_TYPE_FLOAT);
2473 return new (mem_root) Field_float(*this);
2474 }
2475
2477 /*
2478 We use the maximum as per IEEE754-2008 standard, 2^24
2479 */
2480 return 0x1000000ULL;
2481 }
2482
2483 private:
2484 int do_save_field_metadata(uchar *first_byte) const final;
2485};
2486
2487class Field_double final : public Field_real {
2488 public:
2489 Field_double(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2490 uchar null_bit_arg, uchar auto_flags_arg,
2491 const char *field_name_arg, uint8 dec_arg, bool zero_arg,
2492 bool unsigned_arg)
2493 : Field_real(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2494 field_name_arg, dec_arg, zero_arg, unsigned_arg) {}
2495 Field_double(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
2496 uint8 dec_arg)
2497 : Field_real(nullptr, len_arg,
2498 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
2499 field_name_arg, dec_arg, false, false) {}
2500 Field_double(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
2501 uint8 dec_arg, bool unsigned_arg)
2502 : Field_real(nullptr, len_arg,
2503 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
2504 field_name_arg, dec_arg, false, unsigned_arg) {}
2505 Field_double(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
2506 uint8 dec_arg, bool unsigned_arg, bool not_fixed_arg)
2507 : Field_real(nullptr, len_arg,
2508 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
2509 field_name_arg, dec_arg, false, unsigned_arg) {
2510 not_fixed = not_fixed_arg;
2511 }
2512 enum_field_types type() const final { return MYSQL_TYPE_DOUBLE; }
2513 enum ha_base_keytype key_type() const final { return HA_KEYTYPE_DOUBLE; }
2514 type_conversion_status store(const char *to, size_t length,
2515 const CHARSET_INFO *charset) final;
2516 type_conversion_status store(double nr) final;
2517 type_conversion_status store(longlong nr, bool unsigned_val) final;
2518 double val_real() const final;
2519 longlong val_int() const final;
2520 String *val_str(String *, String *) const final;
2521 bool send_to_protocol(Protocol *protocol) const final;
2522 int cmp(const uchar *, const uchar *) const final;
2524 size_t make_sort_key(uchar *buff, size_t length) const final;
2525 uint32 pack_length() const final { return sizeof(double); }
2526 void sql_type(String &str) const final;
2528 assert(type() == MYSQL_TYPE_DOUBLE);
2529 return new (mem_root) Field_double(*this);
2530 }
2531
2533 /*
2534 We use the maximum as per IEEE754-2008 standard, 2^53
2535 */
2536 return 0x20000000000000ULL;
2537 }
2538
2539 private:
2540 int do_save_field_metadata(uchar *first_byte) const final;
2541};
2542
2543/* Everything saved in this will disappear. It will always return NULL */
2544
2545class Field_null final : public Field_str {
2546 public:
2547 Field_null(uchar *ptr_arg, uint32 len_arg, uchar auto_flags_arg,
2548 const char *field_name_arg, const CHARSET_INFO *cs)
2549 // (dummy_null_buffer & 32) is true, so is_null() always returns true.
2550 : Field_str(ptr_arg, len_arg, &dummy_null_buffer, 32, auto_flags_arg,
2551 field_name_arg, cs) {}
2552 enum_field_types type() const final { return MYSQL_TYPE_NULL; }
2553 type_conversion_status store(const char *, size_t,
2554 const CHARSET_INFO *) final {
2555 return TYPE_OK;
2556 }
2557 type_conversion_status store(double) final { return TYPE_OK; }
2560 return TYPE_OK;
2561 }
2563 double val_real() const final { return 0.0; }
2564 longlong val_int() const final { return 0; }
2565 my_decimal *val_decimal(my_decimal *) const final { return nullptr; }
2566 String *val_str(String *, String *value2) const final {
2567 value2->length(0);
2568 return value2;
2569 }
2570 int cmp(const uchar *, const uchar *) const final { return 0; }
2572 size_t make_sort_key(uchar *, size_t len) const final { return len; }
2573 uint32 pack_length() const final { return 0; }
2574 void sql_type(String &str) const final;
2575 uint32 max_display_length() const final { return 4; }
2577 assert(type() == MYSQL_TYPE_NULL);
2578 return new (mem_root) Field_null(*this);
2579 }
2580};
2581
2582/*
2583 Abstract class for TIME, DATE, DATETIME, TIMESTAMP
2584 with and without fractional part.
2585*/
2586class Field_temporal : public Field {
2587 protected:
2588 uint8 dec; // Number of fractional digits
2589
2590 /**
2591 Adjust number of decimal digits from DECIMAL_NOT_SPECIFIED to
2592 DATETIME_MAX_DECIMALS
2593 */
2594 static uint8 normalize_dec(uint8 dec_arg) {
2595 return dec_arg == DECIMAL_NOT_SPECIFIED ? DATETIME_MAX_DECIMALS : dec_arg;
2596 }
2597
2598 /**
2599 Low level routine to store a MYSQL_TIME value into a field.
2600 The value must be already properly rounded or truncated
2601 and checked for being a valid TIME/DATE/DATETIME value.
2602
2603 @param[in] ltime MYSQL_TIME value.
2604 @param[out] error Error flag vector, set in case of error.
2605 @retval false In case of success.
2606 @retval true In case of error.
2607 */
2609 int *error) = 0;
2610
2611 /**
2612 Low level routine to store a MYSQL_TIME value into a field
2613 with rounding/truncation according to the field decimals() value and
2614 sql_mode.
2615
2616 @param[in] ltime MYSQL_TIME value.
2617 @param[out] warnings Error flag vector, set in case of error.
2618 @retval false In case of success.
2619 @retval true In case of error.
2620 */
2622 int *warnings) = 0;
2623
2624 /**
2625 Store a temporal value in lldiv_t into a field,
2626 with rounding according to the field decimals() value.
2627
2628 @param[in] lld Temporal value.
2629 @param[out] warning Warning flag vector.
2630 @retval false In case of success.
2631 @retval true In case of error.
2632 */
2633 type_conversion_status store_lldiv_t(const lldiv_t *lld, int *warning);
2634
2635 /**
2636 Convert a string to MYSQL_TIME, according to the field type.
2637
2638 @param[in] str String
2639 @param[in] len String length
2640 @param[in] cs String character set
2641 @param[out] ltime The value is stored here
2642 @param[out] status Conversion status
2643 @retval false Conversion went fine, ltime contains a valid time
2644 @retval true Conversion failed, ltime was reset and contains nothing
2645 */
2646 virtual bool convert_str_to_TIME(const char *str, size_t len,
2647 const CHARSET_INFO *cs, MYSQL_TIME *ltime,
2649 /**
2650 Convert a number with fractional part with nanosecond precision
2651 into MYSQL_TIME, according to the field type. Nanoseconds
2652 are rounded to milliseconds and added to ltime->second_part.
2653
2654 @param[in] nr Number
2655 @param[in] unsigned_val SIGNED/UNSIGNED flag
2656 @param[in] nanoseconds Fractional part in nanoseconds
2657 @param[out] ltime The value is stored here
2658 @param[in,out] warning Warnings found during execution
2659
2660 @return Conversion status
2661 @retval false On success
2662 @retval true On error
2663 */
2665 bool unsigned_val,
2666 int nanoseconds,
2667 MYSQL_TIME *ltime,
2668 int *warning) = 0;
2669
2670 /**
2671 Convert an integer number into MYSQL_TIME, according to the field type.
2672
2673 @param[in] nr Number
2674 @param[in] unsigned_val SIGNED/UNSIGNED flag
2675 @param[out] ltime The value is stored here
2676 @param[in,out] warnings Warnings found during execution
2677
2678 @retval false On success
2679 @retval true On error
2680 */
2681 longlong convert_number_to_datetime(longlong nr, bool unsigned_val,
2682 MYSQL_TIME *ltime, int *warnings);
2683
2684 /**
2685 Set warnings from a warning vector.
2686 Note, multiple warnings can be set at the same time.
2687 Every warning in the bit vector is set by an individual
2688 set_datetime_warning() call.
2689
2690 @param str Value.
2691 @param warnings Warning vector.
2692
2693 @retval false Function reported warning
2694 @retval true Function reported error
2695
2696 @note STRICT mode can convert warnings to error.
2697 */
2698 [[nodiscard]] bool set_warnings(const ErrConvString &str, int warnings);
2699
2700 /**
2701 Flags that are passed as "flag" argument to
2702 check_date(), number_to_datetime(), str_to_datetime().
2703
2704 Flags depend on the session sql_mode settings, such as
2705 MODE_NO_ZERO_DATE, MODE_NO_ZERO_IN_DATE.
2706 Also, Field_newdate, Field_datetime, Field_datetimef add TIME_FUZZY_DATE
2707 to the session sql_mode settings, to allow relaxed date format,
2708 while Field_timestamp, Field_timestampf do not.
2709
2710 @param thd THD
2711 @retval sql_mode flags mixed with the field type flags.
2712 */
2713 virtual my_time_flags_t date_flags(const THD *thd [[maybe_unused]]) const {
2714 return 0;
2715 }
2716
2717 /**
2718 Flags that are passed as "flag" argument to
2719 check_date(), number_to_datetime(), str_to_datetime().
2720 Similar to the above when we don't have a THD value.
2721 */
2722 my_time_flags_t date_flags() const;
2723
2724 /**
2725 Produce warning or note about double datetime data saved into field.
2726
2727 @param level level of message (Note/Warning/Error)
2728 @param code error code of message to be produced
2729 @param val error parameter (the value)
2730 @param ts_type type of datetime value (datetime/date/time)
2731 @param truncate_increment whether we should increase truncated fields count
2732
2733 @retval false Function reported warning
2734 @retval true Function reported error
2735
2736 @note
2737 This function will always produce some warning but won't increase
2738 truncated fields counter if check_for_truncated_fields == FIELD_CHECK_IGNORE
2739 for current thread.
2740 */
2741 [[nodiscard]] bool set_datetime_warning(
2742 Sql_condition::enum_severity_level level, uint code,
2743 const ErrConvString &val, enum_mysql_timestamp_type ts_type,
2744 int truncate_increment);
2745
2746 public:
2747 /**
2748 Constructor for Field_temporal
2749 @param ptr_arg See Field definition
2750 @param null_ptr_arg See Field definition
2751 @param null_bit_arg See Field definition
2752 @param auto_flags_arg See Field definition
2753 @param field_name_arg See Field definition
2754 @param len_arg Number of characters in the integer part.
2755 @param dec_arg Number of second fraction digits, 0..6.
2756 */
2757 Field_temporal(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
2758 uchar auto_flags_arg, const char *field_name_arg,
2759 uint32 len_arg, uint8 dec_arg)
2760 : Field(ptr_arg,
2761 len_arg +
2762 ((normalize_dec(dec_arg)) ? normalize_dec(dec_arg) + 1 : 0),
2763 null_ptr_arg, null_bit_arg, auto_flags_arg, field_name_arg) {
2765 dec = normalize_dec(dec_arg);
2766 }
2767 Item_result result_type() const final { return STRING_RESULT; }
2768 uint32 max_display_length() const final { return field_length; }
2769 bool str_needs_quotes() const final { return true; }
2770 uint is_equal(const Create_field *new_field) const final;
2772 return dec ? DECIMAL_RESULT : INT_RESULT;
2773 }
2774 enum Item_result cmp_type() const final { return INT_RESULT; }
2775 enum Derivation derivation() const final { return DERIVATION_NUMERIC; }
2776 uint repertoire() const final { return MY_REPERTOIRE_NUMERIC; }
2777 const CHARSET_INFO *charset() const final { return &my_charset_numeric; }
2778 bool can_be_compared_as_longlong() const final { return true; }
2779 bool binary() const final { return true; }
2780 type_conversion_status store(const char *str, size_t len,
2781 const CHARSET_INFO *cs) final;
2783 type_conversion_status store(longlong nr, bool unsigned_val) override;
2784 type_conversion_status store(double nr) final;
2785 double val_real() const override // FSP-enable types redefine it.
2786 {
2787 return (double)val_int();
2788 }
2789 [[nodiscard]] uint8 get_dec() const { return dec; }
2791 my_decimal *decimal_value) const override; // FSP types redefine it
2792
2794 return date_flags(thd);
2795 }
2796
2797 uint8 get_fractional_digits() const { return dec; }
2798};
2799
2800/**
2801 Abstract class for types with date
2802 with optional time, with or without fractional part:
2803 DATE, DATETIME, DATETIME(N), TIMESTAMP, TIMESTAMP(N).
2804*/
2806 protected:
2807 /**
2808 Low level function to get value into MYSQL_TIME,
2809 without checking for being valid.
2810 */
2811 virtual bool get_date_internal(MYSQL_TIME *ltime) const = 0;
2812
2813 virtual bool get_date_internal_at_utc(MYSQL_TIME *ltime) const {
2814 return get_date_internal(ltime);
2815 }
2816
2817 /**
2818 Get value into MYSQL_TIME and check TIME_NO_ZERO_DATE flag.
2819 @retval True on error: we get a zero value but flags disallow zero dates.
2820 @retval False on success.
2821 */
2822 bool get_internal_check_zero(MYSQL_TIME *ltime,
2823 my_time_flags_t fuzzydate) const;
2824
2825 type_conversion_status convert_number_to_TIME(longlong nr, bool unsigned_val,
2826 int nanoseconds,
2827 MYSQL_TIME *ltime,
2828 int *warning) final;
2829 bool convert_str_to_TIME(const char *str, size_t len, const CHARSET_INFO *cs,
2830 MYSQL_TIME *ltime, MYSQL_TIME_STATUS *status) final;
2831
2832 type_conversion_status store_internal_adjust_frac(MYSQL_TIME *ltime,
2833 int *warnings) final;
2835
2836 public:
2837 /**
2838 Constructor for Field_temporal
2839 @param ptr_arg See Field definition
2840 @param null_ptr_arg See Field definition
2841 @param null_bit_arg See Field definition
2842 @param auto_flags_arg See Field definition
2843 @param field_name_arg See Field definition
2844 @param int_length_arg Number of characters in the integer part.
2845 @param dec_arg Number of second fraction digits, 0..6.
2846 */
2847 Field_temporal_with_date(uchar *ptr_arg, uchar *null_ptr_arg,
2848 uchar null_bit_arg, uchar auto_flags_arg,
2849 const char *field_name_arg, uint8 int_length_arg,
2850 uint8 dec_arg)
2851 : Field_temporal(ptr_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
2852 field_name_arg, int_length_arg, dec_arg) {}
2853 bool send_to_protocol(Protocol *protocol) const override;
2855 String *val_str(String *, String *) const override;
2856 longlong val_time_temporal() const override;
2857 longlong val_date_temporal() const override;
2858 longlong val_time_temporal_at_utc() const override;
2859 longlong val_date_temporal_at_utc() const override;
2860 bool get_time(MYSQL_TIME *ltime) const final {
2861 return get_date(ltime, TIME_FUZZY_DATE);
2862 }
2863 /* Validate the value stored in a field */
2865};
2866
2867/**
2868 Abstract class for types with date and time,
2869 with or without fractional part:
2870 DATETIME, DATETIME(N), TIMESTAMP, TIMESTAMP(N).
2871*/
2873 private:
2874 int do_save_field_metadata(uchar *metadata_ptr) const override {
2875 if (decimals()) {
2876 *metadata_ptr = decimals();
2877 return 1;
2878 }
2879 return 0;
2880 }
2881
2882 protected:
2883 /**
2884 Initialize flags for TIMESTAMP DEFAULT CURRENT_TIMESTAMP / ON UPDATE
2885 CURRENT_TIMESTAMP columns.
2886
2887 @todo get rid of TIMESTAMP_FLAG and ON_UPDATE_NOW_FLAG.
2888 */
2889 void init_timestamp_flags();
2890 /**
2891 Store "struct timeval" value into field.
2892 The value must be properly rounded or truncated according
2893 to the number of fractional second digits.
2894 */
2895 virtual void store_timestamp_internal(const my_timeval *tm) = 0;
2896 bool convert_TIME_to_timestamp(const MYSQL_TIME *ltime, const Time_zone &tz,
2897 my_timeval *tm, int *error);
2898
2899 public:
2900 /**
2901 Constructor for Field_temporal_with_date_and_time
2902 @param ptr_arg See Field definition
2903 @param null_ptr_arg See Field definition
2904 @param null_bit_arg See Field definition
2905 @param auto_flags_arg See Field definition
2906 @param field_name_arg See Field definition
2907 @param dec_arg Number of second fraction digits, 0..6.
2908 */
2910 uchar null_bit_arg, uchar auto_flags_arg,
2911 const char *field_name_arg, uint8 dec_arg)
2912 : Field_temporal_with_date(ptr_arg, null_ptr_arg, null_bit_arg,
2913 auto_flags_arg, field_name_arg,
2914 MAX_DATETIME_WIDTH, dec_arg) {}
2915 void store_timestamp(const my_timeval *tm) override;
2916};
2917
2918/**
2919 Abstract class for types with date and time, with fractional part:
2920 DATETIME, DATETIME(N), TIMESTAMP, TIMESTAMP(N).
2921*/
2924 private:
2925 int do_save_field_metadata(uchar *metadata_ptr) const final {
2926 *metadata_ptr = decimals();
2927 return 1;
2928 }
2929
2930 public:
2931 /**
2932 Constructor for Field_temporal_with_date_and_timef
2933 @param ptr_arg See Field definition
2934 @param null_ptr_arg See Field definition
2935 @param null_bit_arg See Field definition
2936 @param auto_flags_arg See Field definition
2937 @param field_name_arg See Field definition
2938 @param dec_arg Number of second fraction digits, 0..6.
2939 */
2941 uchar null_bit_arg, uchar auto_flags_arg,
2942 const char *field_name_arg, uint8 dec_arg)
2943 : Field_temporal_with_date_and_time(ptr_arg, null_ptr_arg, null_bit_arg,
2944 auto_flags_arg, field_name_arg,
2945 dec_arg) {}
2946
2947 uint decimals() const final { return dec; }
2948 const CHARSET_INFO *sort_charset() const final { return &my_charset_bin; }
2950 size_t make_sort_key(uchar *to, size_t length) const final {
2951 memcpy(to, ptr, length);
2952 return length;
2953 }
2954 int cmp(const uchar *a_ptr, const uchar *b_ptr) const final {
2955 return memcmp(a_ptr, b_ptr, pack_length());
2956 }
2957 uint row_pack_length() const final { return pack_length(); }
2958 double val_real() const final;
2959 longlong val_int() const final;
2960 my_decimal *val_decimal(my_decimal *decimal_value) const final;
2961};
2962
2963/*
2964 Field implementing TIMESTAMP data type without fractional seconds.
2965 We will be removed eventually.
2966*/
2968 protected:
2969 my_time_flags_t date_flags(const THD *thd) const final;
2970 type_conversion_status store_internal(const MYSQL_TIME *ltime,
2971 int *error) final;
2972 bool get_date_internal(MYSQL_TIME *ltime) const final;
2973 bool get_date_internal_at_utc(MYSQL_TIME *ltime) const final;
2974 void store_timestamp_internal(const my_timeval *tm) final;
2975
2976 public:
2977 static const int PACK_LENGTH = 4;
2978 Field_timestamp(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
2979 uchar null_bit_arg, uchar auto_flags_arg,
2980 const char *field_name_arg);
2981 Field_timestamp(bool is_nullable_arg, const char *field_name_arg);
2983 enum ha_base_keytype key_type() const final { return HA_KEYTYPE_ULONG_INT; }
2985 longlong val_int() const final;
2986 int cmp(const uchar *, const uchar *) const final;
2988 size_t make_sort_key(uchar *buff, size_t length) const final;
2989 uint32 pack_length() const final { return PACK_LENGTH; }
2990 void sql_type(String &str) const final;
2991 bool zero_pack() const final { return false; }
2992 /* Get TIMESTAMP field value as seconds since begging of Unix Epoch */
2993 bool get_timestamp(my_timeval *tm, int *warnings) const final;
2994 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const final;
2996 assert(type() == MYSQL_TYPE_TIMESTAMP);
2997 return new (mem_root) Field_timestamp(*this);
2998 }
2999 uchar *pack(uchar *to, const uchar *from, size_t max_length) const final {
3000 return pack_int32(to, from, max_length);
3001 }
3002 const uchar *unpack(uchar *to, const uchar *from,
3003 uint param_data [[maybe_unused]]) final {
3004 return unpack_int32(to, from);
3005 }
3006 /* Validate the value stored in a field */
3008
3009 private:
3010 /**
3011 Retrieves a value from a record, without checking fuzzy date flags.
3012
3013 @param tz The time zone to convert to
3014 @param[out] ltime The timestamp value in the time zone.
3015
3016 @retval true Means that the timestamp value read is 0. ltime is not touched
3017 in this case.
3018 @retval false If timestamp is non-zero.
3019 */
3020 bool get_date_internal_at(const Time_zone *tz, MYSQL_TIME *ltime) const;
3021};
3022
3023/*
3024 Field implementing TIMESTAMP(N) data type, where N=0..6.
3025*/
3027 protected:
3028 bool get_date_internal(MYSQL_TIME *ltime) const final;
3029 bool get_date_internal_at_utc(MYSQL_TIME *ltime) const final;
3030 type_conversion_status store_internal(const MYSQL_TIME *ltime,
3031 int *error) final;
3032 my_time_flags_t date_flags(const THD *thd) const final;
3033 void store_timestamp_internal(const my_timeval *tm) override;
3034
3035 public:
3036 /**
3037 Field_timestampf constructor
3038 @param ptr_arg See Field definition
3039 @param null_ptr_arg See Field definition
3040 @param null_bit_arg See Field definition
3041 @param auto_flags_arg See Field definition
3042 @param field_name_arg See Field definition
3043 @param dec_arg Number of fractional second digits, 0..6.
3044 */
3045 Field_timestampf(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
3046 uchar auto_flags_arg, const char *field_name_arg,
3047 uint8 dec_arg);
3048 /**
3049 Field_timestampf constructor
3050 @param is_nullable_arg See Field definition
3051 @param field_name_arg See Field definition
3052 @param dec_arg Number of fractional second digits, 0..6.
3053 */
3054 Field_timestampf(bool is_nullable_arg, const char *field_name_arg,
3055 uint8 dec_arg);
3057 assert(type() == MYSQL_TYPE_TIMESTAMP);
3058 return new (mem_root) Field_timestampf(*this);
3059 }
3060
3064 bool zero_pack() const final { return false; }
3065
3067 uint pack_length_from_metadata(uint field_metadata) const final {
3068 DBUG_TRACE;
3069 const uint tmp = my_timestamp_binary_length(field_metadata);
3070 return tmp;
3071 }
3072
3074 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const final;
3075 void sql_type(String &str) const final;
3076
3077 bool get_timestamp(my_timeval *tm, int *warnings) const final;
3078 /* Validate the value stored in a field */
3080
3081 private:
3082 /**
3083 Retrieves a value from a record, without checking fuzzy date flags.
3084
3085 @param tz The time zone to convert to
3086 @param[out] ltime The timestamp value in the time zone.
3087
3088 @retval true Means that the timestamp value read is 0. ltime is not touched
3089 in this case.
3090 @retval false If timestamp is non-zero.
3091 */
3092 bool get_date_internal_at(const Time_zone *tz, MYSQL_TIME *ltime) const;
3093};
3094
3095class Field_year final : public Field_tiny {
3096 public:
3097 enum Limits { MIN_YEAR = 1901, MAX_YEAR = 2155 };
3098 Field_year(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
3099 uchar auto_flags_arg, const char *field_name_arg)
3100 : Field_tiny(ptr_arg, 4, null_ptr_arg, null_bit_arg, auto_flags_arg,
3101 field_name_arg, true, true) {}
3102 Field_year(bool is_nullable_arg, const char *field_name_arg)
3103 : Field_tiny(nullptr, 4, is_nullable_arg ? &dummy_null_buffer : nullptr,
3104 0, NONE, field_name_arg, true, true) {}
3105 enum_field_types type() const final { return MYSQL_TYPE_YEAR; }
3106 type_conversion_status store(const char *to, size_t length,
3107 const CHARSET_INFO *charset) final;
3108 type_conversion_status store(double nr) final;
3109 type_conversion_status store(longlong nr, bool unsigned_val) final;
3111 double val_real() const final;
3112 longlong val_int() const final;
3113 String *val_str(String *, String *) const final;
3114 bool send_to_protocol(Protocol *protocol) const final;
3115 void sql_type(String &str) const final;
3116 bool can_be_compared_as_longlong() const final { return true; }
3118 assert(type() == MYSQL_TYPE_YEAR);
3119 return new (mem_root) Field_year(*this);
3120 }
3121};
3122
3124 protected:
3125 static const int PACK_LENGTH = 3;
3126 my_time_flags_t date_flags(const THD *thd) const final;
3127 bool get_date_internal(MYSQL_TIME *ltime) const final;
3128 type_conversion_status store_internal(const MYSQL_TIME *ltime,
3129 int *error) final;
3130
3131 public:
3132 Field_newdate(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
3133 uchar auto_flags_arg, const char *field_name_arg)
3134 : Field_temporal_with_date(ptr_arg, null_ptr_arg, null_bit_arg,
3135 auto_flags_arg, field_name_arg, MAX_DATE_WIDTH,
3136 0) {}
3137 Field_newdate(bool is_nullable_arg, const char *field_name_arg)
3139 is_nullable_arg ? &dummy_null_buffer : nullptr,
3140 0, NONE, field_name_arg, MAX_DATE_WIDTH, 0) {}
3141 enum_field_types type() const final { return MYSQL_TYPE_DATE; }
3143 enum ha_base_keytype key_type() const final { return HA_KEYTYPE_UINT24; }
3145 longlong val_int() const final;
3146 longlong val_time_temporal() const final;
3147 longlong val_date_temporal() const final;
3148 String *val_str(String *, String *) const final;
3149 bool send_to_protocol(Protocol *protocol) const final;
3150 int cmp(const uchar *, const uchar *) const final;
3152 size_t make_sort_key(uchar *buff, size_t length) const final;
3153 uint32 pack_length() const final { return PACK_LENGTH; }
3154 void sql_type(String &str) const final;
3155 bool zero_pack() const final { return true; }
3156 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const final;
3158 assert(type() == MYSQL_TYPE_DATE);
3159 assert(real_type() == MYSQL_TYPE_NEWDATE);
3160 return new (mem_root) Field_newdate(*this);
3161 }
3162};
3163
3164/**
3165 Abstract class for TIME and TIME(N).
3166*/
3168 protected:
3169 bool convert_str_to_TIME(const char *str, size_t len, const CHARSET_INFO *cs,
3170 MYSQL_TIME *ltime, MYSQL_TIME_STATUS *status) final;
3171 /**
3172 @todo: convert_number_to_TIME returns conversion status through
3173 two different interfaces: return value and warning. It should be
3174 refactored to only use return value.
3175 */
3176 type_conversion_status convert_number_to_TIME(longlong nr, bool unsigned_val,
3177 int nanoseconds,
3178 MYSQL_TIME *ltime,
3179 int *warning) final;
3180 /**
3181 Low-level function to store MYSQL_TIME value.
3182 The value must be rounded or truncated according to decimals().
3183 */
3185 int *error) override = 0;
3186 /**
3187 Function to store time value.
3188 The value is rounded/truncated according to decimals() and sql_mode.
3189 */
3190 type_conversion_status store_internal_adjust_frac(MYSQL_TIME *ltime,
3191 int *warnings) final;
3192
3193 my_time_flags_t date_flags(const THD *thd) const final;
3195
3196 public:
3197 /**
3198 Constructor for Field_time_common
3199 @param ptr_arg See Field definition
3200 @param null_ptr_arg See Field definition
3201 @param null_bit_arg See Field definition
3202 @param auto_flags_arg See Field definition
3203 @param field_name_arg See Field definition
3204 @param dec_arg Number of second fraction digits, 0..6.
3205 */
3206 Field_time_common(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
3207 uchar auto_flags_arg, const char *field_name_arg,
3208 uint8 dec_arg)
3209 : Field_temporal(ptr_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
3210 field_name_arg, MAX_TIME_WIDTH, dec_arg) {}
3212 String *val_str(String *, String *) const final;
3213 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const final;
3214 longlong val_date_temporal() const final;
3215 bool send_to_protocol(Protocol *protocol) const final;
3216};
3217
3218/*
3219 Field implementing TIME data type without fractional seconds.
3220 It will be removed eventually.
3221*/
3222class Field_time final : public Field_time_common {
3223 protected:
3224 type_conversion_status store_internal(const MYSQL_TIME *ltime,
3225 int *error) final;
3226
3227 public:
3228 Field_time(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
3229 uchar auto_flags_arg, const char *field_name_arg)
3230 : Field_time_common(ptr_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
3231 field_name_arg, 0) {}
3232 Field_time(const char *field_name_arg)
3233 : Field_time_common(nullptr, nullptr, 0, NONE, field_name_arg, 0) {}
3234 enum_field_types type() const final { return MYSQL_TYPE_TIME; }
3235 enum ha_base_keytype key_type() const final { return HA_KEYTYPE_INT24; }
3237 longlong val_int() const final;
3238 longlong val_time_temporal() const final;
3239 bool get_time(MYSQL_TIME *ltime) const final;
3240 int cmp(const uchar *, const uchar *) const final;
3242 size_t make_sort_key(uchar *buff, size_t length) const final;
3243 uint32 pack_length() const final { return 3; }
3244 void sql_type(String &str) const final;
3245 bool zero_pack() const final { return true; }
3247 assert(type() == MYSQL_TYPE_TIME);
3248 return new (mem_root) Field_time(*this);
3249 }
3250};
3251
3252/*
3253 Field implementing TIME(N) data type, where N=0..6.
3254*/
3255class Field_timef final : public Field_time_common {
3256 private:
3257 int do_save_field_metadata(uchar *metadata_ptr) const final {
3258 *metadata_ptr = decimals();
3259 return 1;
3260 }
3261
3262 protected:
3263 type_conversion_status store_internal(const MYSQL_TIME *ltime,
3264 int *error) final;
3265
3266 public:
3267 /**
3268 Constructor for Field_timef
3269 @param ptr_arg See Field definition
3270 @param null_ptr_arg See Field definition
3271 @param null_bit_arg See Field definition
3272 @param auto_flags_arg See Field definition
3273 @param field_name_arg See Field definition
3274 @param dec_arg Number of second fraction digits, 0..6.
3275 */
3276 Field_timef(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
3277 uchar auto_flags_arg, const char *field_name_arg, uint8 dec_arg)
3278 : Field_time_common(ptr_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
3279 field_name_arg, dec_arg) {}
3280 /**
3281 Constructor for Field_timef
3282 @param is_nullable_arg See Field definition
3283 @param field_name_arg See Field definition
3284 @param dec_arg Number of second fraction digits, 0..6.
3285 */
3286 Field_timef(bool is_nullable_arg, const char *field_name_arg, uint8 dec_arg)
3288 is_nullable_arg ? &dummy_null_buffer : nullptr, 0,
3289 NONE, field_name_arg, dec_arg) {}
3291 assert(type() == MYSQL_TYPE_TIME);
3292 return new (mem_root) Field_timef(*this);
3293 }
3294 uint decimals() const final { return dec; }
3295 enum_field_types type() const final { return MYSQL_TYPE_TIME; }
3300 double val_real() const final;
3301 longlong val_int() const final;
3302 longlong val_time_temporal() const final;
3303 bool get_time(MYSQL_TIME *ltime) const final;
3304 my_decimal *val_decimal(my_decimal *) const final;
3305 uint32 pack_length() const final { return my_time_binary_length(dec); }
3306 uint pack_length_from_metadata(uint field_metadata) const final {
3307 DBUG_TRACE;
3308 const uint tmp = my_time_binary_length(field_metadata);
3309 return tmp;
3310 }
3311 uint row_pack_length() const final { return pack_length(); }
3312 void sql_type(String &str) const final;
3313 bool zero_pack() const final { return true; }
3314 const CHARSET_INFO *sort_charset() const final { return &my_charset_bin; }
3316 size_t make_sort_key(uchar *to, size_t length) const final {
3317 memcpy(to, ptr, length);
3318 return length;
3319 }
3320 int cmp(const uchar *a_ptr, const uchar *b_ptr) const final {
3321 return memcmp(a_ptr, b_ptr, pack_length());
3322 }
3323};
3324
3325/*
3326 Field implementing DATETIME data type without fractional seconds.
3327 We will be removed eventually.
3328*/
3330 protected:
3331 type_conversion_status store_internal(const MYSQL_TIME *ltime,
3332 int *error) final;
3333 bool get_date_internal(MYSQL_TIME *ltime) const final;
3334 my_time_flags_t date_flags(const THD *thd) const final;
3335 void store_timestamp_internal(const my_timeval *tm) final;
3336
3337 public:
3338 static const int PACK_LENGTH = 8;
3339
3340 /**
3341 DATETIME columns can be defined as having CURRENT_TIMESTAMP as the
3342 default value on inserts or updates. This constructor accepts a
3343 auto_flags argument which controls the column default expressions.
3344
3345 For DATETIME columns this argument is a bitmap combining two flags:
3346
3347 - DEFAULT_NOW - means that column has DEFAULT CURRENT_TIMESTAMP attribute.
3348 - ON_UPDATE_NOW - means that column has ON UPDATE CURRENT_TIMESTAMP.
3349
3350 (these two flags can be used orthogonally to each other).
3351 */
3352 Field_datetime(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
3353 uchar auto_flags_arg, const char *field_name_arg)
3354 : Field_temporal_with_date_and_time(ptr_arg, null_ptr_arg, null_bit_arg,
3355 auto_flags_arg, field_name_arg, 0) {}
3356 Field_datetime(const char *field_name_arg)
3358 field_name_arg, 0) {}
3360 enum ha_base_keytype key_type() const final { return HA_KEYTYPE_ULONGLONG; }
3361 using Field_temporal_with_date_and_time::store; // Make -Woverloaded-virtual
3362 type_conversion_status store(longlong nr, bool unsigned_val) final;
3364 longlong val_int() const final;
3365 String *val_str(String *, String *) const final;
3366 int cmp(const uchar *, const uchar *) const final;
3368 size_t make_sort_key(uchar *buff, size_t length) const final;
3369 uint32 pack_length() const final { return PACK_LENGTH; }
3370 void sql_type(String &str) const final;
3371 bool zero_pack() const final { return true; }
3372 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const final;
3374 assert(type() == MYSQL_TYPE_DATETIME);
3375 return new (mem_root) Field_datetime(*this);
3376 }
3377 uchar *pack(uchar *to, const uchar *from, size_t max_length) const final {
3378 return pack_int64(to, from, max_length);
3379 }
3380 const uchar *unpack(uchar *to, const uchar *from,
3381 uint param_data [[maybe_unused]]) final {
3382 return unpack_int64(to, from);
3383 }
3384};
3385
3386/*
3387 Field implementing DATETIME(N) data type, where N=0..6.
3388*/
3390 protected:
3391 bool get_date_internal(MYSQL_TIME *ltime) const final;
3392 type_conversion_status store_internal(const MYSQL_TIME *ltime,
3393 int *error) final;
3394 my_time_flags_t date_flags(const THD *thd) const final;
3395 void store_timestamp_internal(const my_timeval *tm) final;
3396
3397 public:
3398 /**
3399 Constructor for Field_datetimef
3400 @param ptr_arg See Field definition
3401 @param null_ptr_arg See Field definition
3402 @param null_bit_arg See Field definition
3403 @param auto_flags_arg See Field definition
3404 @param field_name_arg See Field definition
3405 @param dec_arg Number of second fraction digits, 0..6.
3406 */
3407 Field_datetimef(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
3408 uchar auto_flags_arg, const char *field_name_arg,
3409 uint8 dec_arg)
3410 : Field_temporal_with_date_and_timef(ptr_arg, null_ptr_arg, null_bit_arg,
3411 auto_flags_arg, field_name_arg,
3412 dec_arg) {}
3413 /**
3414 Constructor for Field_datetimef
3415 @param is_nullable_arg See Field definition
3416 @param field_name_arg See Field definition
3417 @param dec_arg Number of second fraction digits, 0..6.
3418 */
3419 Field_datetimef(bool is_nullable_arg, const char *field_name_arg,
3420 uint8 dec_arg)
3422 nullptr, is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
3423 field_name_arg, dec_arg) {}
3425 assert(type() == MYSQL_TYPE_DATETIME);
3426 return new (mem_root) Field_datetimef(*this);
3427 }
3428
3433 uint pack_length_from_metadata(uint field_metadata) const final {
3434 DBUG_TRACE;
3435 const uint tmp = my_datetime_binary_length(field_metadata);
3436 return tmp;
3437 }
3438 bool zero_pack() const final { return true; }
3439
3442 longlong val_date_temporal() const final;
3443 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const final;
3444 void sql_type(String &str) const final;
3445};
3446
3448 public:
3449 Field_string(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
3450 uchar null_bit_arg, uchar auto_flags_arg,
3451 const char *field_name_arg, const CHARSET_INFO *cs)
3452 : Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
3453 auto_flags_arg, field_name_arg, cs) {}
3454 Field_string(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
3455 const CHARSET_INFO *cs)
3456 : Field_longstr(nullptr, len_arg,
3457 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
3458 field_name_arg, cs) {}
3459
3460 enum_field_types type() const final { return MYSQL_TYPE_STRING; }
3461 bool match_collation_to_optimize_range() const final { return true; }
3462 enum ha_base_keytype key_type() const final {
3464 }
3465 bool zero_pack() const final { return false; }
3467 charset()->cset->fill(charset(), (char *)ptr, field_length,
3468 (has_charset() ? ' ' : 0));
3469 return TYPE_OK;
3470 }
3471 type_conversion_status store(const char *to, size_t length,
3472 const CHARSET_INFO *charset) final;
3473 type_conversion_status store(longlong nr, bool unsigned_val) final;
3474 // Inherit the store() overloads that have not been overridden.
3476 double val_real() const final;
3477 longlong val_int() const final;
3478 String *val_str(String *, String *) const final;
3479 /**
3480 Get the C-string value, without using String class.
3481 @returns The C-string value of this field.
3482 */
3483 LEX_CSTRING val_str_quick() const {
3484 const char *string = pointer_cast<const char *>(ptr);
3485 return {string,
3487 }
3488 my_decimal *val_decimal(my_decimal *) const final;
3489 int cmp(const uchar *, const uchar *) const final;
3490 size_t make_sort_key(uchar *buff, size_t length) const final;
3491 size_t make_sort_key(uchar *to, size_t length, size_t trunc_pos) const final;
3492 void sql_type(String &str) const final;
3493 uchar *pack(uchar *to, const uchar *from, size_t max_length) const final;
3494 const uchar *unpack(uchar *to, const uchar *from, uint param_data) final;
3495 uint pack_length_from_metadata(uint field_metadata) const final {
3496 DBUG_PRINT("debug", ("field_metadata: 0x%04x", field_metadata));
3497 if (field_metadata == 0) return row_pack_length();
3498 return (((field_metadata >> 4) & 0x300) ^ 0x300) +
3499 (field_metadata & 0x00ff);
3500 }
3501 bool compatible_field_size(uint field_metadata, Relay_log_info *rli,
3502 uint16 mflags, int *order_var) const final;
3503 uint row_pack_length() const final { return field_length; }
3504 uint max_packed_col_length() const final;
3506 bool has_charset() const final {
3507 return charset() == &my_charset_bin ? false : true;
3508 }
3510 assert(real_type() == MYSQL_TYPE_STRING);
3511 return new (mem_root) Field_string(*this);
3512 }
3513 size_t get_key_image(uchar *buff, size_t length, imagetype type) const final;
3514 bool is_text_key_type() const final { return binary() ? false : true; }
3515
3516 private:
3517 int do_save_field_metadata(uchar *first_byte) const final;
3518};
3519
3521 public:
3522 Field_varstring(uchar *ptr_arg, uint32 len_arg, uint length_bytes_arg,
3523 uchar *null_ptr_arg, uchar null_bit_arg, uchar auto_flags_arg,
3524 const char *field_name_arg, TABLE_SHARE *share,
3525 const CHARSET_INFO *cs);
3526 Field_varstring(uint32 len_arg, bool is_nullable_arg,
3527 const char *field_name_arg, TABLE_SHARE *share,
3528 const CHARSET_INFO *cs);
3529
3530 enum_field_types type() const final { return MYSQL_TYPE_VARCHAR; }
3531 bool match_collation_to_optimize_range() const final { return true; }
3532 enum ha_base_keytype key_type() const final;
3533 uint row_pack_length() const final { return field_length; }
3534 bool zero_pack() const final { return false; }
3535 uint32 pack_length() const final {
3536 return (uint32)field_length + length_bytes;
3537 }
3538 uint32 key_length() const final { return (uint32)field_length; }
3539 type_conversion_status store(const char *to, size_t length,
3540 const CHARSET_INFO *charset) override;
3541 type_conversion_status store(longlong nr, bool unsigned_val) final;
3542 // Inherit the store() overloads that have not been overridden.
3544 double val_real() const final;
3545 longlong val_int() const final;
3546 String *val_str(String *, String *) const override;
3547 my_decimal *val_decimal(my_decimal *) const final;
3548 int cmp_max(const uchar *, const uchar *, uint max_length) const final;
3549 int cmp(const uchar *a, const uchar *b) const final {
3550 return cmp_max(a, b, ~0U);
3551 }
3552 size_t make_sort_key(uchar *buff, size_t length) const final;
3553 size_t make_sort_key(uchar *to, size_t length, size_t trunc_pos) const final;
3554 size_t get_key_image(uchar *buff, size_t length, imagetype type) const final;
3555 void set_key_image(const uchar *buff, size_t length) final;
3556 void sql_type(String &str) const final;
3557 uchar *pack(uchar *to, const uchar *from, size_t max_length) const final;
3558 const uchar *unpack(uchar *to, const uchar *from, uint param_data) final;
3559 int cmp_binary(const uchar *a, const uchar *b,
3560 uint32 max_length = ~0L) const final;
3561 int key_cmp(const uchar *, const uchar *) const final;
3562 int key_cmp(const uchar *str, uint length) const final;
3563
3564 uint32 data_length(ptrdiff_t row_offset = 0) const final;
3566 bool has_charset() const final {
3567 return charset() == &my_charset_bin ? false : true;
3568 }
3569 Field *new_field(MEM_ROOT *root, TABLE *new_table) const final;
3570 Field *new_key_field(MEM_ROOT *root, TABLE *new_table, uchar *new_ptr,
3571 uchar *new_null_ptr, uint new_null_bit) const final;
3573 assert(type() == MYSQL_TYPE_VARCHAR);
3574 assert(real_type() == MYSQL_TYPE_VARCHAR);
3575 return new (mem_root) Field_varstring(*this);
3576 }
3577 uint is_equal(const Create_field *new_field) const final;
3578 void hash(ulong *nr, ulong *nr2) const final;
3579 const uchar *data_ptr() const final { return ptr + length_bytes; }
3580 bool is_text_key_type() const final { return binary() ? false : true; }
3581 uint32 get_length_bytes() const override { return length_bytes; }
3582
3583 private:
3584 /* Store number of bytes used to store length (1 or 2) */
3586
3587 int do_save_field_metadata(uchar *first_byte) const final;
3588};
3589
3591 virtual type_conversion_status store_internal(const char *from, size_t length,
3592 const CHARSET_INFO *cs);
3593 /**
3594 Copy value to memory storage.
3595 */
3596 type_conversion_status store_to_mem(const char *from, size_t length,
3597 const CHARSET_INFO *cs, size_t max_length,
3599
3600 protected:
3601 /**
3602 The number of bytes used to represent the length of the blob.
3603 */
3605
3606 /**
3607 The 'value'-object is a cache fronting the storage engine.
3608 */
3610
3611 private:
3612 /**
3613 In order to support update of virtual generated columns of blob type,
3614 we need to allocate the space blob needs on server for old_row and
3615 new_row respectively. This variable is used to record the
3616 allocated blob space for old_row.
3617 */
3619
3620 /**
3621 Whether we need to move the content of 'value' to 'old_value' before
3622 updating the BLOB stored in 'value'. This needs to be done for
3623 updates of BLOB columns that are virtual since the storage engine
3624 does not have its own copy of the old 'value'. This variable is set
3625 to true when we read the data into 'value'. It is reset when we move
3626 'value' to 'old_value'. The purpose of having this is to avoid that we
3627 do the move operation from 'value' to 'old_value' more than one time per
3628 record.
3629 Currently, this variable is introduced because the following call in
3630 sql_data_change.cc:
3631 \/\**
3632 @todo combine this call to update_generated_write_fields() with the one
3633 in fill_record() to avoid updating virtual generated fields twice.
3634 *\/
3635 if (table->has_gcol())
3636 update_generated_write_fields(table->write_set, table);
3637 When the @todo is done, m_keep_old_value can be deleted.
3638 */
3640
3641 /**
3642 Backup String for table's blob fields.
3643 UPDATE of a virtual field (for index update) requires two values to be
3644 kept at the same time - 'new' and 'old' since SE (InnoDB) doesn't know the
3645 latter. In the case when there was an indexed record, it got deleted and
3646 When INSERT inserts into an index a record that coincides with a
3647 previously deleted one, InnoDB needs to recalculate value that was
3648 deleted in order to properly insert the new one.
3649 When two above overlap, a field have to keep 3 different values at the
3650 same time - 'new', 'old' and 'deleted'.
3651 This backup_value is used by @see my_eval_gcolumn_expr_helper() to save
3652 'new' and provide space for 'deleted' to avoid thrashing the former.
3653 Unlike the old_value, backup_value is allocated once and reused for each
3654 new re-calculation, to avoid excessive [re-]allocations. It's freed at the
3655 end of statement. Since InnoDB consumes calculated values only after all
3656 needed table's virtual fields were calculated, we have to have such backup
3657 buffer for each field.
3658
3659 Also used for set operation hashing: we need to compare the new
3660 and the existing record with the same hash.
3661 */
3663
3664#ifndef NDEBUG
3665 /**
3666 Whether the field uses table's backup value storage. @see
3667 TABLE::m_blob_backup. Used only for debug.
3668 */
3669 bool m_uses_backup{false};
3670#endif
3671
3672 protected:
3673 /**
3674 Store ptr and length.
3675 */
3676 void store_ptr_and_length(const char *from, uint32 length) {
3677 store_length(length);
3678 memmove(ptr + packlength, &from, sizeof(char *));
3679 }
3680
3681 public:
3682 Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
3683 uchar auto_flags_arg, const char *field_name_arg,
3684 TABLE_SHARE *share, uint blob_pack_length, const CHARSET_INFO *cs);
3685
3686 Field_blob(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
3687 const CHARSET_INFO *cs, bool set_packlength)
3688 : Field_longstr(nullptr, len_arg,
3689 is_nullable_arg ? &dummy_null_buffer : nullptr, 0, NONE,
3690 field_name_arg, cs),
3691 packlength(4),
3692 m_keep_old_value(false) {
3694 if (set_packlength) {
3695 packlength = len_arg <= 255
3696 ? 1
3697 : len_arg <= 65535 ? 2 : len_arg <= 16777215 ? 3 : 4;
3698 }
3699 }
3700
3701 /// Copy static information and reset dynamic information.
3703 : Field_longstr(field),
3704 packlength(field.packlength),
3705 value(),
3706 old_value(),
3707 m_keep_old_value(field.m_keep_old_value),
3708 m_blob_backup() {
3709#ifndef NDEBUG
3710 m_uses_backup = field.m_uses_backup;
3711#endif
3712 }
3713
3714 explicit Field_blob(uint32 packlength_arg);
3715
3716 /* Note that the default copy constructor is used, in clone() */
3717 enum_field_types type() const override { return MYSQL_TYPE_BLOB; }
3718 bool match_collation_to_optimize_range() const override { return true; }
3719 enum ha_base_keytype key_type() const override {
3721 }
3722 type_conversion_status store(const char *to, size_t length,
3723 const CHARSET_INFO *charset) override;
3724 type_conversion_status store(double nr) override;
3725 type_conversion_status store(longlong nr, bool unsigned_val) override;
3726 type_conversion_status store(const Field *from);
3727 double val_real() const override;
3728 longlong val_int() const override;
3729 String *val_str(String *, String *) const override;
3730 my_decimal *val_decimal(my_decimal *) const override;
3731 int cmp_max(const uchar *, const uchar *, uint max_length) const final;
3732 int cmp(const uchar *a, const uchar *b) const final {
3733 return cmp_max(a, b, ~0U);
3734 }
3735 int cmp(const uchar *a, uint32 a_length, const uchar *b,
3736 uint32 b_length) const; // No override.
3737 int cmp_binary(const uchar *a, const uchar *b,
3738 uint32 max_length = ~0L) const override;
3739 int key_cmp(const uchar *, const uchar *) const override;
3740 int key_cmp(const uchar *str, uint length) const override;
3741 uint32 key_length() const override { return 0; }
3742 size_t make_sort_key(uchar *buff, size_t length) const override;
3743 size_t make_sort_key(uchar *to, size_t length, size_t trunc_pos) const final;
3744 uint32 pack_length() const final {
3745 return (uint32)(packlength + portable_sizeof_char_ptr);
3746 }
3747
3748 /**
3749 Return the packed length without the pointer size added.
3750
3751 This is used to determine the size of the actual data in the row
3752 buffer.
3753
3754 @returns The length of the raw data itself without the pointer.
3755 */
3756 uint32 pack_length_no_ptr() const { return (uint32)(packlength); }
3757 uint row_pack_length() const final { return pack_length_no_ptr(); }
3758 uint32 max_data_length() const final {
3759 return (uint32)(((ulonglong)1 << (packlength * 8)) - 1);
3760 }
3761 size_t get_field_buffer_size() { return value.alloced_length(); }
3762 void store_length(uchar *i_ptr, uint i_packlength, uint32 i_number);
3763 inline void store_length(uint32 number) {
3764 store_length(ptr, packlength, number);
3765 }
3766 uint32 data_length(ptrdiff_t row_offset = 0) const final {
3767 return get_length(row_offset);
3768 }
3769 uint32 get_length(ptrdiff_t row_offset = 0) const;
3770 uint32 get_length(const uchar *ptr, uint packlength) const;
3771 uint32 get_length(const uchar *ptr_arg) const;
3772 /** Get a const pointer to the BLOB data of this field. */
3773 const uchar *get_blob_data() const { return get_blob_data(ptr + packlength); }
3774 /** Get a non-const pointer to the BLOB data of this field. */
3775 uchar *get_blob_data(ptrdiff_t row_offset = 0) {
3776 // row_offset is only used by NDB
3777 return get_blob_data(ptr + packlength + row_offset);
3778 }
3779 /** Get a const pointer to the BLOB data of this field. */
3780 const uchar *data_ptr() const final { return get_blob_data(); }
3781
3782 protected:
3783 /**
3784 Get the BLOB data pointer stored at the specified position in the record
3785 buffer.
3786 */
3787 static uchar *get_blob_data(const uchar *position) {
3788 uchar *data;
3789 memcpy(&data, position, sizeof(data));
3790 return data;
3791 }
3792
3793 public:
3794 void set_ptr(const uchar *length, const uchar *data) {
3795 memcpy(ptr, length, packlength);
3796 memcpy(ptr + packlength, &data, sizeof(char *));
3797 }
3798 void set_ptr_offset(ptrdiff_t ptr_diff, uint32 length, const uchar *data) {
3799 uchar *ptr_ofs = ptr + ptr_diff;
3800 store_length(ptr_ofs, packlength, length);
3801 memcpy(ptr_ofs + packlength, &data, sizeof(char *));
3802 }
3803 void set_ptr(uint32 length, const uchar *data) {
3804 set_ptr_offset(0, length, data);
3805 }
3806 size_t get_key_image(uchar *buff, size_t length,
3807 imagetype type) const override;
3808 void set_key_image(const uchar *buff, size_t length) final;
3809 void sql_type(String &str) const override;
3810 bool copy();
3811 Field_blob *clone(MEM_ROOT *mem_root) const override {
3812 assert(type() == MYSQL_TYPE_BLOB);
3813 return new (mem_root) Field_blob(*this);
3814 }
3815 uchar *pack(uchar *to, const uchar *from, size_t max_length) const final;
3816 uchar *pack_with_metadata_bytes(uchar *to, const uchar *from,
3817 uint max_length) const final;
3818 const uchar *unpack(uchar *, const uchar *from, uint param_data) final;
3819 uint max_packed_col_length() const final;
3820 void mem_free() final {
3821 // Free all allocated space
3822 value.mem_free();
3823 old_value.mem_free();
3824 m_blob_backup.mem_free();
3825 }
3826 bool has_charset() const override {
3827 return charset() == &my_charset_bin ? false : true;
3828 }
3829 uint32 max_display_length() const final;
3830 uint32 char_length() const override;
3831 bool copy_blob_value(MEM_ROOT *mem_root);
3832 uint is_equal(const Create_field *new_field) const override;
3833 bool is_text_key_type() const final { return binary() ? false : true; }
3834
3835 /**
3836 Mark that the BLOB stored in value should be copied before updating it.
3837
3838 When updating virtual generated columns we need to keep the old
3839 'value' for BLOBs since this can be needed when the storage engine
3840 does the update. During read of the record the old 'value' for the
3841 BLOB is evaluated and stored in 'value'. This function is to be used
3842 to specify that we need to copy this BLOB 'value' into 'old_value'
3843 before we compute the new BLOB 'value'. For more information @see
3844 Field_blob::keep_old_value().
3845 */
3846 void set_keep_old_value(bool old_value_flag) {
3847 /*
3848 We should only need to keep a copy of the blob 'value' in the case
3849 where this is a virtual generated column (that is indexed).
3850 */
3851 assert(is_virtual_gcol());
3852
3853 /*
3854 If set to true, ensure that 'value' is copied to 'old_value' when
3855 keep_old_value() is called.
3856 */
3857 m_keep_old_value = old_value_flag;
3858 }
3859
3860 /**
3861 Save the current BLOB value to avoid that it gets overwritten.
3862
3863 This is used when updating virtual generated columns that are
3864 BLOBs. Some storage engines require that we have both the old and
3865 new BLOB value for virtual generated columns that are indexed in
3866 order for the storage engine to be able to maintain the index. This
3867 function will transfer the buffer storing the current BLOB value
3868 from 'value' to 'old_value'. This avoids that the current BLOB value
3869 is over-written when the new BLOB value is saved into this field.
3870
3871 The reason this requires special handling when updating/deleting
3872 virtual columns of BLOB type is that the BLOB value is not known to
3873 the storage engine. For stored columns, the "old" BLOB value is read
3874 by the storage engine, Field_blob is made to point to the engine's
3875 internal buffer; Field_blob's internal buffer (Field_blob::value)
3876 isn't used and remains available to store the "new" value. For
3877 virtual generated columns, the "old" value is written directly into
3878 Field_blob::value when reading the record to be
3879 updated/deleted. This is done in update_generated_read_fields().
3880 Since, in this case, the "old" value already occupies the place to
3881 store the "new" value, we must call this function before we write
3882 the "new" value into Field_blob::value object so that the "old"
3883 value does not get over-written. The table->record[1] buffer will
3884 have a pointer that points to the memory buffer inside
3885 old_value. The storage engine will use table->record[1] to read the
3886 old value for the BLOB and use table->record[0] to read the new
3887 value.
3888
3889 This function must be called before we store the new BLOB value in
3890 this field object.
3891 */
3893 /*
3894 We should only need to keep a copy of the blob value in the case
3895 where this is a virtual generated column (that is indexed).
3896 */
3897 assert(is_virtual_gcol());
3898
3899 // Transfer ownership of the current BLOB value to old_value
3900 if (m_keep_old_value) {
3901 old_value.takeover(value);
3902 m_keep_old_value = false;
3903 }
3904 }
3905
3906 /**
3907 Use to store the blob value into an allocated space.
3908 */
3909 void store_in_allocated_space(const char *from, uint32 length) {
3910 store_ptr_and_length(from, length);
3911 }
3912
3913 /**
3914 Backup data stored in 'value' into the backup_value
3915 @see Field_blob::backup_value
3916
3917 @returns
3918 true if backup fails
3919 false otherwise
3920 */
3921 bool backup_blob_field();
3922
3923 /**
3924 Restore backup value
3925 @see Field_blob::backup_value
3926 */
3927 void restore_blob_backup();
3928
3929 private:
3930 int do_save_field_metadata(uchar *first_byte) const override;
3931};
3932
3933class Field_geom final : public Field_blob {
3934 private:
3935 const std::optional<gis::srid_t> m_srid;
3936
3937 type_conversion_status store_internal(const char *from, size_t length,
3938 const CHARSET_INFO *cs) final;
3939
3940 public:
3942
3943 Field_geom(uchar *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
3944 uchar auto_flags_arg, const char *field_name_arg,
3945 TABLE_SHARE *share, uint blob_pack_length,
3946 enum geometry_type geom_type_arg, std::optional<gis::srid_t> srid)
3947 : Field_blob(ptr_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
3948 field_name_arg, share, blob_pack_length, &my_charset_bin),
3949 m_srid(srid),
3950 geom_type(geom_type_arg) {}
3951 Field_geom(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg,
3952 enum geometry_type geom_type_arg, std::optional<gis::srid_t> srid)
3953 : Field_blob(len_arg, is_nullable_arg, field_name_arg, &my_charset_bin,
3954 false),
3955 m_srid(srid),
3956 geom_type(geom_type_arg) {}
3957 enum ha_base_keytype key_type() const final { return HA_KEYTYPE_VARBINARY2; }
3959 bool match_collation_to_optimize_range() const final { return false; }
3960 void sql_type(String &str) const final;
3961 using Field_blob::store;
3962 type_conversion_status store(double nr) final;
3963 type_conversion_status store(longlong nr, bool unsigned_val) final;
3965 type_conversion_status store(const char *from, size_t length,
3966 const CHARSET_INFO *cs) final;
3967
3968 /**
3969 Non-nullable GEOMETRY types cannot have defaults,
3970 but the underlying blob must still be reset.
3971 */
3974 if (res != TYPE_OK) return res;
3975 return (is_nullable() || table->is_nullable())
3976 ? TYPE_OK
3978 }
3979
3980 geometry_type get_geometry_type() const final { return geom_type; }
3982 assert(type() == MYSQL_TYPE_GEOMETRY);
3983 return new (mem_root) Field_geom(*this);
3984 }
3985 uint is_equal(const Create_field *new_field) const final;
3986
3987 std::optional<gis::srid_t> get_srid() const { return m_srid; }
3988};
3989
3990/// A field that stores a JSON value.
3991class Field_json : public Field_blob {
3992 type_conversion_status unsupported_conversion();
3993 type_conversion_status store_binary(const char *ptr, size_t length);
3994
3995 public:
3996 Field_json(uchar *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
3997 uchar auto_flags_arg, const char *field_name_arg,
3998 TABLE_SHARE *share, uint blob_pack_length)
3999 : Field_blob(ptr_arg, null_ptr_arg, null_bit_arg, auto_flags_arg,
4000 field_name_arg, share, blob_pack_length, &my_charset_bin) {}
4001
4002 Field_json(uint32 len_arg, bool is_nullable_arg, const char *field_name_arg)
4003 : Field_blob(len_arg, is_nullable_arg, field_name_arg, &my_charset_bin,
4004 false) {}
4005
4006 enum_field_types type() const override { return MYSQL_TYPE_JSON; }
4007 void sql_type(String &str) const override;
4008 /**
4009 Return a text charset so that string functions automatically
4010 convert the field value to string and treat it as a non-binary
4011 string.
4012 */
4013 const CHARSET_INFO *charset() const override {
4014 return &my_charset_utf8mb4_bin;
4015 }
4016 /**
4017 Sort should treat the field as binary and not attempt any
4018 conversions.
4019 */
4020 const CHARSET_INFO *sort_charset() const final { return field_charset; }
4021 /**
4022 JSON columns don't have an associated charset. Returning false
4023 here prevents SHOW CREATE TABLE from attaching a CHARACTER SET
4024 clause to the column.
4025 */
4026 bool has_charset() const final { return false; }
4027 type_conversion_status store(const char *to, size_t length,
4028 const CHARSET_INFO *charset) override;
4029 type_conversion_status store(double nr) override;
4030 type_conversion_status store(longlong nr, bool unsigned_val) override;
4032 type_conversion_status store_json(const Json_wrapper *json);
4033 type_conversion_status store_time(MYSQL_TIME *ltime, uint8 dec_arg) final;
4035
4036 bool pack_diff(uchar **to, ulonglong value_options) const final;
4037 /**
4038 Return the length of this field, taking into consideration that it may be in
4039 partial format.
4040
4041 This is the format used when writing the binary log in row format
4042 and using a partial format according to
4043 @@session.binlog_row_value_options.
4044
4045 @param[in] value_options The value of binlog_row_value options.
4046
4047 @param[out] diff_vector_p If this is not NULL, the pointer it
4048 points to will be set to NULL if the field is to be stored in full
4049 format, or to the Json_diff_vector if the field is to be stored in
4050 partial format.
4051
4052 @return The number of bytes needed when writing to the binlog: the
4053 size of the full format if stored in full format and the size of
4054 the diffs if stored in partial format.
4055 */
4056 longlong get_diff_vector_and_length(
4057 ulonglong value_options,
4058 const Json_diff_vector **diff_vector_p = nullptr) const;
4059 /**
4060 Return true if the before-image and after-image for this field are
4061 equal.
4062 */
4063 bool is_before_image_equal_to_after_image() const;
4064 /**
4065 Read the binary diff from the given buffer, and apply it to this field.
4066
4067 @param[in,out] from Pointer to buffer where the binary diff is stored.
4068 This will be changed to point to the next byte after the field.
4069
4070 @retval false Success
4071 @retval true Error (e.g. failed to apply the diff). The error has
4072 been reported through my_error.
4073 */
4074 bool unpack_diff(const uchar **from);
4075
4076 /**
4077 Retrieve the field's value as a JSON wrapper. It
4078 there is an error, wr is not modified and we return
4079 false, else true.
4080
4081 @param[out] wr the JSON value
4082 @return true if a value is retrieved (or NULL), false if error
4083 */
4084 bool val_json(Json_wrapper *wr) const;
4085
4086 /**
4087 Retrieve the JSON as an int if possible. This requires a JSON scalar
4088 of suitable type.
4089
4090 @returns the JSON value as an int
4091 */
4092 longlong val_int() const final;
4093
4094 /**
4095 Retrieve the JSON as a double if possible. This requires a JSON scalar
4096 of suitable type.
4097
4098 @returns the JSON value as a double
4099 */
4100 double val_real() const final;
4101
4102 /**
4103 Retrieve the JSON value stored in this field as text
4104
4105 @param[in,out] buf1 string buffer for converting JSON value to string
4106 @param[in,out] buf2 unused
4107 */
4108 String *val_str(String *buf1, String *buf2) const final;
4109 my_decimal *val_decimal(my_decimal *m) const final;
4110 bool get_time(MYSQL_TIME *ltime) const final;
4111 bool get_date(MYSQL_TIME *ltime, my_time_flags_t fuzzydate) const final;
4112 Field_json *clone(MEM_ROOT *mem_root) const override;
4113 uint is_equal(const Create_field *new_field) const final;
4114 Item_result cast_to_int_type() const final { return INT_RESULT; }
4115 int cmp_binary(const uchar *a, const uchar *b,
4116 uint32 max_length = ~0L) const final;
4118 size_t make_sort_key(uchar *to, size_t length) const override;
4119
4120 /**
4121 Make a hash key that can be used by sql_executor.cc/unique_hash
4122 in order to support SELECT DISTINCT
4123
4124 @param[in] hash_val An initial hash value.
4125 */
4126 ulonglong make_hash_key(ulonglong hash_val) const;
4127
4128 /**
4129 Get a read-only pointer to the binary representation of the JSON document
4130 in this field.
4131
4132 @param row_offset Field's data offset
4133 */
4134 const char *get_binary(ptrdiff_t row_offset = 0) const;
4135};
4136
4137/**
4138 Field that stores array of values of the same type.
4139
4140 This Field class is used together with Item_func_array_cast class
4141 (CAST( .. AS .. ARRAY) function) in implementation of multi-valued index.
4142 Effectively it's a JSON field that contains a single JSON array. When a
4143 JSON value is stored, it's checked to be either a scalar, or an array.
4144 All source values are converted using the internal conversion field and
4145 stored as an array. Field_typed_array ensures that all values stored
4146 in the array have the same type and precision - the one specified by user.
4147 This way InnoDB doesn't have to do the conversion on its own and can easily
4148 index them.
4149
4150 The Field_typed_array always reports type of its element and from this
4151 point of view it's undistinguishable from regular field having the same
4152 type. Due to that, fields are differentiated by is_array() property.
4153 Field_typed_array returns true, all other fields - false.
4154
4155 For conversion and index applicability tests, Field_typed_array employs a
4156 conversion field, which is a regular Field class of array's element type.
4157 It's stored in the m_conv_field. All Field_typed_array::store_*() methods
4158 store values to the conversion field. Conversion field and typed array
4159 field are sharing same field_index, to allow correct read/write_set
4160 checks. So the field always have to be marked for read in order to allow
4161 read of conversions' results.
4162
4163 @see Item_func_array_cast
4164*/
4165
4166class Field_typed_array final : public Field_json {
4167 /// Conversion item_field
4168 Item_field *m_conv_item{nullptr};
4169 /// The array element's real type.
4171 /// Element's decimals
4173 /// Element's charset
4175 const bool unsigned_flag;
4176
4177 public:
4178 /**
4179 Constructs a Field_typed_array that is a copy of another Field_typed_array.
4180 @param other the other Field_typed_array object
4181 */
4182