MySQL 8.0.31
Source Code Documentation
data0type.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1996, 2022, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is also distributed with certain software (including but not
10limited to OpenSSL) that is licensed under separate terms, as designated in a
11particular file or component or in included license documentation. The authors
12of MySQL hereby grant you an additional permission to link the program and
13your derivative works with the separately licensed software that they have
14included with MySQL.
15
16This program is distributed in the hope that it will be useful, but WITHOUT
17ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
19for more details.
20
21You should have received a copy of the GNU General Public License along with
22this program; if not, write to the Free Software Foundation, Inc.,
2351 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24
25*****************************************************************************/
26
27/** @file include/data0type.h
28 Data types
29
30 Created 1/16/1996 Heikki Tuuri
31 *******************************************************/
32
33#ifndef data0type_h
34#define data0type_h
35
36#include "univ.i"
37
39constexpr uint32_t DATA_MYSQL_BINARY_CHARSET_COLL = 63;
40
41/* SQL data type struct */
42struct dtype_t;
43
44/** SQL Like operator comparison types */
46 IB_LIKE_EXACT, /**< e.g. STRING */
47 IB_LIKE_PREFIX /**< e.g., STRING% */
48};
49
50/*-------------------------------------------*/
51/* The 'MAIN TYPE' of a column */
52/** missing column */
53constexpr uint32_t DATA_MISSING = 0;
54/** character varying of the latin1_swedish_ci charset-collation; note that the
55 MySQL format for this, DATA_BINARY, DATA_VARMYSQL, is also affected by
56 whether the 'precise type' contains DATA_MYSQL_TRUE_VARCHAR */
57constexpr uint32_t DATA_VARCHAR = 1;
58/** fixed length character of the latin1_swedish_ci charset-collation */
59constexpr uint32_t DATA_CHAR = 2;
60/** binary string of fixed length */
61constexpr uint32_t DATA_FIXBINARY = 3;
62/** binary string */
63constexpr uint32_t DATA_BINARY = 4;
64/** binary large object, or a TEXT type; if prtype & DATA_BINARY_TYPE == 0, then
65 this is actually a TEXT column (or a BLOB created with < 4.0.14; since column
66 prefix indexes came only in 4.0.14, the missing flag in BLOBs created before
67 that does not cause any harm) */
68constexpr uint32_t DATA_BLOB = 5;
69/** integer: can be any size 1 - 8 bytes */
70constexpr uint32_t DATA_INT = 6;
71/** address of the child page in node pointer */
72constexpr uint32_t DATA_SYS_CHILD = 7;
73/** system column */
74constexpr uint32_t DATA_SYS = 8;
75
76/* Data types >= DATA_FLOAT must be compared using the whole field, not as
77binary strings */
78
79constexpr uint32_t DATA_FLOAT = 9;
80constexpr uint32_t DATA_DOUBLE = 10;
81/** decimal number stored as an ASCII string */
82constexpr uint32_t DATA_DECIMAL = 11;
83/** any charset varying length char */
84constexpr uint32_t DATA_VARMYSQL = 12;
85/** any charset fixed length char
86NOTE that 4.1.1 used DATA_MYSQL and DATA_VARMYSQL for all character sets, and
87the charset-collation for tables created with it can also be latin1_swedish_ci
88*/
89constexpr uint32_t DATA_MYSQL = 13;
90
91/* DATA_POINT&DATA_VAR_POINT are for standard geometry datatype 'point' and
92DATA_GEOMETRY include all other standard geometry datatypes as described in
93OGC standard(line_string, polygon, multi_point, multi_polygon,
94multi_line_string, geometry_collection, geometry).
95Currently, geometry data is stored in the standard Well-Known Binary(WKB)
96format (http://www.opengeospatial.org/standards/sfa).
97We use BLOB as underlying datatype for DATA_GEOMETRY and DATA_VAR_POINT
98while CHAR for DATA_POINT */
99/* geometry datatype of variable length */
100constexpr uint32_t DATA_GEOMETRY = 14;
101/* The following two are disabled temporarily, we won't create them in
102get_innobase_type_from_mysql_type().
103TODO: We will enable DATA_POINT/them when we come to the fixed-length POINT
104again. */
105/** geometry datatype of fixed length POINT */
106constexpr uint32_t DATA_POINT = 15;
107/** geometry datatype of variable length POINT, used when we want to store POINT
108 as BLOB internally */
109constexpr uint32_t DATA_VAR_POINT = 16;
110/** dtype_store_for_order_and_null_size() requires the values are <= 63 */
111constexpr uint32_t DATA_MTYPE_MAX = 63;
112
113/** minimum value of mtype */
115/** maximum value of mtype */
117/*-------------------------------------------*/
118/* The 'PRECISE TYPE' of a column */
119/*
120Tables created by a MySQL user have the following convention:
121
122- In the least significant byte in the precise type we store the MySQL type
123code (not applicable for system columns).
124
125- In the second least significant byte we OR flags DATA_NOT_NULL,
126DATA_UNSIGNED, DATA_BINARY_TYPE.
127
128- In the third least significant byte of the precise type of string types we
129store the MySQL charset-collation code. In DATA_BLOB columns created with
130< 4.0.14 we do not actually know if it is a BLOB or a TEXT column. Since there
131are no indexes on prefixes of BLOB or TEXT columns in < 4.0.14, this is no
132problem, though.
133
134Note that versions < 4.1.2 or < 5.0.1 did not store the charset code to the
135precise type, since the charset was always the default charset of the MySQL
136installation. If the stored charset code is 0 in the system table SYS_COLUMNS
137of InnoDB, that means that the default charset of this MySQL installation
138should be used.
139
140When loading a table definition from the system tables to the InnoDB data
141dictionary cache in main memory, InnoDB versions >= 4.1.2 and >= 5.0.1 check
142if the stored charset-collation is 0, and if that is the case and the type is
143a non-binary string, replace that 0 by the default charset-collation code of
144this MySQL installation. In short, in old tables, the charset-collation code
145in the system tables on disk can be 0, but in in-memory data structures
146(dtype_t), the charset-collation code is always != 0 for non-binary string
147types.
148
149In new tables, in binary string types, the charset-collation code is the
150MySQL code for the 'binary charset', that is, != 0.
151
152For binary string types and for DATA_CHAR, DATA_VARCHAR, and for those
153DATA_BLOB which are binary or have the charset-collation latin1_swedish_ci,
154InnoDB performs all comparisons internally, without resorting to the MySQL
155comparison functions. This is to save CPU time.
156
157InnoDB's own internal system tables have different precise types for their
158columns, and for them the precise type is usually not used at all.
159*/
160
161/** English language character string: this is a relic from pre-MySQL time and
162 only used for InnoDB's own system tables */
163constexpr uint32_t DATA_ENGLISH = 4;
164/** another relic from pre-MySQL time */
165constexpr uint32_t DATA_ERROR = 111;
166
167/** AND with this mask to extract the MySQL type from the precise type */
168constexpr uint32_t DATA_MYSQL_TYPE_MASK = 255;
169/** MySQL type code for the >= 5.0.3 format true VARCHAR */
170constexpr uint32_t DATA_MYSQL_TRUE_VARCHAR = 15;
171
172/* Precise data types for system columns and the length of those columns;
173NOTE: the values must run from 0 up in the order given! All codes must
174be less than 256 */
175/** row id: a 48-bit integer */
176constexpr uint32_t DATA_ROW_ID = 0;
177/** stored length for row id */
178constexpr uint32_t DATA_ROW_ID_LEN = 6;
179
180/** Transaction id: 6 bytes */
181constexpr size_t DATA_TRX_ID = 1;
182
183/** Transaction ID type size in bytes. */
184constexpr size_t DATA_TRX_ID_LEN = 6;
185
186/** Rollback data pointer: 7 bytes */
187constexpr size_t DATA_ROLL_PTR = 2;
188
189/** Rollback data pointer type size in bytes. */
190constexpr size_t DATA_ROLL_PTR_LEN = 7;
191
192/** number of system columns defined above */
193constexpr uint32_t DATA_N_SYS_COLS = 3;
194
195/** number of system columns for intrinsic temporary table */
196constexpr uint32_t DATA_ITT_N_SYS_COLS = 2;
197
198/** Used as FTS DOC ID column */
199constexpr uint32_t DATA_FTS_DOC_ID = 3;
200
201/** mask to extract the above from prtype */
202constexpr uint32_t DATA_SYS_PRTYPE_MASK = 0xF;
203
204/* Flags ORed to the precise data type */
205/** this is ORed to the precise type when the column is declared as NOT NULL */
206constexpr uint32_t DATA_NOT_NULL = 256;
207/* this id ORed to the precise type when we have an unsigned integer type */
208constexpr uint32_t DATA_UNSIGNED = 512;
209/** if the data type is a binary character string, this is ORed to the precise
210 type: this only holds for tables created with >= MySQL-4.0.14 */
211constexpr uint32_t DATA_BINARY_TYPE = 1024;
212/** Used as GIS MBR column */
213constexpr uint32_t DATA_GIS_MBR = 2048;
214/** GIS MBR length*/
215constexpr uint32_t DATA_MBR_LEN = SPDIMS * 2 * sizeof(double);
216
217/** this is ORed to the precise data type when the column is true VARCHAR where
218 MySQL uses 2 bytes to store the data len; for shorter VARCHARs MySQL uses
219 only 1 byte */
220constexpr uint32_t DATA_LONG_TRUE_VARCHAR = 4096;
221/** Virtual column */
222constexpr uint32_t DATA_VIRTUAL = 8192;
223/** Multi-value Virtual column */
224constexpr uint32_t DATA_MULTI_VALUE = 16384;
225
226/*-------------------------------------------*/
227
228/* This many bytes we need to store the type information affecting the
229alphabetical order for a single field and decide the storage size of an
230SQL null*/
231constexpr uint32_t DATA_ORDER_NULL_TYPE_BUF_SIZE = 4;
232/* In the >= 4.1.x storage format we add 2 bytes more so that we can also
233store the charset-collation number; one byte is left unused, though */
235
236/* Maximum multi-byte character length in bytes, plus 1 */
237constexpr uint32_t DATA_MBMAX = 5;
238
239/* For DATA_POINT of dimension 2, the length of value in btree is always 25,
240which is the summary of:
241SRID_SIZE(4) + WKB_HEADER_SIZE(1+4) + POINT_DATA_SIZE(8*2).
242So the length of physical record or POINT KEYs on btree are 25.
243GIS_TODO: When we support multi-dimensions DATA_POINT, we should get the
244length from corresponding column or index definition, instead of this MACRO
245*/
246constexpr uint32_t DATA_POINT_LEN = 25;
247
248/* Pack mbminlen, mbmaxlen to mbminmaxlen. */
249inline ulint DATA_MBMINMAXLEN(ulint mbminlen, ulint mbmaxlen) {
250 return mbmaxlen * DATA_MBMAX + mbminlen;
251}
252/* Get mbminlen from mbminmaxlen. Cast the result of UNIV_EXPECT to ulint
253because in GCC it returns a long. */
256}
257/* Get mbmaxlen from mbminmaxlen. */
259 return mbminmaxlen / DATA_MBMAX;
260}
261
262/* For checking if a geom_type is POINT */
264 return mtype == DATA_POINT || mtype == DATA_VAR_POINT;
265}
266
267/* For checking if mtype is GEOMETRY datatype */
270}
271
272/* For checking if mtype is BLOB or GEOMETRY, since we use BLOB as
273the underling datatype of GEOMETRY(not DATA_POINT) data. */
275 return mtype == DATA_BLOB || mtype == DATA_VAR_POINT ||
277}
278
279/* For checking if data type is big length data type. */
281 return len > 255 || DATA_LARGE_MTYPE(mtype);
282}
283
284/* For checking if the column is a big length column. */
285#define DATA_BIG_COL(col) DATA_BIG_LEN_MTYPE((col)->len, (col)->mtype)
286
287/* We now support 15 bits (up to 32767) collation number */
288constexpr uint32_t MAX_CHAR_COLL_NUM = 32767;
289
290/* Mask to get the Charset Collation number (0x7fff) */
292
293#ifndef UNIV_HOTBACKUP
294/** Gets the MySQL type code from a dtype.
295 @return MySQL type code; this is NOT an InnoDB type code! */
297 const dtype_t *type); /*!< in: type struct */
298/** Determine how many bytes the first n characters of the given string occupy.
299 If the string is shorter than n characters, returns the number of bytes the
300 characters in the string occupy.
301 @return length of the prefix, in bytes */
303 ulint prtype, /*!< in: precise type */
304 ulint mbminmaxlen, /*!< in: minimum and maximum length of
305 a multi-byte character */
306 ulint prefix_len, /*!< in: length of the requested
307 prefix, in characters, multiplied by
308 dtype_get_mbmaxlen(dtype) */
309 ulint data_len, /*!< in: length of str (in bytes) */
310 const char *str); /*!< in: the string whose prefix
311 length is being determined */
312#endif /* !UNIV_HOTBACKUP */
313/** Checks if a data main type is a string type. Also a BLOB is considered a
314 string type.
315 @return true if string type */
317 ulint mtype); /*!< in: InnoDB main data type code: DATA_CHAR, ... */
318/** Checks if a type is a binary string type. Note that for tables created
319 with < 4.0.14, we do not know if a DATA_BLOB column is a BLOB or a TEXT
320 column. For those DATA_BLOB columns this function currently returns false.
321 @return true if binary string type */
322bool dtype_is_binary_string_type(ulint mtype, /*!< in: main data type */
323 ulint prtype); /*!< in: precise type */
324/** Checks if a type is a non-binary string type. That is,
325 dtype_is_string_type is true and dtype_is_binary_string_type is false. Note
326 that for tables created with < 4.0.14, we do not know if a DATA_BLOB column
327 is a BLOB or a TEXT column. For those DATA_BLOB columns this function
328 currently returns true.
329 @return true if non-binary string type */
330bool dtype_is_non_binary_string_type(ulint mtype, /*!< in: main data type */
331 ulint prtype); /*!< in: precise type */
332
333/** Sets a data type structure.
334@param[in] type type struct to init
335@param[in] mtype main data type
336@param[in] prtype precise type
337@param[in] len precision of type */
339 ulint len);
340
341/** Copies a data type structure.
342@param[in] type1 type struct to copy to
343@param[in] type2 type struct to copy from */
344static inline void dtype_copy(dtype_t *type1, const dtype_t *type2);
345
346/** Gets the SQL main data type.
347 @return SQL main data type */
348static inline ulint dtype_get_mtype(const dtype_t *type); /*!< in: data type */
349/** Gets the precise data type.
350 @return precise data type */
351static inline ulint dtype_get_prtype(const dtype_t *type); /*!< in: data type */
352
353#ifndef UNIV_HOTBACKUP
354/** Compute the mbminlen and mbmaxlen members of a data type structure.
355@param[in] mtype main type
356@param[in] prtype precise type (and collation)
357@param[out] mbminlen minimum length of a multi-byte character
358@param[out] mbmaxlen maximum length of a multi-byte character */
359static inline void dtype_get_mblen(ulint mtype, ulint prtype, ulint *mbminlen,
360 ulint *mbmaxlen);
361#endif
362
363/** Gets the MySQL charset-collation code for MySQL string types.
364 @return MySQL charset-collation code */
366 ulint prtype); /*!< in: precise data type */
367/** Forms a precise type from the < 4.1.2 format precise type plus the
368 charset-collation code.
369 @return precise type, including the charset-collation code */
371 ulint old_prtype, /*!< in: the MySQL type code and the flags
372 DATA_BINARY_TYPE etc. */
373 ulint charset_coll); /*!< in: MySQL charset-collation code */
374
375#ifndef UNIV_HOTBACKUP
376/** Determines if a MySQL string type is a subset of UTF-8. This function
377 may return false negatives, in case further character-set collation
378 codes are introduced in MySQL later.
379 @return true if a subset of UTF-8 */
380static inline bool dtype_is_utf8(ulint prtype); /*!< in: precise data type */
381#endif
382
383/** Gets the type length.
384 @return fixed length of the type, in bytes, or 0 if variable-length */
385static inline ulint dtype_get_len(const dtype_t *type); /*!< in: data type */
386#ifndef UNIV_HOTBACKUP
387/** Gets the minimum length of a character, in bytes.
388 @return minimum length of a char, in bytes, or 0 if this is not a
389 character type */
390static inline ulint dtype_get_mbminlen(const dtype_t *type); /*!< in: type */
391/** Gets the maximum length of a character, in bytes.
392 @return maximum length of a char, in bytes, or 0 if this is not a
393 character type */
394static inline ulint dtype_get_mbmaxlen(const dtype_t *type); /*!< in: type */
395
396/** Sets the minimum and maximum length of a character, in bytes.
397@param[in,out] type type
398@param[in] mbminlen minimum length of a char, in bytes, or 0 if
399 this is not a character type
400@param[in] mbmaxlen maximum length of a char, in bytes, or 0 if
401 this is not a character type */
402static inline void dtype_set_mbminmaxlen(dtype_t *type, ulint mbminlen,
403 ulint mbmaxlen);
404#endif /* !UNIV_HOTBACKUP */
405
406/** Returns the size of a fixed size data type, 0 if not a fixed size type.
407@param[in] mtype main type
408@param[in] prtype precise type
409@param[in] len length
410@param[in] mbminmaxlen minimum and maximum length of a multibyte
411 character, in bytes
412@param[in] comp nonzero=ROW_FORMAT=COMPACT
413@return fixed size, or 0 */
416 bool comp);
417
418/** Returns the minimum size of a data type.
419@param[in] mtype main type
420@param[in] prtype precise type
421@param[in] len length
422@param[in] mbminmaxlen minimum and maximum length of a multibyte
423 character, in bytes
424@return minimum size */
427
428/** Returns the maximum size of a data type. Note: types in system tables may
429be incomplete and return incorrect information.
430@param[in] mtype main type
431@param[in] len length
432@return maximum size */
434
435/** Returns the ROW_FORMAT=REDUNDANT stored SQL NULL size of a type.
436For fixed length types it is the fixed length of the type, otherwise 0.
437@param[in] type type struct
438@param[in] comp nonzero=ROW_FORMAT=COMPACT
439@return SQL null storage size in ROW_FORMAT=REDUNDANT */
440static inline ulint dtype_get_sql_null_size(const dtype_t *type, bool comp);
441
442#ifndef UNIV_HOTBACKUP
443/** Reads to a type the stored information which determines its alphabetical
444ordering and the storage size of an SQL NULL value.
445@param[in] type type struct
446@param[in] buf buffer for the stored order info */
448 const byte *buf);
449
450/** Stores for a type the information which determines its alphabetical
451ordering and the storage size of an SQL NULL value. This is the >= 4.1.x
452storage format.
453@param[in] buf buffer for DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE
454 bytes where we store the info
455@param[in] type type struct
456@param[in] prefix_len prefix length to replace type->len, or 0 */
458 const dtype_t *type,
459 ulint prefix_len);
460
461/** Reads to a type the stored information which determines its alphabetical
462ordering and the storage size of an SQL NULL value. This is the 4.1.x storage
463format.
464@param[in] type type struct
465@param[in] buf buffer for stored type order info */
467 const byte *buf);
468
469/** Returns the type's SQL name (e.g. BIGINT UNSIGNED) from mtype,prtype,len
470@param[in] mtype main type
471@param[in] prtype precise type
472@param[in] len length
473@param[out] name SQL name
474@param[in] name_sz size of the name buffer
475@return the SQL type name */
476static inline char *dtype_sql_name(unsigned mtype, unsigned prtype,
477 unsigned len, char *name, unsigned name_sz);
478#endif /* !UNIV_HOTBACKUP */
479
480/** Validates a data type structure.
481 @return true if ok */
482bool dtype_validate(const dtype_t *type); /*!< in: type struct to validate */
483#ifdef UNIV_DEBUG
484/** Print a data type structure.
485@param[in] type data type */
486void dtype_print(const dtype_t *type);
487#endif /* UNIV_DEBUG */
488
489/* Structure for an SQL data type.
490If you add fields to this structure, be sure to initialize them everywhere.
491This structure is initialized in the following functions:
492dtype_set()
493dtype_read_for_order_and_null_size()
494dtype_new_read_for_order_and_null_size()
495sym_tab_add_null_lit() */
496
497struct dtype_t {
498 unsigned prtype : 32; /*!< precise type; MySQL data
499 type, charset code, flags to
500 indicate nullability,
501 signedness, whether this is a
502 binary string, whether this is
503 a true VARCHAR where MySQL
504 uses 2 bytes to store the length */
505 unsigned mtype : 8; /*!< main data type */
506
507 /* the remaining fields do not affect alphabetical ordering: */
508
509 unsigned len : 16; /*!< length; for MySQL data this
510 is field->pack_length(),
511 except that for a >= 5.0.3
512 type true VARCHAR this is the
513 maximum byte length of the
514 string data (in addition to
515 the string, MySQL uses 1 or 2
516 bytes to store the string length) */
517 unsigned mbminmaxlen : 5; /*!< minimum and maximum length of a
518 character, in bytes;
519 DATA_MBMINMAXLEN(mbminlen,mbmaxlen);
520 mbminlen=DATA_MBMINLEN(mbminmaxlen);
521 mbmaxlen=DATA_MBMINLEN(mbminmaxlen) */
522
523 bool is_virtual() const { return ((prtype & DATA_VIRTUAL) == DATA_VIRTUAL); }
524
525 std::ostream &print(std::ostream &out) const;
526};
527
528inline std::ostream &operator<<(std::ostream &out, const dtype_t &obj) {
529 return (obj.print(out));
530}
531
532static_assert(true == 1, "true != 1");
533
534static_assert(DATA_TRX_ID_LEN == 6, "DATA_TRX_ID_LEN != 6!");
535
536static_assert(DATA_ROLL_PTR_LEN == 7, "DATA_PTR_LEN != 7!");
537
538static_assert(DATA_TRX_ID + 1 == DATA_ROLL_PTR, "DATA_TRX_ID value invalid!");
539
540#include "data0type.ic"
541
542#endif
static ulint dtype_get_mbmaxlen(const dtype_t *type)
Gets the maximum length of a character, in bytes.
constexpr uint32_t DATA_FLOAT
Definition: data0type.h:79
static void dtype_read_for_order_and_null_size(dtype_t *type, const byte *buf)
Reads to a type the stored information which determines its alphabetical ordering and the storage siz...
static char * dtype_sql_name(unsigned mtype, unsigned prtype, unsigned len, char *name, unsigned name_sz)
Returns the type's SQL name (e.g.
constexpr uint32_t DATA_GIS_MBR
Used as GIS MBR column.
Definition: data0type.h:213
constexpr uint32_t DATA_MULTI_VALUE
Multi-value Virtual column.
Definition: data0type.h:224
constexpr uint32_t DATA_FIXBINARY
binary string of fixed length
Definition: data0type.h:61
constexpr uint32_t DATA_POINT
geometry datatype of fixed length POINT
Definition: data0type.h:106
ulint DATA_MBMINMAXLEN(ulint mbminlen, ulint mbmaxlen)
Definition: data0type.h:249
constexpr uint32_t DATA_BINARY
binary string
Definition: data0type.h:63
constexpr uint32_t DATA_SYS_PRTYPE_MASK
mask to extract the above from prtype
Definition: data0type.h:202
constexpr size_t DATA_ROLL_PTR
Rollback data pointer: 7 bytes.
Definition: data0type.h:187
constexpr uint32_t DATA_BLOB
binary large object, or a TEXT type; if prtype & DATA_BINARY_TYPE == 0, then this is actually a TEXT ...
Definition: data0type.h:68
constexpr uint32_t DATA_MISSING
missing column
Definition: data0type.h:53
constexpr uint32_t DATA_MYSQL_BINARY_CHARSET_COLL
Definition: data0type.h:39
static ulint dtype_get_mtype(const dtype_t *type)
Gets the SQL main data type.
static void dtype_get_mblen(ulint mtype, ulint prtype, ulint *mbminlen, ulint *mbmaxlen)
Compute the mbminlen and mbmaxlen members of a data type structure.
constexpr uint32_t DATA_MBMAX
Definition: data0type.h:237
constexpr size_t DATA_ROLL_PTR_LEN
Rollback data pointer type size in bytes.
Definition: data0type.h:190
constexpr uint32_t DATA_SYS_CHILD
address of the child page in node pointer
Definition: data0type.h:72
static ulint dtype_get_max_size_low(ulint mtype, ulint len)
Returns the maximum size of a data type.
constexpr uint32_t DATA_VAR_POINT
geometry datatype of variable length POINT, used when we want to store POINT as BLOB internally
Definition: data0type.h:109
constexpr uint32_t MAX_CHAR_COLL_NUM
Definition: data0type.h:288
constexpr uint32_t DATA_MTYPE_MAX
dtype_store_for_order_and_null_size() requires the values are <= 63
Definition: data0type.h:111
static void dtype_new_read_for_order_and_null_size(dtype_t *type, const byte *buf)
Reads to a type the stored information which determines its alphabetical ordering and the storage siz...
constexpr uint32_t DATA_VIRTUAL
Virtual column.
Definition: data0type.h:222
constexpr uint32_t DATA_FTS_DOC_ID
Used as FTS DOC ID column.
Definition: data0type.h:199
constexpr uint32_t DATA_ROW_ID
row id: a 48-bit integer
Definition: data0type.h:176
ulint data_mysql_default_charset_coll
Definition: data0type.cc:45
constexpr uint32_t DATA_ITT_N_SYS_COLS
number of system columns for intrinsic temporary table
Definition: data0type.h:196
static ulint dtype_get_mbminlen(const dtype_t *type)
Gets the minimum length of a character, in bytes.
constexpr uint32_t DATA_MYSQL_TRUE_VARCHAR
MySQL type code for the >= 5.0.3 format true VARCHAR.
Definition: data0type.h:170
constexpr uint32_t DATA_SYS
system column
Definition: data0type.h:74
constexpr size_t DATA_TRX_ID
Transaction id: 6 bytes.
Definition: data0type.h:181
static ulint dtype_get_len(const dtype_t *type)
Gets the type length.
bool dtype_is_string_type(ulint mtype)
Checks if a data main type is a string type.
Definition: data0type.cc:84
ulint DATA_MBMINLEN(ulint mbminmaxlen)
Definition: data0type.h:254
bool dtype_validate(const dtype_t *type)
Validates a data type structure.
Definition: data0type.cc:141
bool DATA_LARGE_MTYPE(ulint mtype)
Definition: data0type.h:274
constexpr uint32_t CHAR_COLL_MASK
Definition: data0type.h:291
constexpr uint32_t DATA_MTYPE_CURRENT_MAX
maximum value of mtype
Definition: data0type.h:116
constexpr uint32_t DATA_UNSIGNED
Definition: data0type.h:208
constexpr uint32_t DATA_POINT_LEN
Definition: data0type.h:246
static void dtype_set_mbminmaxlen(dtype_t *type, ulint mbminlen, ulint mbmaxlen)
Sets the minimum and maximum length of a character, in bytes.
constexpr uint32_t DATA_VARMYSQL
any charset varying length char
Definition: data0type.h:84
constexpr uint32_t DATA_MBR_LEN
GIS MBR length.
Definition: data0type.h:215
static void dtype_new_store_for_order_and_null_size(byte *buf, const dtype_t *type, ulint prefix_len)
Stores for a type the information which determines its alphabetical ordering and the storage size of ...
constexpr size_t DATA_TRX_ID_LEN
Transaction ID type size in bytes.
Definition: data0type.h:184
std::ostream & operator<<(std::ostream &out, const dtype_t &obj)
Definition: data0type.h:528
constexpr uint32_t DATA_ROW_ID_LEN
stored length for row id
Definition: data0type.h:178
constexpr uint32_t DATA_BINARY_TYPE
if the data type is a binary character string, this is ORed to the precise type: this only holds for ...
Definition: data0type.h:211
static void dtype_copy(dtype_t *type1, const dtype_t *type2)
Copies a data type structure.
ulint DATA_MBMAXLEN(ulint mbminmaxlen)
Definition: data0type.h:258
ulint dtype_get_at_most_n_mbchars(ulint prtype, ulint mbminmaxlen, ulint prefix_len, ulint data_len, const char *str)
Determine how many bytes the first n characters of the given string occupy.
Definition: data0type.cc:51
constexpr uint32_t DATA_ENGLISH
English language character string: this is a relic from pre-MySQL time and only used for InnoDB's own...
Definition: data0type.h:163
constexpr uint32_t DATA_INT
integer: can be any size 1 - 8 bytes
Definition: data0type.h:70
bool dtype_is_non_binary_string_type(ulint mtype, ulint prtype)
Checks if a type is a non-binary string type.
Definition: data0type.cc:114
constexpr uint32_t DATA_DOUBLE
Definition: data0type.h:80
static void dtype_set(dtype_t *type, ulint mtype, ulint prtype, ulint len)
Sets a data type structure.
constexpr uint32_t DATA_CHAR
fixed length character of the latin1_swedish_ci charset-collation
Definition: data0type.h:59
static ulint dtype_get_fixed_size_low(ulint mtype, ulint prtype, ulint len, ulint mbminmaxlen, bool comp)
Returns the size of a fixed size data type, 0 if not a fixed size type.
constexpr uint32_t DATA_LONG_TRUE_VARCHAR
this is ORed to the precise data type when the column is true VARCHAR where MySQL uses 2 bytes to sto...
Definition: data0type.h:220
constexpr uint32_t DATA_DECIMAL
decimal number stored as an ASCII string
Definition: data0type.h:82
static ulint dtype_get_prtype(const dtype_t *type)
Gets the precise data type.
ulint dtype_form_prtype(ulint old_prtype, ulint charset_coll)
Forms a precise type from the < 4.1.2 format precise type plus the charset-collation code.
Definition: data0type.cc:128
constexpr uint32_t DATA_NOT_NULL
this is ORed to the precise type when the column is declared as NOT NULL
Definition: data0type.h:206
constexpr uint32_t DATA_N_SYS_COLS
number of system columns defined above
Definition: data0type.h:193
constexpr uint32_t DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE
Definition: data0type.h:234
static bool dtype_is_utf8(ulint prtype)
Determines if a MySQL string type is a subset of UTF-8.
constexpr uint32_t DATA_MTYPE_CURRENT_MIN
minimum value of mtype
Definition: data0type.h:114
constexpr uint32_t DATA_MYSQL_TYPE_MASK
AND with this mask to extract the MySQL type from the precise type.
Definition: data0type.h:168
static ulint dtype_get_sql_null_size(const dtype_t *type, bool comp)
Returns the ROW_FORMAT=REDUNDANT stored SQL NULL size of a type.
void dtype_print(const dtype_t *type)
Print a data type structure.
Definition: data0type.cc:159
constexpr uint32_t DATA_VARCHAR
character varying of the latin1_swedish_ci charset-collation; note that the MySQL format for this,...
Definition: data0type.h:57
static ulint dtype_get_min_size_low(ulint mtype, ulint prtype, ulint len, ulint mbminmaxlen)
Returns the minimum size of a data type.
constexpr uint32_t DATA_ORDER_NULL_TYPE_BUF_SIZE
Definition: data0type.h:231
static ulint dtype_get_charset_coll(ulint prtype)
Gets the MySQL charset-collation code for MySQL string types.
ib_like_t
SQL Like operator comparison types.
Definition: data0type.h:45
@ IB_LIKE_PREFIX
e.g., STRING%
Definition: data0type.h:47
@ IB_LIKE_EXACT
e.g.
Definition: data0type.h:46
constexpr uint32_t DATA_MYSQL
any charset fixed length char NOTE that 4.1.1 used DATA_MYSQL and DATA_VARMYSQL for all character set...
Definition: data0type.h:89
static ulint dtype_get_mysql_type(const dtype_t *type)
Gets the MySQL type code from a dtype.
constexpr uint32_t DATA_ERROR
another relic from pre-MySQL time
Definition: data0type.h:165
bool dtype_is_binary_string_type(ulint mtype, ulint prtype)
Checks if a type is a binary string type.
Definition: data0type.cc:98
constexpr uint32_t DATA_GEOMETRY
Definition: data0type.h:100
bool DATA_BIG_LEN_MTYPE(ulint len, ulint mtype)
Definition: data0type.h:280
bool DATA_POINT_MTYPE(ulint mtype)
Definition: data0type.h:263
bool DATA_GEOMETRY_MTYPE(ulint mtype)
Definition: data0type.h:268
Data types.
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1063
Definition: buf0block_hint.cc:29
required string type
Definition: replication_group_member_actions.proto:33
case opt name
Definition: sslopt-case.h:32
Definition: data0type.h:497
unsigned prtype
precise type; MySQL data type, charset code, flags to indicate nullability, signedness,...
Definition: data0type.h:498
std::ostream & print(std::ostream &out) const
Definition: data0type.cc:272
unsigned len
length; for MySQL data this is field->pack_length(), except that for a >= 5.0.3 type true VARCHAR thi...
Definition: data0type.h:509
bool is_virtual() const
Definition: data0type.h:523
unsigned mbminmaxlen
minimum and maximum length of a character, in bytes; DATA_MBMINMAXLEN(mbminlen,mbmaxlen); mbminlen=DA...
Definition: data0type.h:517
unsigned mtype
main data type
Definition: data0type.h:505
Version control for database, common definitions, and include files.
constexpr uint32_t SPDIMS
Definition: univ.i:644
unsigned long int ulint
Definition: univ.i:407
#define UNIV_EXPECT(expr, value)
Definition: univ.i:513