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