data0type.ic 15.1 KB
Newer Older
vasil's avatar
vasil committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*****************************************************************************

Copyright (c) 1996, 2009, Innobase Oy. All Rights Reserved.

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place, Suite 330, Boston, MA 02111-1307 USA

*****************************************************************************/

osku's avatar
osku committed
19 20 21 22 23 24 25
/******************************************************
Data types

Created 1/16/1996 Heikki Tuuri
*******************************************************/

#include "mach0data.h"
26 27
#ifndef UNIV_HOTBACKUP
# include "ha_prototypes.h"
osku's avatar
osku committed
28 29 30 31 32 33 34 35 36 37 38 39

/*************************************************************************
Gets the MySQL charset-collation code for MySQL string types. */
UNIV_INLINE
ulint
dtype_get_charset_coll(
/*===================*/
	ulint	prtype)	/* in: precise data type */
{
	return((prtype >> 16) & 0xFFUL);
}

40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
/*************************************************************************
Determines if a MySQL string type is a subset of UTF-8.  This function
may return false negatives, in case further character-set collation
codes are introduced in MySQL later. */
UNIV_INLINE
ibool
dtype_is_utf8(
/*==========*/
			/* out: TRUE if a subset of UTF-8 */
	ulint	prtype)	/* in: precise data type */
{
	/* These codes have been copied from strings/ctype-extra.c
	and strings/ctype-utf8.c. */
	switch (dtype_get_charset_coll(prtype)) {
	case 11: /* ascii_general_ci */
	case 65: /* ascii_bin */
	case 33: /* utf8_general_ci */
	case 83: /* utf8_bin */
	case 254: /* utf8_general_cs */
			return(TRUE);
	}

	return(FALSE);
}

osku's avatar
osku committed
65 66 67 68 69 70 71 72
/*************************************************************************
Gets the MySQL type code from a dtype. */
UNIV_INLINE
ulint
dtype_get_mysql_type(
/*=================*/
				/* out: MySQL type code; this is NOT an InnoDB
				type code! */
73
	const dtype_t*	type)	/* in: type struct */
osku's avatar
osku committed
74 75 76 77 78
{
	return(type->prtype & 0xFFUL);
}

/*************************************************************************
79
Compute the mbminlen and mbmaxlen members of a data type structure. */
osku's avatar
osku committed
80 81
UNIV_INLINE
void
82
dtype_get_mblen(
osku's avatar
osku committed
83
/*============*/
84 85 86 87 88 89
	ulint	mtype,		/* in: main type */
	ulint	prtype,		/* in: precise type (and collation) */
	ulint*	mbminlen,	/* out: minimum length of a
				multi-byte character */
	ulint*	mbmaxlen)	/* out: maximum length of a
				multi-byte character */
osku's avatar
osku committed
90
{
91 92 93 94
	if (dtype_is_string_type(mtype)) {
		innobase_get_cset_width(dtype_get_charset_coll(prtype),
					mbminlen, mbmaxlen);
		ut_ad(*mbminlen <= *mbmaxlen);
95 96
		ut_ad(*mbminlen <= 2); /* mbminlen in dtype_t is 0..3 */
		ut_ad(*mbmaxlen < 1 << 3); /* mbmaxlen in dtype_t is 0..7 */
osku's avatar
osku committed
97
	} else {
98
		*mbminlen = *mbmaxlen = 0;
osku's avatar
osku committed
99 100 101
	}
}

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
/*************************************************************************
Compute the mbminlen and mbmaxlen members of a data type structure. */
UNIV_INLINE
void
dtype_set_mblen(
/*============*/
	dtype_t*	type)	/* in/out: type */
{
	ulint	mbminlen;
	ulint	mbmaxlen;

	dtype_get_mblen(type->mtype, type->prtype, &mbminlen, &mbmaxlen);
	type->mbminlen = mbminlen;
	type->mbmaxlen = mbmaxlen;

	ut_ad(dtype_validate(type));
}
119 120 121
#else /* !UNIV_HOTBACKUP */
# define dtype_set_mblen(type) (void) 0
#endif /* !UNIV_HOTBACKUP */
122

osku's avatar
osku committed
123 124 125 126 127 128 129 130 131
/*************************************************************************
Sets a data type structure. */
UNIV_INLINE
void
dtype_set(
/*======*/
	dtype_t*	type,	/* in: type struct to init */
	ulint		mtype,	/* in: main data type */
	ulint		prtype,	/* in: precise type */
132
	ulint		len)	/* in: precision of type */
