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