osku's avatar
osku committed
133 134 135
{
	ut_ad(type);
	ut_ad(mtype <= DATA_MTYPE_MAX);
136

osku's avatar
osku committed
137 138 139 140 141 142 143 144 145 146 147 148 149 150
	type->mtype = mtype;
	type->prtype = prtype;
	type->len = len;

	dtype_set_mblen(type);
}

/*************************************************************************
Copies a data type structure. */
UNIV_INLINE
void
dtype_copy(
/*=======*/
	dtype_t*	type1,	/* in: type struct to copy to */
151
	const dtype_t*	type2)	/* in: type struct to copy from */
osku's avatar
osku committed
152 153 154 155 156 157 158 159 160 161 162 163
{
	*type1 = *type2;

	ut_ad(dtype_validate(type1));
}

/*************************************************************************
Gets the SQL main data type. */
UNIV_INLINE
ulint
dtype_get_mtype(
/*============*/
164 165
				/* out: SQL main data type */
	const dtype_t*	type)	/* in: data type */
osku's avatar
osku committed
166 167 168 169 170 171 172 173 174 175 176 177
{
	ut_ad(type);

	return(type->mtype);
}

/*************************************************************************
Gets the precise data type. */
UNIV_INLINE
ulint
dtype_get_prtype(
/*=============*/
178 179
				/* out: precise data type */
	const dtype_t*	type)	/* in: data type */
osku's avatar
osku committed
180 181 182 183 184 185 186 187 188 189 190 191
{
	ut_ad(type);

	return(type->prtype);
}

/*************************************************************************
Gets the type length. */
UNIV_INLINE
ulint
dtype_get_len(
/*==========*/
192 193 194
				/* out: fixed length of the type, in bytes,
				or 0 if variable-length */
	const dtype_t*	type)	/* in: data type */
osku's avatar
osku committed
195 196 197 198 199 200
{
	ut_ad(type);

	return(type->len);
}

201
#ifndef UNIV_HOTBACKUP
osku's avatar
osku committed
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
/*************************************************************************
Gets the minimum length of a character, in bytes. */
UNIV_INLINE
ulint
dtype_get_mbminlen(
/*===============*/
				/* out: minimum length of a char, in bytes,
				or 0 if this is not a character type */
	const dtype_t*	type)	/* in: type */
{
	ut_ad(type);
	return(type->mbminlen);
}
/*************************************************************************
Gets the maximum length of a character, in bytes. */
UNIV_INLINE
ulint
dtype_get_mbmaxlen(
/*===============*/
				/* out: maximum length of a char, in bytes,
				or 0 if this is not a character type */
	const dtype_t*	type)	/* in: type */
{
	ut_ad(type);
	return(type->mbmaxlen);
}

/*************************************************************************
230
Gets the padding character code for a type. */
osku's avatar
osku committed
231 232 233 234 235 236
UNIV_INLINE
ulint
dtype_get_pad_char(
/*===============*/
				/* out: padding character code, or
				ULINT_UNDEFINED if no padding specified */
237 238
	ulint	mtype,		/* in: main type */
	ulint	prtype)		/* in: precise type */
osku's avatar
osku committed
239
{
240
	switch (mtype) {
241 242
	case DATA_FIXBINARY:
	case DATA_BINARY:
243
		if (UNIV_UNLIKELY(dtype_get_charset_coll(prtype)
244
				  == DATA_MYSQL_BINARY_CHARSET_COLL)) {
245 246 247 248 249 250 251 252 253
			/* Starting from 5.0.18, do not pad
			VARBINARY or BINARY columns. */
			return(ULINT_UNDEFINED);
		}
		/* Fall through */
	case DATA_CHAR:
	case DATA_VARCHAR:
	case DATA_MYSQL:
	case DATA_VARMYSQL:
osku's avatar
osku committed
254
		/* Space is the padding character for all char and binary
255
		strings, and starting from 5.0.3, also for TEXT strings. */
osku's avatar
osku committed
256

257 258
		return(0x20);
	case DATA_BLOB:
259
		if (!(prtype & DATA_BINARY_TYPE)) {
260 261 262 263 264 265
			return(0x20);
		}
		/* Fall through */
	default:
		/* No padding specified */
		return(ULINT_UNDEFINED);
osku's avatar
osku committed
266 267 268 269 270 271 272 273 274 275 276 277 278 279
	}
}

/**************************************************************************
Stores for a type the information which determines its alphabetical ordering
and the storage size of an SQL NULL value. This is the >= 4.1.x storage
format. */
UNIV_INLINE
void
dtype_new_store_for_order_and_null_size(
/*====================================*/
	byte*		buf,	/* in: buffer for
				DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE
				bytes where we store the info */
280
	const dtype_t*	type,	/* in: type struct */
281 282
	ulint		prefix_len)/* in: prefix length to
				replace type->len, or 0 */
osku's avatar
osku committed
283 284 285 286
{
#if 6 != DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE
#error "6 != DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE"
#endif
287
	ulint	len;
osku's avatar
osku committed
288 289 290 291 292 293 294

	buf[0] = (byte)(type->mtype & 0xFFUL);

	if (type->prtype & DATA_BINARY_TYPE) {
		buf[0] = buf[0] | 128;
	}

295
	/* In versions < 4.1.2 we had:	if (type->prtype & DATA_NONLATIN1) {
296 297
	buf[0] = buf[0] | 64;
	}
osku's avatar
osku committed
298 299 300 301
	*/

	buf[1] = (byte)(type->prtype & 0xFFUL);

302 303 304
	len = prefix_len ? prefix_len : type->len;

	mach_write_to_2(buf + 2, len & 0xFFFFUL);
osku's avatar
osku committed
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322

	ut_ad(dtype_get_charset_coll(type->prtype) < 256);
	mach_write_to_2(buf + 4, dtype_get_charset_coll(type->prtype));

	if (type->prtype & DATA_NOT_NULL) {
		buf[4] |= 128;
	}
}

/**************************************************************************
Reads to a type the stored information which determines its alphabetical
ordering and the storage size of an SQL NULL value. This is the < 4.1.x
storage format. */
UNIV_INLINE
void
dtype_read_for_order_and_null_size(
/*===============================*/
	dtype_t*	type,	/* in: type struct */
323
	const byte*	buf)	/* in: buffer for stored type order info */
osku's avatar
osku committed
324
{
325 326 327
#if 4 != DATA_ORDER_NULL_TYPE_BUF_SIZE
# error "4 != DATA_ORDER_NULL_TYPE_BUF_SIZE"
#endif
328

osku's avatar
osku committed
329 330 331 332
	type->mtype = buf[0] & 63;
	type->prtype = buf[1];

	if (buf[0] & 128) {
333
		type->prtype = type->prtype | DATA_BINARY_TYPE;
osku's avatar
osku committed
334 335 336
	}

	type->len = mach_read_from_2(buf + 2);
337

osku's avatar
osku committed
338
	type->prtype = dtype_form_prtype(type->prtype,
339
					 data_mysql_default_charset_coll);
osku's avatar
osku committed
340
	dtype_set_mblen(type);
341
}
osku's avatar
osku committed
342 343 344 345 346 347 348 349 350 351

/**************************************************************************
Reads to a type the stored information which determines its alphabetical
ordering and the storage size of an SQL NULL value. This is the >= 4.1.x
storage format. */
UNIV_INLINE
void
dtype_new_read_for_order_and_null_size(
/*===================================*/
	dtype_t*	type,	/* in: type struct */
352
	const byte*	buf)	/* in: buffer for stored type order info */
osku's avatar
osku committed
353 354 355 356 357 358
{
	ulint	charset_coll;

#if 6 != DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE
#error "6 != DATA_NEW_ORDER_NULL_TYPE_BUF_SIZE"
#endif
359

osku's avatar
osku committed
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
	type->mtype = buf[0] & 63;
	type->prtype = buf[1];

	if (buf[0] & 128) {
		type->prtype |= DATA_BINARY_TYPE;
	}

	if (buf[4] & 128) {
		type->prtype |= DATA_NOT_NULL;
	}

	type->len = mach_read_from_2(buf + 2);

	charset_coll = mach_read_from_2(buf + 4) & 0x7fff;

	if (dtype_is_string_type(type->mtype)) {
		ut_a(charset_coll < 256);

		if (charset_coll == 0) {
			/* This insert buffer record was inserted with MySQL
			version < 4.1.2, and the charset-collation code was not
			explicitly stored to dtype->prtype at that time. It
			must be the default charset-collation of this MySQL
			installation. */

			charset_coll = data_mysql_default_charset_coll;
		}
387

osku's avatar
osku committed
388
		type->prtype = dtype_form_prtype(type->prtype, charset_coll);
389
	}
osku's avatar
osku committed
390 391
	dtype_set_mblen(type);
}
392
#endif /* !UNIV_HOTBACKUP */
osku's avatar
osku committed
393 394 395 396 397

/***************************************************************************
Returns the size of a fixed size data type, 0 if not a fixed size type. */
UNIV_INLINE
ulint
398 399
dtype_get_fixed_size_low(
/*=====================*/
osku's avatar
osku committed
400
				/* out: fixed size, or 0 */
401 402 403 404
	ulint	mtype,		/* in: main type */
	ulint	prtype,		/* in: precise type */
	ulint	len,		/* in: length */
	ulint	mbminlen,	/* in: minimum length of a multibyte char */
405 406
	ulint	mbmaxlen,	/* in: maximum length of a multibyte char */
	ulint	comp)		/* in: nonzero=ROW_FORMAT=COMPACT  */
osku's avatar
osku committed
407 408 409 410
{
	switch (mtype) {
	case DATA_SYS:
#ifdef UNIV_DEBUG
411
		switch (prtype & DATA_MYSQL_TYPE_MASK) {
412
		case DATA_ROW_ID:
413
			ut_ad(len == DATA_ROW_ID_LEN);
414 415
			break;
		case DATA_TRX_ID:
416
			ut_ad(len == DATA_TRX_ID_LEN);
417 418
			break;
		case DATA_ROLL_PTR:
419
			ut_ad(len == DATA_ROLL_PTR_LEN);
420
			break;
421 422 423
		default:
			ut_ad(0);
			return(0);
424
		}
osku's avatar
osku committed
425 426 427 428 429 430
#endif /* UNIV_DEBUG */
	case DATA_CHAR:
	case DATA_FIXBINARY:
	case DATA_INT:
	case DATA_FLOAT:
	case DATA_DOUBLE:
431
		return(len);
osku's avatar
osku committed
432
	case DATA_MYSQL:
433
#ifndef UNIV_HOTBACKUP
434 435
		if (prtype & DATA_BINARY_TYPE) {
			return(len);
436 437
		} else if (!comp) {
			return(len);
438 439 440
		} else {
			/* We play it safe here and ask MySQL for
			mbminlen and mbmaxlen.	Although
441 442
			mbminlen and mbmaxlen are
			initialized if and only if prtype
443 444 445 446
			is (in one of the 3 functions in this file),
			it could be that none of these functions
			has been called. */

447
			ulint	i_mbminlen, i_mbmaxlen;
448

449 450 451
			innobase_get_cset_width(
				dtype_get_charset_coll(prtype),
				&i_mbminlen, &i_mbmaxlen);
452

453 454
			if (UNIV_UNLIKELY(mbminlen != i_mbminlen)
			    || UNIV_UNLIKELY(mbmaxlen != i_mbmaxlen)) {
455 456 457 458 459 460 461

				ut_print_timestamp(stderr);
				fprintf(stderr, "  InnoDB: "
					"mbminlen=%lu, "
					"mbmaxlen=%lu, "
					"type->mbminlen=%lu, "
					"type->mbmaxlen=%lu\n",
462 463
					(ulong) i_mbminlen,
					(ulong) i_mbmaxlen,
464
					(ulong) mbminlen,
465
					(ulong) mbmaxlen);
osku's avatar
osku committed
466
			}
467
			if (mbminlen == mbmaxlen) {
468
				return(len);
469 470
			}
		}
471 472 473
#else /* !UNIV_HOTBACKUP */
		return(len);
#endif /* !UNIV_HOTBACKUP */
474
		/* fall through for variable-length charsets */
osku's avatar
osku committed
475 476 477 478 479
	case DATA_VARCHAR:
	case DATA_BINARY:
	case DATA_DECIMAL:
	case DATA_VARMYSQL:
	case DATA_BLOB:
480 481 482
		return(0);
	default:
		ut_error;
osku's avatar
osku committed
483 484 485 486 487
	}

	return(0);
}

488
#ifndef UNIV_HOTBACKUP
osku's avatar
osku committed
489 490 491 492
/***************************************************************************
Returns the minimum size of a data type. */
UNIV_INLINE
ulint
493 494
dtype_get_min_size_low(
/*===================*/
osku's avatar
osku committed
495
				/* out: minimum size */
496 497 498 499 500
	ulint	mtype,		/* in: main type */
	ulint	prtype,		/* in: precise type */
	ulint	len,		/* in: length */
	ulint	mbminlen,	/* in: minimum length of a multibyte char */
	ulint	mbmaxlen)	/* in: maximum length of a multibyte char */
osku's avatar
osku committed
501
{
502
	switch (mtype) {
osku's avatar
osku committed
503 504
	case DATA_SYS:
#ifdef UNIV_DEBUG
505
		switch (prtype & DATA_MYSQL_TYPE_MASK) {
506
		case DATA_ROW_ID:
507
			ut_ad(len == DATA_ROW_ID_LEN);
508 509
			break;
		case DATA_TRX_ID:
510
			ut_ad(len == DATA_TRX_ID_LEN);
511 512
			break;
		case DATA_ROLL_PTR:
513
			ut_ad(len == DATA_ROLL_PTR_LEN);
514
			break;
515 516 517
		default:
			ut_ad(0);
			return(0);
518
		}
osku's avatar
osku committed
519 520 521 522 523 524
#endif /* UNIV_DEBUG */
	case DATA_CHAR:
	case DATA_FIXBINARY:
	case DATA_INT:
	case DATA_FLOAT:
	case DATA_DOUBLE:
525
		return(len);
osku's avatar
osku committed
526
	case DATA_MYSQL:
527 528
		if ((prtype & DATA_BINARY_TYPE) || mbminlen == mbmaxlen) {
			return(len);
529 530
		}
		/* this is a variable-length character set */
531 532 533 534
		ut_a(mbminlen > 0);
		ut_a(mbmaxlen > mbminlen);
		ut_a(len % mbmaxlen == 0);
		return(len * mbminlen / mbmaxlen);
osku's avatar
osku committed
535 536 537 538 539
	case DATA_VARCHAR:
	case DATA_BINARY:
	case DATA_DECIMAL:
	case DATA_VARMYSQL:
	case DATA_BLOB:
540
		return(0);
541 542
	default:
		ut_error;
osku's avatar
osku committed
543 544 545 546 547 548
	}

	return(0);
}

/***************************************************************************
549 550
Returns the maximum size of a data type. Note: types in system tables may be
incomplete and return incorrect information. */
osku's avatar
osku committed
551 552
UNIV_INLINE
ulint
553 554 555 556 557
dtype_get_max_size_low(
/*===================*/
				/* out: maximum size */
	ulint	mtype,		/* in: main type */
	ulint	len)		/* in: length */
osku's avatar
osku committed
558
{
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
	switch (mtype) {
	case DATA_SYS:
	case DATA_CHAR:
	case DATA_FIXBINARY:
	case DATA_INT:
	case DATA_FLOAT:
	case DATA_DOUBLE:
	case DATA_MYSQL:
	case DATA_VARCHAR:
	case DATA_BINARY:
	case DATA_DECIMAL:
	case DATA_VARMYSQL:
		return(len);
	case DATA_BLOB:
		break;
	default:
		ut_error;
	}

	return(ULINT_MAX);
osku's avatar
osku committed
579
}
580
#endif /* !UNIV_HOTBACKUP */
osku's avatar
osku committed
581 582

/***************************************************************************
583 584
Returns the ROW_FORMAT=REDUNDANT stored SQL NULL size of a type.
For fixed length types it is the fixed length of the type, otherwise 0. */
osku's avatar
osku committed
585
UNIV_INLINE
586 587 588 589 590
ulint
dtype_get_sql_null_size(
/*====================*/
				/* out: SQL null storage size
				in ROW_FORMAT=REDUNDANT */
591 592
	const dtype_t*	type,	/* in: type */
	ulint		comp)	/* in: nonzero=ROW_FORMAT=COMPACT  */
osku's avatar
osku committed
593
{
594
#ifndef UNIV_HOTBACKUP
595
	return(dtype_get_fixed_size_low(type->mtype, type->prtype, type->len,
596
					type->mbminlen, type->mbmaxlen, comp));
597 598
#else /* !UNIV_HOTBACKUP */
	return(dtype_get_fixed_size_low(type->mtype, type->prtype, type->len,
599
					0, 0, 0));
600
#endif /* !UNIV_HOTBACKUP */
osku's avatar
osku committed
601
}