field.cc 247 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   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; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   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.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21
   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 */


/*****************************************************************************
** This file implements classes defined in field.h
*****************************************************************************/

22
#ifdef USE_PRAGMA_IMPLEMENTATION
unknown's avatar
unknown committed
23 24 25 26 27 28 29 30 31 32 33
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include "sql_select.h"
#include <m_ctype.h>
#include <errno.h>
#ifdef HAVE_FCONVERT
#include <floatingpoint.h>
#endif

unknown's avatar
unknown committed
34 35 36
// Maximum allowed exponent value for converting string to decimal
#define MAX_EXPONENT 1024

unknown's avatar
unknown committed
37
/*****************************************************************************
38
  Instansiate templates and static variables
unknown's avatar
unknown committed
39 40
*****************************************************************************/

41
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
unknown's avatar
unknown committed
42 43 44 45 46 47 48
template class List<create_field>;
template class List_iterator<create_field>;
#endif

uchar Field_null::null[1]={1};
const char field_separator=',';

49
#define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE 320
50 51
#define BLOB_PACK_LENGTH_TO_MAX_LENGH(arg) \
((ulong) ((LL(1) << min(arg, 4) * 8) - LL(1)))
52

53 54 55 56 57 58 59
/*
  Rules for merging different types of fields in UNION

  NOTE: to avoid 256*256 table, gap in table types numeration is skiped
  following #defines describe that gap and how to canculate number of fields
  and index of field in thia array.
*/
unknown's avatar
unknown committed
60 61 62
#define FIELDTYPE_TEAR_FROM (MYSQL_TYPE_BIT + 1)
#define FIELDTYPE_TEAR_TO   (MYSQL_TYPE_NEWDECIMAL - 1)
#define FIELDTYPE_NUM (FIELDTYPE_TEAR_FROM + (255 - FIELDTYPE_TEAR_TO))
63 64 65 66 67 68 69
inline int field_type2index (enum_field_types field_type)
{
  return (field_type < FIELDTYPE_TEAR_FROM ?
          field_type :
          ((int)FIELDTYPE_TEAR_FROM) + (field_type - FIELDTYPE_TEAR_TO) - 1);
}

unknown's avatar
unknown committed
70

71 72 73 74 75
static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
{
  /* MYSQL_TYPE_DECIMAL -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
76
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_NEWDECIMAL,
77
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
unknown's avatar
unknown committed
78
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_NEWDECIMAL,
79 80 81
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
82
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
83 84 85
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_DECIMAL,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
86
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
87
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
88 89 90 91 92 93 94
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
95
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
96
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
97 98 99
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
100
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
101
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
102
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
103 104 105 106
  },
  /* MYSQL_TYPE_TINY -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
107
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_TINY,
108 109 110 111 112
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
113
    MYSQL_TYPE_TINY,        MYSQL_TYPE_VARCHAR,
114 115 116
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
117
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
118
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
119 120 121 122 123 124 125
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
126
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
127
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
128 129 130
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
131
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
132
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
133
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
134 135 136 137
  },
  /* MYSQL_TYPE_SHORT -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
138
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_SHORT,
139 140 141 142 143
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
144
    MYSQL_TYPE_SHORT,       MYSQL_TYPE_VARCHAR,
145 146 147
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
148
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
149
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
150 151 152 153 154 155 156
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_SHORT,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
157
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
158
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
159 160 161
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
162
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
163
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
164
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
165 166 167 168
  },
  /* MYSQL_TYPE_LONG -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
169
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_LONG,
170 171 172 173 174
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_LONG,        MYSQL_TYPE_LONG,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
175
    MYSQL_TYPE_LONG,         MYSQL_TYPE_VARCHAR,
176
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
177
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
178
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
179
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
180
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
181 182 183 184 185 186 187
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_LONG,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
188
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
189
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
190 191 192
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
193
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
194
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
195
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
196 197 198 199 200 201 202 203 204 205
  },
  /* MYSQL_TYPE_FLOAT -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_FLOAT,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
206
    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_VARCHAR,
207
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
208
    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_INT24,
209
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
210
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
211
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
212 213 214 215 216 217 218
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_FLOAT,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_VARCHAR,
219
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
220
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
221 222 223
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
224
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
225
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
226
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
227 228 229 230 231 232 233 234 235 236
  },
  /* MYSQL_TYPE_DOUBLE -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
237
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_VARCHAR,
238
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
239
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_INT24,
240
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
241
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
242
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
243 244 245 246 247 248 249
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_VARCHAR,
250
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
251
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
252 253 254
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
255
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
256
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
257
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
258 259 260 261
  },
  /* MYSQL_TYPE_NULL -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
262
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_TINY,
263 264 265 266 267 268 269 270 271 272 273 274
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_NULL,        MYSQL_TYPE_TIMESTAMP,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_TIME,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_YEAR,
unknown's avatar
unknown committed
275 276 277 278 279 280
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_BIT,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_ENUM,
281 282 283 284 285
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
    MYSQL_TYPE_SET,         MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
286
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
287 288 289 290 291 292
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
    MYSQL_TYPE_STRING,      MYSQL_TYPE_GEOMETRY
  },
  /* MYSQL_TYPE_TIMESTAMP -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
293
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
294
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
unknown's avatar
unknown committed
295
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
296
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
unknown's avatar
unknown committed
297
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
298 299 300
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_TIMESTAMP,   MYSQL_TYPE_TIMESTAMP,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
301
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
302 303 304
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_DATETIME,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
305 306 307 308 309 310 311
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
312
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
313
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
314 315 316
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
317
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
318
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
319
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
320 321 322 323
  },
  /* MYSQL_TYPE_LONGLONG -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
324
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_LONGLONG,
325 326 327 328 329
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_LONGLONG,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
330
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_VARCHAR,
331 332 333
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_LONG,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
334
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
335
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
336 337 338 339 340 341 342
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_LONGLONG,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
343
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
344
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
345 346 347
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
348
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
349
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
350
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
351 352 353 354
  },
  /* MYSQL_TYPE_INT24 -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
355
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_INT24,
356 357 358 359 360
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_INT24,       MYSQL_TYPE_LONG,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
361
    MYSQL_TYPE_INT24,       MYSQL_TYPE_VARCHAR,
362 363 364
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
365
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
366
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
367 368 369 370 371 372 373
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_INT24,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL    MYSQL_TYPE_ENUM
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
374
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
375
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
376 377 378
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
379
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
380
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
381
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
382 383 384 385
  },
  /* MYSQL_TYPE_DATE -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
386
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
387
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
unknown's avatar
unknown committed
388
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
389
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
unknown's avatar
unknown committed
390
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
391 392 393
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
394
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
395 396 397
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
398 399 400 401 402 403 404
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
405
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
406
    MYSQL_TYPE_VARCHAR,  MYSQL_TYPE_TINY_BLOB,
407 408 409
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
410
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
411
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
412
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
413 414 415 416
  },
  /* MYSQL_TYPE_TIME -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
417
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
418
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
unknown's avatar
unknown committed
419
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
420
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
unknown's avatar
unknown committed
421
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
422 423 424
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_TIME,        MYSQL_TYPE_DATETIME,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
425
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
426 427 428
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_TIME,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
429 430 431 432 433 434 435
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
436
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
437
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
438 439 440
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
441
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
442
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
443
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
444 445 446 447
  },
  /* MYSQL_TYPE_DATETIME -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
448
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
449
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
unknown's avatar
unknown committed
450
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
451
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
unknown's avatar
unknown committed
452
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
453 454 455
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_DATETIME,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
456
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
457 458 459
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_DATETIME,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
460 461 462 463 464 465 466
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
467
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
468
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
469 470 471
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
472
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
473
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
474
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
475 476 477 478 479 480 481 482 483 484
  },
  /* MYSQL_TYPE_YEAR -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_TINY,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
485
    MYSQL_TYPE_YEAR,        MYSQL_TYPE_VARCHAR,
486 487 488
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
489
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
490
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
491 492 493 494 495 496 497
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_YEAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
498
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
499
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
500 501 502
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
503
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
504
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
505
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
506 507 508 509
  },
  /* MYSQL_TYPE_NEWDATE -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
510
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
511
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
unknown's avatar
unknown committed
512
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
513
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
unknown's avatar
unknown committed
514
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
515 516 517
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
518
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
519 520 521
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
  },
  /* MYSQL_TYPE_VARCHAR -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR
  },
  /* MYSQL_TYPE_BIT -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_BIT,         MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_BIT,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
  },
  /* MYSQL_TYPE_NEWDECIMAL -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_NEWDECIMAL,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_NEWDECIMAL,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_NEWDECIMAL,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_NEWDECIMAL,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
622
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
623
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
624 625 626
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
627
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
628
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
629
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
630 631 632 633
  },
  /* MYSQL_TYPE_ENUM -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
634
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
635
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
unknown's avatar
unknown committed
636
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
637
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
unknown's avatar
unknown committed
638
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
639
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
640
    MYSQL_TYPE_ENUM,        MYSQL_TYPE_VARCHAR,
641
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
642
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
643
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
644
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
645
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
646 647 648 649 650 651 652
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
653
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
654
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
655 656 657
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
658
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
659
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
660
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
661 662 663 664
  },
  /* MYSQL_TYPE_SET -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
665
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
666
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
unknown's avatar
unknown committed
667
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
668
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
unknown's avatar
unknown committed
669
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
670
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
671
    MYSQL_TYPE_SET,         MYSQL_TYPE_VARCHAR,
672
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
673
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
674
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
675
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
676
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
677 678 679 680 681 682 683
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
684
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
685
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
686 687 688
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
689
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
690
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
691
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
  },
  /* MYSQL_TYPE_TINY_BLOB -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
unknown's avatar
unknown committed
709 710 711
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_BIT          <16>-<245>
712
    MYSQL_TYPE_TINY_BLOB,
unknown's avatar
unknown committed
713 714
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
    MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB
  },
  /* MYSQL_TYPE_MEDIUM_BLOB -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
unknown's avatar
unknown committed
740 741 742
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  //MYSQL_TYPE_BIT          <16>-<245>
743
    MYSQL_TYPE_MEDIUM_BLOB,
unknown's avatar
unknown committed
744 745
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB
  },
  /* MYSQL_TYPE_LONG_BLOB -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
unknown's avatar
unknown committed
771 772 773
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BIT          <16>-<245>
774
    MYSQL_TYPE_LONG_BLOB,
unknown's avatar
unknown committed
775 776
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
    MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB
  },
  /* MYSQL_TYPE_BLOB -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
unknown's avatar
unknown committed
802 803 804
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  //MYSQL_TYPE_BIT          <16>-<245>
805
    MYSQL_TYPE_BLOB,
unknown's avatar
unknown committed
806 807
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
808 809 810 811 812 813 814 815 816 817 818 819
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB
  },
  /* MYSQL_TYPE_VAR_STRING -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
820
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
821
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
unknown's avatar
unknown committed
822
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
823
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
unknown's avatar
unknown committed
824
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
825
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
826
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
827
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
828
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
829
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
830
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
831
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
832 833 834 835 836 837 838
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
839
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
840
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
841 842 843
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
844
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
845
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
unknown's avatar
unknown committed
846
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
  },
  /* MYSQL_TYPE_STRING -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
unknown's avatar
unknown committed
864 865 866
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
867
    MYSQL_TYPE_STRING,
unknown's avatar
unknown committed
868 869
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
870 871 872 873 874
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
    MYSQL_TYPE_STRING,      MYSQL_TYPE_TINY_BLOB,
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
875
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
876 877 878 879 880 881
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING
  },
  /* MYSQL_TYPE_GEOMETRY -> */
  {
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
882
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
883
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
unknown's avatar
unknown committed
884
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
885
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
unknown's avatar
unknown committed
886
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
887
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
unknown's avatar
unknown committed
888
    MYSQL_TYPE_GEOMETRY,    MYSQL_TYPE_VARCHAR,
889
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
unknown's avatar
unknown committed
890
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
891
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
unknown's avatar
unknown committed
892
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
893
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
unknown's avatar
unknown committed
894 895 896 897 898 899 900
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_BIT          <16>-<245>
    MYSQL_TYPE_VARCHAR,
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
901
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
unknown's avatar
unknown committed
902
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY_BLOB,
903 904 905
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
    MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
unknown's avatar
unknown committed
906
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
    MYSQL_TYPE_STRING,      MYSQL_TYPE_GEOMETRY
  }
};

/*
  Return type of which can carry value of both given types in UNION result

  SYNOPSIS
    Field::field_type_merge()
    a, b  types for merging

  RETURN
    type of field
*/

enum_field_types Field::field_type_merge(enum_field_types a,
                                         enum_field_types b)
{
  DBUG_ASSERT(a < FIELDTYPE_TEAR_FROM || a > FIELDTYPE_TEAR_TO);
  DBUG_ASSERT(b < FIELDTYPE_TEAR_FROM || b > FIELDTYPE_TEAR_TO);
  return field_types_merge_rules[field_type2index(a)]
                                [field_type2index(b)];
}


static Item_result field_types_result_type [FIELDTYPE_NUM]=
{
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
unknown's avatar
unknown committed
936
  DECIMAL_RESULT,           INT_RESULT,
937 938 939 940 941 942 943 944 945 946 947 948
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  INT_RESULT,               INT_RESULT,
  //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  REAL_RESULT,              REAL_RESULT,
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  STRING_RESULT,            STRING_RESULT,
  //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  INT_RESULT,               INT_RESULT,
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  STRING_RESULT,            STRING_RESULT,
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  STRING_RESULT,            INT_RESULT,
unknown's avatar
unknown committed
949 950 951
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
  STRING_RESULT,            STRING_RESULT,
  //MYSQL_TYPE_BIT          <16>-<245>
952
  STRING_RESULT,
unknown's avatar
unknown committed
953 954
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
  DECIMAL_RESULT,           STRING_RESULT,
955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983
  //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  STRING_RESULT,            STRING_RESULT,
  //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  STRING_RESULT,            STRING_RESULT,
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  STRING_RESULT,            STRING_RESULT,
  //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  STRING_RESULT,            STRING_RESULT
};


/*
  Detect Item_result by given field type of UNION merge result

  SYNOPSIS
    Field::result_merge_type()
    field_type  given field type

  RETURN
    Item_result (type of internal MySQL expression result)
*/

Item_result Field::result_merge_type(enum_field_types field_type)
{
  DBUG_ASSERT(field_type < FIELDTYPE_TEAR_FROM || field_type
              > FIELDTYPE_TEAR_TO);
  return field_types_result_type[field_type2index(field_type)];
}

unknown's avatar
unknown committed
984
/*****************************************************************************
985
  Static help functions
unknown's avatar
unknown committed
986 987
*****************************************************************************/

988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020

/*
  Check whether a field type can be partially indexed by a key

  This is a static method, rather than a virtual function, because we need
  to check the type of a non-Field in mysql_alter_table().

  SYNOPSIS
   type_can_have_key_part()
   type                 field type

  RETURN
    TRUE  Type can have a prefixed key
    FALSE Type can not have a prefixed key
*/

bool Field::type_can_have_key_part(enum enum_field_types type)
{
  switch (type) {
  case MYSQL_TYPE_VARCHAR:
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
  case MYSQL_TYPE_BLOB:
  case MYSQL_TYPE_VAR_STRING:
  case MYSQL_TYPE_STRING:
    return TRUE;
  default:
    return FALSE;
  }
}


unknown's avatar
unknown committed
1021 1022 1023 1024 1025 1026 1027 1028
/*
  Numeric fields base class constructor
*/
Field_num::Field_num(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
                     uchar null_bit_arg, utype unireg_check_arg,
                     const char *field_name_arg,
                     uint8 dec_arg, bool zero_arg, bool unsigned_arg)
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unknown's avatar
unknown committed
1029
         unireg_check_arg, field_name_arg),
unknown's avatar
unknown committed
1030 1031 1032 1033 1034 1035 1036 1037 1038
  dec(dec_arg),zerofill(zero_arg),unsigned_flag(unsigned_arg)
{
  if (zerofill)
    flags|=ZEROFILL_FLAG;
  if (unsigned_flag)
    flags|=UNSIGNED_FLAG;
}


unknown's avatar
unknown committed
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
void Field_num::prepend_zeros(String *value)
{
  int diff;
  if ((diff= (int) (field_length - value->length())) > 0)
  {
    bmove_upp((char*) value->ptr()+field_length,value->ptr()+value->length(),
	      value->length());
    bfill((char*) value->ptr(),diff,'0');
    value->length(field_length);
    (void) value->c_ptr_quick();		// Avoid warnings in purify
  }
}

/*
1053
  Test if given number is a int (or a fixed format float with .000)
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068

  SYNOPSIS
    test_if_int()
    str		String to test
    end		Pointer to char after last used digit
    cs		Character set

  NOTES
    This is called after one has called my_strntol() or similar function.
    This is only used to give warnings in ALTER TABLE or LOAD DATA...

  TODO
    Make this multi-byte-character safe

  RETURN
unknown's avatar
unknown committed
1069
    0	OK
unknown's avatar
unknown committed
1070
    1	error.  A warning is pushed if field_name != 0
unknown's avatar
unknown committed
1071 1072
*/

unknown's avatar
unknown committed
1073 1074
bool Field::check_int(const char *str, int length, const char *int_end,
                      CHARSET_INFO *cs)
unknown's avatar
unknown committed
1075
{
unknown's avatar
unknown committed
1076
  const char *end;
1077
  if (str == int_end)
unknown's avatar
unknown committed
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
  {
    char buff[128];
    String tmp(buff,(uint32) sizeof(buff), system_charset_info);
    tmp.copy(str, length, system_charset_info);
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, 
                        ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
                        "integer", tmp.c_ptr(), field_name,
                        (ulong) table->in_use->row_count);
    return 1;					// Empty string
  }
  end= str+length;
1090
  if ((str= int_end) == end)
unknown's avatar
unknown committed
1091
    return 0;					// OK; All digits was used
unknown's avatar
unknown committed
1092

1093 1094
  /* Allow end .0000 */
  if (*str == '.')
unknown's avatar
unknown committed
1095
  {
unknown's avatar
unknown committed
1096 1097
    for (str++ ; str != end && *str == '0'; str++)
      ;
1098 1099
  }
  /* Allow end space */
unknown's avatar
unknown committed
1100
  for ( ; str != end ; str++)
1101 1102
  {
    if (!my_isspace(cs,*str))
unknown's avatar
unknown committed
1103
    {
1104
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
1105 1106
      return 1;
    }
unknown's avatar
unknown committed
1107
  }
unknown's avatar
unknown committed
1108
  return 0;
unknown's avatar
unknown committed
1109 1110
}

unknown's avatar
unknown committed
1111

unknown's avatar
unknown committed
1112 1113 1114 1115 1116
/*
  Process decimal library return codes and issue warnings for overflow and
  truncation.

  SYNOPSIS
unknown's avatar
unknown committed
1117
    Field::warn_if_overflow()
unknown's avatar
unknown committed
1118 1119 1120 1121 1122 1123 1124
    op_result  decimal library return code (E_DEC_* see include/decimal.h)

  RETURN
    1  there was overflow
    0  no error or some other errors except overflow
*/

unknown's avatar
unknown committed
1125
int Field::warn_if_overflow(int op_result)
unknown's avatar
unknown committed
1126 1127 1128 1129 1130 1131
{
  if (op_result == E_DEC_OVERFLOW)
  {
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
    return 1;
  }
unknown's avatar
unknown committed
1132 1133
  if (op_result == E_DEC_TRUNCATED)
  {
unknown's avatar
unknown committed
1134
    set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
1135 1136
    /* We return 0 here as this is not a critical issue */
  }
unknown's avatar
unknown committed
1137 1138 1139
  return 0;
}

unknown's avatar
unknown committed
1140

unknown's avatar
unknown committed
1141
#ifdef NOT_USED
1142
static bool test_if_real(const char *str,int length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
1143
{
1144
  cs= system_charset_info; // QQ move test_if_real into CHARSET_INFO struct
1145 1146

  while (length && my_isspace(cs,*str))
unknown's avatar
unknown committed
1147 1148 1149 1150 1151 1152 1153 1154
  {						// Allow start space
    length--; str++;
  }
  if (!length)
    return 0;
  if (*str == '+' || *str == '-')
  {
    length--; str++;
1155
    if (!length || !(my_isdigit(cs,*str) || *str == '.'))
unknown's avatar
unknown committed
1156 1157
      return 0;
  }
1158
  while (length && my_isdigit(cs,*str))
unknown's avatar
unknown committed
1159 1160 1161 1162 1163 1164 1165 1166
  {
    length--; str++;
  }
  if (!length)
    return 1;
  if (*str == '.')
  {
    length--; str++;
1167
    while (length && my_isdigit(cs,*str))
unknown's avatar
unknown committed
1168 1169 1170 1171 1172 1173 1174 1175
    {
      length--; str++;
    }
  }
  if (!length)
    return 1;
  if (*str == 'E' || *str == 'e')
  {
1176
    if (length < 3 || (str[1] != '+' && str[1] != '-') || 
1177
        !my_isdigit(cs,str[2]))
unknown's avatar
unknown committed
1178 1179 1180
      return 0;
    length-=3;
    str+=3;
1181
    while (length && my_isdigit(cs,*str))
unknown's avatar
unknown committed
1182 1183 1184 1185
    {
      length--; str++;
    }
  }
1186
  for (; length ; length--, str++)
unknown's avatar
unknown committed
1187
  {						// Allow end space
1188
    if (!my_isspace(cs,*str))
unknown's avatar
unknown committed
1189 1190 1191 1192
      return 0;
  }
  return 1;
}
unknown's avatar
unknown committed
1193
#endif
unknown's avatar
unknown committed
1194

1195

unknown's avatar
unknown committed
1196 1197 1198 1199 1200 1201
/*
  Interpret field value as an integer but return the result as a string.

  This is used for printing bit_fields as numbers while debugging
*/

1202
String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_val)
unknown's avatar
unknown committed
1203 1204 1205 1206 1207 1208
{
  CHARSET_INFO *cs= &my_charset_bin;
  uint length= 21;
  longlong value= val_int();
  if (val_buffer->alloc(length))
    return 0;
unknown's avatar
unknown committed
1209 1210
  length= (uint) (*cs->cset->longlong10_to_str)(cs, (char*) val_buffer->ptr(),
                                                length,
1211
                                                unsigned_val ? 10 : -10,
unknown's avatar
unknown committed
1212
                                                value);
unknown's avatar
unknown committed
1213 1214 1215 1216 1217
  val_buffer->length(length);
  return val_buffer;
}


unknown's avatar
unknown committed
1218
Field::Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
unknown's avatar
unknown committed
1219
	     uchar null_bit_arg,
unknown's avatar
unknown committed
1220
	     utype unireg_check_arg, const char *field_name_arg)
unknown's avatar
unknown committed
1221
  :ptr(ptr_arg),null_ptr(null_ptr_arg),
unknown's avatar
unknown committed
1222
   table(0), orig_table(0), table_name(0),
unknown's avatar
unknown committed
1223
   field_name(field_name_arg),
unknown's avatar
unknown committed
1224 1225
   query_id(0), key_start(0), part_of_key(0), part_of_sortkey(0),
   unireg_check(unireg_check_arg),
unknown's avatar
unknown committed
1226
   field_length(length_arg),null_bit(null_bit_arg)
unknown's avatar
unknown committed
1227 1228
{
  flags=null_ptr ? 0: NOT_NULL_FLAG;
unknown's avatar
unknown committed
1229 1230
  comment.str= (char*) "";
  comment.length=0;
1231
  fieldnr= 0;
unknown's avatar
unknown committed
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
}

uint Field::offset()
{
  return (uint) (ptr - (char*) table->record[0]);
}


void Field::copy_from_tmp(int row_offset)
{
  memcpy(ptr,ptr+row_offset,pack_length());
  if (null_ptr)
  {
unknown's avatar
unknown committed
1245 1246
    *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) |
			null_ptr[row_offset] & (uchar) null_bit);
unknown's avatar
unknown committed
1247 1248 1249 1250
  }
}


1251
bool Field::send_binary(Protocol *protocol)
unknown's avatar
unknown committed
1252 1253
{
  char buff[MAX_FIELD_WIDTH];
1254
  String tmp(buff,sizeof(buff),charset());
1255
  val_str(&tmp);
1256
  return protocol->store(tmp.ptr(), tmp.length(), tmp.charset());
unknown's avatar
unknown committed
1257 1258 1259
}


unknown's avatar
unknown committed
1260 1261 1262 1263 1264 1265 1266 1267
my_decimal *Field::val_decimal(my_decimal *decimal)
{
  /* This never have to be called */
  DBUG_ASSERT(0);
  return 0;
}


unknown's avatar
unknown committed
1268 1269
void Field_num::add_zerofill_and_unsigned(String &res) const
{
1270
  if (unsigned_flag)
1271
    res.append(STRING_WITH_LEN(" unsigned"));
1272
  if (zerofill)
1273
    res.append(STRING_WITH_LEN(" zerofill"));
unknown's avatar
unknown committed
1274 1275
}

unknown's avatar
unknown committed
1276

1277
void Field::make_field(Send_field *field)
unknown's avatar
unknown committed
1278
{
unknown's avatar
unknown committed
1279
  if (orig_table->s->db.str && *orig_table->s->db.str)
unknown's avatar
unknown committed
1280
  {
unknown's avatar
unknown committed
1281 1282
    field->db_name= orig_table->s->db.str;
    field->org_table_name= orig_table->s->table_name.str;
1283 1284
  }
  else
unknown's avatar
unknown committed
1285
    field->org_table_name= field->db_name= "";
1286 1287
  field->table_name= orig_table->alias;
  field->col_name= field->org_col_name= field_name;
1288
  field->charsetnr= charset()->number;
unknown's avatar
unknown committed
1289 1290 1291
  field->length=field_length;
  field->type=type();
  field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
1292
  field->decimals= 0;
unknown's avatar
unknown committed
1293 1294 1295
}


unknown's avatar
unknown committed
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320
/*
  Conversion from decimal to longlong with checking overflow and
  setting correct value (min/max) in case of overflow

  SYNOPSIS
    Field::convert_decimal2longlong()
    val             value which have to be converted
    unsigned_flag   type of integer in which we convert val
    err             variable to pass error code

  RETURN
    value converted from val
*/
longlong Field::convert_decimal2longlong(const my_decimal *val,
                                         bool unsigned_flag, int *err)
{
  longlong i;
  if (unsigned_flag)
  {
    if (val->sign())
    {
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
      i= 0;
      *err= 1;
    }
unknown's avatar
unknown committed
1321
    else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
unknown's avatar
unknown committed
1322 1323 1324 1325 1326 1327 1328
                                           ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
                                           val, TRUE, &i)))
    {
      i= ~(longlong) 0;
      *err= 1;
    }
  }
unknown's avatar
unknown committed
1329
  else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
unknown's avatar
unknown committed
1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
                                         ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
                                         val, FALSE, &i)))
  {
    i= (val->sign() ? LONGLONG_MIN : LONGLONG_MAX);
    *err= 1;
  }
  return i;
}


/*
  Storing decimal in integer fields.

  SYNOPSIS
    Field_num::store_decimal()
    val       value for storing

  NOTE
    This method is used by all integer fields, real/decimal redefine it

  RETURN
    0     OK
    != 0  error
*/

int Field_num::store_decimal(const my_decimal *val)
{
  int err= 0;
  longlong i= convert_decimal2longlong(val, unsigned_flag, &err);
1359
  return test(err | store(i, unsigned_flag));
unknown's avatar
unknown committed
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
}


/*
  Return decimal value of integer field

  SYNOPSIS
    Field_num::val_decimal()
    decimal_value     buffer for storing decimal value

  NOTE
    This method is used by all integer fields, real/decimal redefine it
    All longlong values fit in our decimal buffer which cal store 8*9=72
    digits of integer number

  RETURN
    pointer to decimal buffer with value of field
*/

my_decimal* Field_num::val_decimal(my_decimal *decimal_value)
{
  DBUG_ASSERT(result_type() == INT_RESULT);
  longlong nr= val_int();
1383
  int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
unknown's avatar
unknown committed
1384 1385 1386 1387 1388 1389
  return decimal_value;
}


Field_str::Field_str(char *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
                     uchar null_bit_arg, utype unireg_check_arg,
unknown's avatar
unknown committed
1390
                     const char *field_name_arg, CHARSET_INFO *charset)
unknown's avatar
unknown committed
1391
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unknown's avatar
unknown committed
1392
         unireg_check_arg, field_name_arg)
unknown's avatar
unknown committed
1393 1394 1395 1396 1397 1398 1399
{
  field_charset=charset;
  if (charset->state & MY_CS_BINSORT)
    flags|=BINARY_FLAG;
}


1400
void Field_num::make_field(Send_field *field)
unknown's avatar
unknown committed
1401
{
1402 1403
  Field::make_field(field);
  field->decimals= dec;
unknown's avatar
unknown committed
1404 1405
}

unknown's avatar
unknown committed
1406 1407 1408 1409 1410 1411 1412 1413
/*
  Decimal representation of Field_str

  SYNOPSIS
    Field_str::store_decimal()
    d         value for storing

  NOTE
1414
    Field_str is the base class for fields like Field_enum, Field_date and some
unknown's avatar
unknown committed
1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
    similar.  Some dates use fraction and also string value should be
    converted to floating point value according our rules, so we use double
    to store value of decimal in string

  RETURN
    0     OK
    != 0  error
*/

int Field_str::store_decimal(const my_decimal *d)
{
  double val;
  /* TODO: use decimal2string? */
unknown's avatar
unknown committed
1428
  int err= warn_if_overflow(my_decimal2double(E_DEC_FATAL_ERROR &
unknown's avatar
unknown committed
1429 1430 1431 1432 1433 1434 1435 1436
                                            ~E_DEC_OVERFLOW, d, &val));
  return err | store(val);
}


my_decimal *Field_str::val_decimal(my_decimal *decimal_value)
{
  longlong nr= val_int();
1437
  int2my_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value);
unknown's avatar
unknown committed
1438 1439 1440
  return decimal_value;
}

1441

unknown's avatar
unknown committed
1442 1443
uint Field::fill_cache_field(CACHE_FIELD *copy)
{
unknown's avatar
unknown committed
1444
  uint store_length;
unknown's avatar
unknown committed
1445 1446 1447 1448 1449 1450 1451
  copy->str=ptr;
  copy->length=pack_length();
  copy->blob_field=0;
  if (flags & BLOB_FLAG)
  {
    copy->blob_field=(Field_blob*) this;
    copy->strip=0;
1452
    copy->length-= table->s->blob_ptr_size;
unknown's avatar
unknown committed
1453 1454
    return copy->length;
  }
1455 1456 1457
  else if (!zero_pack() &&
           (type() == MYSQL_TYPE_STRING && copy->length >= 4 &&
            copy->length < 256))
unknown's avatar
unknown committed
1458
  {
unknown's avatar
unknown committed
1459
    copy->strip=1;				/* Remove end space */
unknown's avatar
unknown committed
1460 1461
    store_length= 2;
  }
unknown's avatar
unknown committed
1462
  else
unknown's avatar
unknown committed
1463
  {
unknown's avatar
unknown committed
1464
    copy->strip=0;
unknown's avatar
unknown committed
1465 1466 1467
    store_length= 0;
  }
  return copy->length+ store_length;
unknown's avatar
unknown committed
1468 1469
}

1470 1471

bool Field::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
1472 1473
{
  char buff[40];
1474 1475
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  if (!(res=val_str(&tmp)) ||
1476 1477
      str_to_datetime_with_warn(res->ptr(), res->length(),
                                ltime, fuzzydate) <= MYSQL_TIMESTAMP_ERROR)
unknown's avatar
unknown committed
1478 1479 1480 1481 1482 1483 1484
    return 1;
  return 0;
}

bool Field::get_time(TIME *ltime)
{
  char buff[40];
1485 1486
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  if (!(res=val_str(&tmp)) ||
1487
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
unknown's avatar
unknown committed
1488 1489 1490 1491
    return 1;
  return 0;
}

1492 1493 1494 1495 1496 1497
/*
  This is called when storing a date in a string

  NOTES
    Needs to be changed if/when we want to support different time formats
*/
unknown's avatar
unknown committed
1498

1499
int Field::store_time(TIME *ltime, timestamp_type type)
unknown's avatar
unknown committed
1500
{
1501 1502
  char buff[MAX_DATE_STRING_REP_LENGTH];
  uint length= (uint) my_TIME_to_str(ltime, buff);
1503
  return store(buff, length, &my_charset_bin);
unknown's avatar
unknown committed
1504 1505 1506
}


1507
bool Field::optimize_range(uint idx, uint part)
unknown's avatar
unknown committed
1508
{
1509
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
unknown's avatar
unknown committed
1510 1511
}

1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524

Field *Field::new_field(MEM_ROOT *root, struct st_table *new_table)
{
  Field *tmp;
  if (!(tmp= (Field*) memdup_root(root,(char*) this,size_of())))
    return 0;

  if (tmp->table->maybe_null)
    tmp->flags&= ~NOT_NULL_FLAG;
  tmp->table= new_table;
  tmp->key_start.init(0);
  tmp->part_of_key.init(0);
  tmp->part_of_sortkey.init(0);
unknown's avatar
unknown committed
1525
  tmp->unireg_check= Field::NONE;
1526 1527 1528 1529 1530 1531
  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG |
                ZEROFILL_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
  tmp->reset_fields();
  return tmp;
}

unknown's avatar
unknown committed
1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546

Field *Field::new_key_field(MEM_ROOT *root, struct st_table *new_table,
                            char *new_ptr, uchar *new_null_ptr,
                            uint new_null_bit)
{
  Field *tmp;
  if ((tmp= new_field(root, new_table)))
  {
    tmp->ptr=      new_ptr;
    tmp->null_ptr= new_null_ptr;
    tmp->null_bit= new_null_bit;
  }
  return tmp;
}

1547

1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
/* 
  SYNOPSIS
  Field::quote_data()
     unquoted_string    Pointer pointing to the value of a field

  DESCRIPTION
    Simple method that passes the field type to the method "type_quote"
    To get a true/false value as to whether the value in string1 needs 
    to be enclosed with quotes. This ensures that values in the final 
    sql statement to be passed to the remote server will be quoted properly

  RETURN_VALUE
    void      Immediately - if string doesn't need quote
    void      Upon prepending/appending quotes on each side of variable

*/
1564

1565 1566 1567 1568
bool Field::quote_data(String *unquoted_string)
{
  char escaped_string[IO_SIZE];
  DBUG_ENTER("Field::quote_data");
1569

unknown's avatar
unknown committed
1570
  if (!needs_quotes())
1571
    DBUG_RETURN(0);
1572

unknown's avatar
unknown committed
1573 1574 1575 1576 1577 1578
  // this is the same call that mysql_real_escape_string() calls
  if (escape_string_for_mysql(&my_charset_bin, (char *)escaped_string,
                              sizeof(escaped_string), unquoted_string->ptr(),
                              unquoted_string->length()) == (ulong)~0)
    DBUG_RETURN(1);

1579 1580
  // reset string, then re-append with quotes and escaped values
  unquoted_string->length(0);
unknown's avatar
unknown committed
1581 1582 1583
  if (unquoted_string->append('\'') ||
      unquoted_string->append((char *)escaped_string) ||
      unquoted_string->append('\''))
1584
    DBUG_RETURN(1);
1585 1586 1587
  DBUG_RETURN(0);
}

1588

1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
/*
  Quote a field type if needed

  SYNOPSIS
    Field::type_quote

  DESCRIPTION 
    Simple method to give true/false whether a field should be quoted. 
    Used when constructing INSERT and UPDATE queries to the remote server
    see write_row and update_row

   RETURN VALUE
      0   if value is of type NOT needing quotes
      1   if value is of type needing quotes
*/
1604

1605 1606 1607 1608
bool Field::needs_quotes(void)
{
  DBUG_ENTER("Field::type_quote");

1609
  switch (type()) {
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624
    //FIX this when kernel is fixed
  case MYSQL_TYPE_VARCHAR :
  case FIELD_TYPE_STRING :
  case FIELD_TYPE_VAR_STRING :
  case FIELD_TYPE_YEAR :
  case FIELD_TYPE_NEWDATE :
  case FIELD_TYPE_TIME :
  case FIELD_TYPE_TIMESTAMP :
  case FIELD_TYPE_DATE :
  case FIELD_TYPE_DATETIME :
  case FIELD_TYPE_TINY_BLOB :
  case FIELD_TYPE_BLOB :
  case FIELD_TYPE_MEDIUM_BLOB :
  case FIELD_TYPE_LONG_BLOB :
  case FIELD_TYPE_GEOMETRY :
unknown's avatar
unknown committed
1625
  case FIELD_TYPE_BIT:
1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
    DBUG_RETURN(1);

  case FIELD_TYPE_DECIMAL : 
  case FIELD_TYPE_TINY :
  case FIELD_TYPE_SHORT :
  case FIELD_TYPE_INT24 :
  case FIELD_TYPE_LONG :
  case FIELD_TYPE_FLOAT :
  case FIELD_TYPE_DOUBLE :
  case FIELD_TYPE_LONGLONG :
  case FIELD_TYPE_NULL :
  case FIELD_TYPE_SET :
  case FIELD_TYPE_ENUM : 
    DBUG_RETURN(0);
1640 1641
  default:
    DBUG_RETURN(0);
1642 1643
  }
}
unknown's avatar
unknown committed
1644

1645

unknown's avatar
unknown committed
1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
/* This is used to generate a field in TABLE from TABLE_SHARE */

Field *Field::clone(MEM_ROOT *root, struct st_table *new_table)
{
  Field *tmp;
  if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
  {
    tmp->init(new_table);
    tmp->move_field_offset((my_ptrdiff_t) (new_table->record[0] -
                                           new_table->s->default_values));
  }
  return tmp;
}


1661
/****************************************************************************
1662
  Field_null, a field that always return NULL
1663 1664 1665 1666
****************************************************************************/

void Field_null::sql_type(String &res) const
{
1667
  res.set_ascii(STRING_WITH_LEN("null"));
1668 1669 1670
}


unknown's avatar
unknown committed
1671
/****************************************************************************
unknown's avatar
unknown committed
1672 1673
  Functions for the Field_decimal class
  This is an number stored as a pre-space (or pre-zero) string
unknown's avatar
unknown committed
1674 1675 1676 1677 1678
****************************************************************************/

void
Field_decimal::reset(void)
{
1679
  Field_decimal::store(STRING_WITH_LEN("0"),&my_charset_bin);
unknown's avatar
unknown committed
1680 1681 1682 1683 1684
}

void Field_decimal::overflow(bool negative)
{
  uint len=field_length;
1685
  char *to=ptr, filler= '9';
unknown's avatar
unknown committed
1686

1687
  set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1688
  if (negative)
unknown's avatar
unknown committed
1689
  {
1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712
    if (!unsigned_flag)
    {
      /* Put - sign as a first digit so we'll have -999..999 or 999..999 */
      *to++ = '-';
      len--;
    }
    else
    {
      filler= '0';				// Fill up with 0
      if (!zerofill)
      {
	/*
	  Handle unsigned integer without zerofill, in which case
	  the number should be of format '   0' or '   0.000'
	*/
	uint whole_part=field_length- (dec ? dec+2 : 1);
	// Fill with spaces up to the first digit
	bfill(to, whole_part, ' ');
	to+=  whole_part;
	len-= whole_part;
	// The main code will also handle the 0 before the decimal point
      }
    }
unknown's avatar
unknown committed
1713
  }
1714
  bfill(to, len, filler);
unknown's avatar
unknown committed
1715 1716 1717 1718 1719 1720
  if (dec)
    ptr[field_length-dec-1]='.';
  return;
}


unknown's avatar
unknown committed
1721
int Field_decimal::store(const char *from, uint len, CHARSET_INFO *cs)
unknown's avatar
unknown committed
1722
{
unknown's avatar
unknown committed
1723
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
1724
  String tmp(buff,sizeof(buff), &my_charset_bin);
1725

1726 1727 1728
  /* Convert character set if the old one is multi byte */
  if (cs->mbmaxlen > 1)
  { 
1729 1730
    uint dummy_errors;
    tmp.copy(from, len, cs, &my_charset_bin, &dummy_errors);
1731 1732 1733
    from= tmp.ptr();
    len=  tmp.length();
  }
1734

1735 1736 1737 1738 1739 1740 1741 1742 1743
  const char *end= from+len;
  /* The pointer where the field value starts (i.e., "where to write") */
  char *to=ptr;
  uint tmp_dec, tmp_uint;
  /*
    The sign of the number : will be 0 (means positive but sign not
    specified), '+' or '-'
  */
  char sign_char=0;
unknown's avatar
unknown committed
1744
  /* The pointers where prezeros start and stop */
1745
  const char *pre_zeros_from, *pre_zeros_end;
unknown's avatar
unknown committed
1746
  /* The pointers where digits at the left of '.' start and stop */
1747
  const char *int_digits_from, *int_digits_end;
unknown's avatar
unknown committed
1748
  /* The pointers where digits at the right of '.' start and stop */
1749
  const char *frac_digits_from, *frac_digits_end;
unknown's avatar
unknown committed
1750
  /* The sign of the exponent : will be 0 (means no exponent), '+' or '-' */
1751
  char expo_sign_char=0;
unknown's avatar
unknown committed
1752
  uint exponent=0;                                // value of the exponent
1753 1754 1755 1756 1757 1758 1759
  /*
    Pointers used when digits move from the left of the '.' to the
    right of the '.' (explained below)
  */
  const char *int_digits_tail_from;
  /* Number of 0 that need to be added at the left of the '.' (1E3: 3 zeros) */
  uint int_digits_added_zeros;
unknown's avatar
unknown committed
1760 1761 1762 1763
  /*
    Pointer used when digits move from the right of the '.' to the left
    of the '.'
  */
1764
  const char *frac_digits_head_end;
unknown's avatar
unknown committed
1765
  /* Number of 0 that need to be added at the right of the '.' (for 1E-3) */
1766 1767 1768 1769 1770
  uint frac_digits_added_zeros;
  char *pos,*tmp_left_pos,*tmp_right_pos;
  /* Pointers that are used as limits (begin and end of the field buffer) */
  char *left_wall,*right_wall;
  char tmp_char;
unknown's avatar
unknown committed
1771
  /*
1772
    To remember if table->in_use->cuted_fields has already been incremented,
unknown's avatar
unknown committed
1773 1774
    to do that only once
  */
1775 1776 1777 1778 1779 1780 1781 1782 1783
  bool is_cuted_fields_incr=0;

  LINT_INIT(int_digits_tail_from);
  LINT_INIT(int_digits_added_zeros);
  LINT_INIT(frac_digits_head_end);
  LINT_INIT(frac_digits_added_zeros);

  /*
    There are three steps in this function :
unknown's avatar
unknown committed
1784 1785
    - parse the input string
    - modify the position of digits around the decimal dot '.' 
1786
      according to the exponent value (if specified)
unknown's avatar
unknown committed
1787
    - write the formatted number
1788 1789 1790 1791 1792
  */

  if ((tmp_dec=dec))
    tmp_dec++;

unknown's avatar
unknown committed
1793
  /* skip pre-space */
unknown's avatar
unknown committed
1794
  while (from != end && my_isspace(&my_charset_bin,*from))
unknown's avatar
unknown committed
1795
    from++;
1796
  if (from == end)
unknown's avatar
unknown committed
1797
  {
1798
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
1799
    is_cuted_fields_incr=1;
unknown's avatar
unknown committed
1800
  }
1801
  else if (*from == '+' || *from == '-')	// Found some sign ?
unknown's avatar
unknown committed
1802
  {
1803
    sign_char= *from++;
unknown's avatar
unknown committed
1804
    /*
1805 1806 1807
      We allow "+" for unsigned decimal unless defined different
      Both options allowed as one may wish not to have "+" for unsigned numbers
      because of data processing issues
1808 1809 1810 1811
    */ 
    if (unsigned_flag)  
    { 
      if (sign_char=='-')
1812
      {
1813
        Field_decimal::overflow(1);
unknown's avatar
unknown committed
1814
        return 1;
1815
      }
1816
      /* 
unknown's avatar
unknown committed
1817 1818
	 Defining this will not store "+" for unsigned decimal type even if
	 it is passed in numeric string. This will make some tests to fail
1819 1820
      */	 
#ifdef DONT_ALLOW_UNSIGNED_PLUS      
1821 1822
      else 
        sign_char=0;
1823
#endif 	
unknown's avatar
unknown committed
1824
    }
1825
  }
unknown's avatar
unknown committed
1826

1827 1828 1829 1830
  pre_zeros_from= from;
  for (; from!=end && *from == '0'; from++) ;	// Read prezeros
  pre_zeros_end=int_digits_from=from;      
  /* Read non zero digits at the left of '.'*/
unknown's avatar
unknown committed
1831
  for (; from != end && my_isdigit(&my_charset_bin, *from) ; from++) ;
1832 1833 1834 1835 1836
  int_digits_end=from;
  if (from!=end && *from == '.')		// Some '.' ?
    from++;
  frac_digits_from= from;
  /* Read digits at the right of '.' */
unknown's avatar
unknown committed
1837
  for (;from!=end && my_isdigit(&my_charset_bin, *from); from++) ;
1838 1839 1840 1841 1842 1843 1844 1845 1846 1847
  frac_digits_end=from;
  // Some exponentiation symbol ?
  if (from != end && (*from == 'e' || *from == 'E'))
  {   
    from++;
    if (from != end && (*from == '+' || *from == '-'))  // Some exponent sign ?
      expo_sign_char= *from++;
    else
      expo_sign_char= '+';
    /*
1848 1849 1850 1851
      Read digits of the exponent and compute its value.  We must care about
      'exponent' overflow, because as unsigned arithmetic is "modulo", big 
      exponents will become small (e.g. 1e4294967296 will become 1e0, and the 
      field will finally contain 1 instead of its max possible value).
1852
    */
unknown's avatar
unknown committed
1853
    for (;from!=end && my_isdigit(&my_charset_bin, *from); from++)
1854
    {
1855
      exponent=10*exponent+(*from-'0');
unknown's avatar
unknown committed
1856
      if (exponent>MAX_EXPONENT)
1857 1858
        break;
    }
unknown's avatar
unknown committed
1859
  }
1860
  
unknown's avatar
unknown committed
1861
  /*
1862 1863
    We only have to generate warnings if count_cuted_fields is set.
    This is to avoid extra checks of the number when they are not needed.
unknown's avatar
unknown committed
1864
    Even if this flag is not set, it's OK to increment warnings, if
1865
    it makes the code easer to read.
unknown's avatar
unknown committed
1866
  */
1867

1868
  if (table->in_use->count_cuted_fields)
unknown's avatar
unknown committed
1869
  {
1870
    // Skip end spaces
unknown's avatar
unknown committed
1871
    for (;from != end && my_isspace(&my_charset_bin, *from); from++) ;
1872
    if (from != end)                     // If still something left, warn
unknown's avatar
unknown committed
1873
    {
1874
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
1875
      is_cuted_fields_incr=1;
unknown's avatar
unknown committed
1876
    }
1877 1878 1879 1880 1881 1882
  }
  
  /*
    Now "move" digits around the decimal dot according to the exponent value,
    and add necessary zeros.
    Examples :
unknown's avatar
unknown committed
1883 1884 1885
    - 1E+3 : needs 3 more zeros at the left of '.' (int_digits_added_zeros=3)
    - 1E-3 : '1' moves at the right of '.', and 2 more zeros are needed
    between '.' and '1'
1886
    - 1234.5E-3 : '234' moves at the right of '.'
unknown's avatar
unknown committed
1887 1888
    These moves are implemented with pointers which point at the begin
    and end of each moved segment. Examples :
1889
    - 1234.5E-3 : before the code below is executed, the int_digits part is
unknown's avatar
unknown committed
1890 1891 1892
    from '1' to '4' and the frac_digits part from '5' to '5'. After the code
    below, the int_digits part is from '1' to '1', the frac_digits_head
    part is from '2' to '4', and the frac_digits part from '5' to '5'.
1893
    - 1234.5E3 : before the code below is executed, the int_digits part is
unknown's avatar
unknown committed
1894 1895 1896 1897
    from '1' to '4' and the frac_digits part from '5' to '5'. After the code
    below, the int_digits part is from '1' to '4', the int_digits_tail
    part is from '5' to '5', the frac_digits part is empty, and
    int_digits_added_zeros=2 (to make 1234500).
1898 1899
  */
  
1900
  /* 
unknown's avatar
unknown committed
1901
     Below tmp_uint cannot overflow with small enough MAX_EXPONENT setting,
1902
     as int_digits_added_zeros<=exponent<4G and 
1903 1904
     (int_digits_end-int_digits_from)<=max_allowed_packet<=2G and
     (frac_digits_from-int_digits_tail_from)<=max_allowed_packet<=2G
1905 1906
  */

1907 1908 1909 1910 1911 1912 1913 1914
  if (!expo_sign_char)
    tmp_uint=tmp_dec+(uint)(int_digits_end-int_digits_from);
  else if (expo_sign_char == '-') 
  {
    tmp_uint=min(exponent,(uint)(int_digits_end-int_digits_from));
    frac_digits_added_zeros=exponent-tmp_uint;
    int_digits_end -= tmp_uint;
    frac_digits_head_end=int_digits_end+tmp_uint;
unknown's avatar
unknown committed
1915
    tmp_uint=tmp_dec+(uint)(int_digits_end-int_digits_from);     
1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940
  }
  else // (expo_sign_char=='+') 
  {
    tmp_uint=min(exponent,(uint)(frac_digits_end-frac_digits_from));
    int_digits_added_zeros=exponent-tmp_uint;
    int_digits_tail_from=frac_digits_from;
    frac_digits_from=frac_digits_from+tmp_uint;
    /*
      We "eat" the heading zeros of the 
      int_digits.int_digits_tail.int_digits_added_zeros concatenation
      (for example 0.003e3 must become 3 and not 0003)
    */
    if (int_digits_from == int_digits_end) 
    {
      /*
	There was nothing in the int_digits part, so continue
	eating int_digits_tail zeros
      */
      for (; int_digits_tail_from != frac_digits_from &&
	     *int_digits_tail_from == '0'; int_digits_tail_from++) ;
      if (int_digits_tail_from == frac_digits_from) 
      {
	// there were only zeros in int_digits_tail too
	int_digits_added_zeros=0;
      }
unknown's avatar
unknown committed
1941
    }
1942
    tmp_uint= (uint) (tmp_dec+(int_digits_end-int_digits_from)+
1943 1944
               (uint)(frac_digits_from-int_digits_tail_from)+
               int_digits_added_zeros);
1945 1946 1947 1948 1949 1950 1951 1952 1953 1954
  }
  
  /*
    Now write the formated number
    
    First the digits of the int_% parts.
    Do we have enough room to write these digits ?
    If the sign is defined and '-', we need one position for it
  */

1955
  if (field_length < tmp_uint + (int) (sign_char == '-')) 
1956
  {
unknown's avatar
unknown committed
1957
    // too big number, change to max or min number
1958
    Field_decimal::overflow(sign_char == '-');
1959
    return 1;
unknown's avatar
unknown committed
1960
  }
1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977
 
  /*
    Tmp_left_pos is the position where the leftmost digit of
    the int_% parts will be written
  */
  tmp_left_pos=pos=to+(uint)(field_length-tmp_uint);
  
  // Write all digits of the int_% parts
  while (int_digits_from != int_digits_end)
    *pos++ = *int_digits_from++ ;

  if (expo_sign_char == '+')
  {    
    while (int_digits_tail_from != frac_digits_from)
      *pos++= *int_digits_tail_from++;
    while (int_digits_added_zeros-- >0)
      *pos++= '0';  
unknown's avatar
unknown committed
1978
  }
1979 1980 1981 1982 1983 1984
  /*
    Note the position where the rightmost digit of the int_% parts has been
    written (this is to later check if the int_% parts contained nothing,
    meaning an extra 0 is needed).
  */
  tmp_right_pos=pos;
unknown's avatar
unknown committed
1985 1986

  /*
1987 1988
    Step back to the position of the leftmost digit of the int_% parts,
    to write sign and fill with zeros or blanks or prezeros.
unknown's avatar
unknown committed
1989
  */
1990 1991 1992 1993
  pos=tmp_left_pos-1;
  if (zerofill)
  {
    left_wall=to-1;
1994
    while (pos > left_wall)			// Fill with zeros
1995 1996 1997 1998
      *pos--='0';
  }
  else
  {
unknown's avatar
unknown committed
1999
    left_wall=to+(sign_char != 0)-1;
2000 2001
    if (!expo_sign_char)	// If exponent was specified, ignore prezeros
    {
2002
      for (;pos > left_wall && pre_zeros_from !=pre_zeros_end;
2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017
	   pre_zeros_from++)
	*pos--= '0';
    }
    if (pos == tmp_right_pos-1)
      *pos--= '0';		// no 0 has ever been written, so write one
    left_wall= to-1;
    if (sign_char && pos != left_wall)
    {
      /* Write sign if possible (it is if sign is '-') */
      *pos--= sign_char;
    }
    while (pos != left_wall)
      *pos--=' ';  //fill with blanks
  }
  
2018 2019
  /*
    Write digits of the frac_% parts ;
2020
    Depending on table->in_use->count_cutted_fields, we may also want
2021 2022 2023 2024 2025
    to know if some non-zero tail of these parts will
    be truncated (for example, 0.002->0.00 will generate a warning,
    while 0.000->0.00 will not)
    (and 0E1000000000 will not, while 1E-1000000000 will)
  */
2026
      
2027 2028 2029
  pos=to+(uint)(field_length-tmp_dec);	// Calculate post to '.'
  right_wall=to+field_length;
  if (pos != right_wall) 
2030 2031
    *pos++='.';

2032 2033 2034
  if (expo_sign_char == '-')
  {
    while (frac_digits_added_zeros-- > 0)
unknown's avatar
unknown committed
2035
    {
2036
      if (pos == right_wall) 
2037
      {
2038
        if (table->in_use->count_cuted_fields && !is_cuted_fields_incr) 
2039
          break; // Go on below to see if we lose non zero digits
unknown's avatar
unknown committed
2040
        return 0;
2041
      }
2042 2043 2044 2045 2046 2047
      *pos++='0';
    }
    while (int_digits_end != frac_digits_head_end)
    {
      tmp_char= *int_digits_end++;
      if (pos == right_wall)
unknown's avatar
unknown committed
2048
      {
2049 2050 2051
        if (tmp_char != '0')			// Losing a non zero digit ?
        {
          if (!is_cuted_fields_incr)
2052
            set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
2053
                        WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
2054
          return 0;
2055 2056
        }
        continue;
unknown's avatar
unknown committed
2057
      }
2058
      *pos++= tmp_char;
unknown's avatar
unknown committed
2059
    }
2060
  }
2061

2062 2063 2064 2065
  for (;frac_digits_from!=frac_digits_end;) 
  {
    tmp_char= *frac_digits_from++;
    if (pos == right_wall)
2066
    {
2067
      if (tmp_char != '0')			// Losing a non zero digit ?
2068
      {
2069
        if (!is_cuted_fields_incr)
unknown's avatar
unknown committed
2070 2071 2072 2073 2074
        {
          /*
            This is a note, not a warning, as we don't want to abort
            when we cut decimals in strict mode
          */
2075
	  set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
2076
        }
unknown's avatar
unknown committed
2077
        return 0;
2078
      }
2079
      continue;
2080
    }
2081
    *pos++= tmp_char;
unknown's avatar
unknown committed
2082
  }
2083 2084 2085
      
  while (pos != right_wall)
   *pos++='0';			// Fill with zeros at right of '.'
unknown's avatar
unknown committed
2086
  return 0;
unknown's avatar
unknown committed
2087 2088 2089
}


unknown's avatar
unknown committed
2090
int Field_decimal::store(double nr)
unknown's avatar
unknown committed
2091 2092 2093 2094
{
  if (unsigned_flag && nr < 0)
  {
    overflow(1);
2095
    return 1;
unknown's avatar
unknown committed
2096
  }
2097
  
2098 2099
#ifdef HAVE_FINITE
  if (!finite(nr)) // Handle infinity as special case
2100 2101
  {
    overflow(nr < 0.0);
unknown's avatar
unknown committed
2102
    return 1;
2103
  }
2104
#endif
unknown's avatar
unknown committed
2105

unknown's avatar
unknown committed
2106 2107
  reg4 uint i,length;
  char fyllchar,*to;
2108
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
unknown's avatar
unknown committed
2109 2110

  fyllchar = zerofill ? (char) '0' : (char) ' ';
unknown's avatar
unknown committed
2111
#ifdef HAVE_SNPRINTF
unknown's avatar
unknown committed
2112 2113
  buff[sizeof(buff)-1]=0;			// Safety
  snprintf(buff,sizeof(buff)-1, "%.*f",(int) dec,nr);
2114
  length=(uint) strlen(buff);
unknown's avatar
unknown committed
2115
#else
2116
  length=(uint) my_sprintf(buff,(buff,"%.*f",dec,nr));
unknown's avatar
unknown committed
2117
#endif
unknown's avatar
unknown committed
2118 2119 2120 2121

  if (length > field_length)
  {
    overflow(nr < 0.0);
2122
    return 1;
unknown's avatar
unknown committed
2123 2124 2125 2126 2127 2128 2129
  }
  else
  {
    to=ptr;
    for (i=field_length-length ; i-- > 0 ;)
      *to++ = fyllchar;
    memcpy(to,buff,length);
2130
    return 0;
unknown's avatar
unknown committed
2131 2132 2133 2134
  }
}


2135
int Field_decimal::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
2136
{
2137 2138 2139 2140 2141
  char buff[22];
  uint length, int_part;
  char fyllchar, *to;

  if (nr < 0 && unsigned_flag && !unsigned_val)
unknown's avatar
unknown committed
2142 2143
  {
    overflow(1);
2144
    return 1;
unknown's avatar
unknown committed
2145
  }
2146 2147
  length= (uint) (longlong10_to_str(nr,buff,unsigned_val ? 10 : -10) - buff);
  int_part= field_length- (dec  ? dec+1 : 0);
unknown's avatar
unknown committed
2148 2149 2150

  if (length > int_part)
  {
2151
    overflow(!unsigned_val && nr < 0L);		/* purecov: inspected */
2152
    return 1;
unknown's avatar
unknown committed
2153
  }
2154 2155 2156 2157 2158 2159 2160

  fyllchar = zerofill ? (char) '0' : (char) ' ';
  to= ptr;
  for (uint i=int_part-length ; i-- > 0 ;)
    *to++ = fyllchar;
  memcpy(to,buff,length);
  if (dec)
unknown's avatar
unknown committed
2161
  {
2162 2163
    to[length]='.';
    bfill(to+length+1,dec,'0');
unknown's avatar
unknown committed
2164
  }
2165
  return 0;
unknown's avatar
unknown committed
2166 2167 2168 2169 2170
}


double Field_decimal::val_real(void)
{
2171
  int not_used;
2172 2173 2174
  char *end_not_used;
  return my_strntod(&my_charset_bin, ptr, field_length, &end_not_used,
                    &not_used);
unknown's avatar
unknown committed
2175 2176 2177 2178
}

longlong Field_decimal::val_int(void)
{
2179
  int not_used;
unknown's avatar
unknown committed
2180
  if (unsigned_flag)
unknown's avatar
unknown committed
2181
    return my_strntoull(&my_charset_bin, ptr, field_length, 10, NULL,
2182
			&not_used);
unknown's avatar
unknown committed
2183
  else
unknown's avatar
unknown committed
2184
    return my_strntoll(&my_charset_bin, ptr, field_length, 10, NULL,
2185
			&not_used);
unknown's avatar
unknown committed
2186 2187
}

2188

unknown's avatar
unknown committed
2189 2190 2191 2192 2193 2194
String *Field_decimal::val_str(String *val_buffer __attribute__((unused)),
			       String *val_ptr)
{
  char *str;
  for (str=ptr ; *str == ' ' ; str++) ;
  uint tmp_length=(uint) (str-ptr);
unknown's avatar
unknown committed
2195
  val_ptr->set_charset(&my_charset_bin);
unknown's avatar
unknown committed
2196 2197 2198
  if (field_length < tmp_length)		// Error in data
    val_ptr->length(0);
  else
2199
    val_ptr->set_ascii((const char*) str, field_length-tmp_length);
unknown's avatar
unknown committed
2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210
  return val_ptr;
}

/*
** Should be able to handle at least the following fixed decimal formats:
** 5.00 , -1.0,  05,  -05, +5 with optional pre/end space
*/

int Field_decimal::cmp(const char *a_ptr,const char *b_ptr)
{
  const char *end;
2211
  int swap=0;
unknown's avatar
unknown committed
2212 2213 2214 2215
  /* First remove prefixes '0', ' ', and '-' */
  for (end=a_ptr+field_length;
       a_ptr != end &&
	 (*a_ptr == *b_ptr ||
unknown's avatar
unknown committed
2216
	  ((my_isspace(&my_charset_bin,*a_ptr)  || *a_ptr == '+' || 
2217
            *a_ptr == '0') &&
unknown's avatar
unknown committed
2218
	   (my_isspace(&my_charset_bin,*b_ptr) || *b_ptr == '+' || 
2219
            *b_ptr == '0')));
2220 2221 2222 2223 2224
       a_ptr++,b_ptr++)
  {
    if (*a_ptr == '-')				// If both numbers are negative
      swap= -1 ^ 1;				// Swap result      
  }
unknown's avatar
unknown committed
2225 2226 2227
  if (a_ptr == end)
    return 0;
  if (*a_ptr == '-')
2228
    return -1;
2229
  if (*b_ptr == '-')
unknown's avatar
unknown committed
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
    return 1;

  while (a_ptr != end)
  {
    if (*a_ptr++ != *b_ptr++)
      return swap ^ (a_ptr[-1] < b_ptr[-1] ? -1 : 1); // compare digits
  }
  return 0;
}


void Field_decimal::sort_string(char *to,uint length)
{
  char *str,*end;
  for (str=ptr,end=ptr+length;
       str != end &&
unknown's avatar
unknown committed
2246
	 ((my_isspace(&my_charset_bin,*str) || *str == '+' ||
unknown's avatar
unknown committed
2247
	   *str == '0')) ;
unknown's avatar
unknown committed
2248 2249 2250 2251 2252 2253 2254 2255 2256 2257
       str++)
    *to++=' ';
  if (str == end)
    return;					/* purecov: inspected */

  if (*str == '-')
  {
    *to++=1;					// Smaller than any number
    str++;
    while (str != end)
unknown's avatar
unknown committed
2258
      if (my_isdigit(&my_charset_bin,*str))
unknown's avatar
unknown committed
2259 2260 2261 2262 2263 2264 2265
	*to++= (char) ('9' - *str++);
      else
	*to++= *str++;
  }
  else memcpy(to,str,(uint) (end-str));
}

unknown's avatar
unknown committed
2266

unknown's avatar
unknown committed
2267 2268
void Field_decimal::sql_type(String &res) const
{
unknown's avatar
unknown committed
2269
  CHARSET_INFO *cs=res.charset();
unknown's avatar
unknown committed
2270 2271 2272 2273 2274
  uint tmp=field_length;
  if (!unsigned_flag)
    tmp--;
  if (dec)
    tmp--;
2275
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2276
			  "decimal(%d,%d)",tmp,dec));
unknown's avatar
unknown committed
2277 2278 2279 2280
  add_zerofill_and_unsigned(res);
}


unknown's avatar
unknown committed
2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291
/****************************************************************************
** Field_new_decimal
****************************************************************************/

Field_new_decimal::Field_new_decimal(char *ptr_arg,
                                     uint32 len_arg, uchar *null_ptr_arg,
                                     uchar null_bit_arg,
                                     enum utype unireg_check_arg,
                                     const char *field_name_arg,
                                     uint8 dec_arg,bool zero_arg,
                                     bool unsigned_arg)
unknown's avatar
unknown committed
2292 2293
  :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
             unireg_check_arg, field_name_arg, dec_arg, zero_arg, unsigned_arg)
unknown's avatar
unknown committed
2294
{
unknown's avatar
unknown committed
2295 2296 2297 2298
  precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
  DBUG_ASSERT((precision <= DECIMAL_MAX_PRECISION) &&
              (dec <= DECIMAL_MAX_SCALE));
  bin_size= my_decimal_get_binary_size(precision, dec);
unknown's avatar
unknown committed
2299 2300 2301 2302 2303 2304
}


Field_new_decimal::Field_new_decimal(uint32 len_arg,
                                     bool maybe_null,
                                     const char *name,
unknown's avatar
unknown committed
2305 2306 2307
                                     uint8 dec_arg,
                                     bool unsigned_arg)
  :Field_num((char*) 0, len_arg,
unknown's avatar
unknown committed
2308
             maybe_null ? (uchar*) "": 0, 0,
unknown's avatar
unknown committed
2309
             NONE, name, dec_arg, 0, unsigned_arg)
unknown's avatar
unknown committed
2310
{
unknown's avatar
unknown committed
2311 2312 2313 2314
  precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
  DBUG_ASSERT((precision <= DECIMAL_MAX_PRECISION) &&
              (dec <= DECIMAL_MAX_SCALE));
  bin_size= my_decimal_get_binary_size(precision, dec);
unknown's avatar
unknown committed
2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
}


void Field_new_decimal::reset(void)
{
  store_value(&decimal_zero);
}


/*
  Generate max/min decimal value in case of overflow.

  SYNOPSIS
    Field_new_decimal::set_value_on_overflow();
    decimal_value     buffer for value
    sign              sign of value which caused overflow
*/

void Field_new_decimal::set_value_on_overflow(my_decimal *decimal_value,
                                              bool sign)
{
  DBUG_ENTER("Field_new_decimal::set_value_on_overflow");
unknown's avatar
unknown committed
2337
  max_my_decimal(decimal_value, precision, decimals());
unknown's avatar
unknown committed
2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359
  if (sign)
  {
    if (unsigned_flag)
      my_decimal_set_zero(decimal_value);
    else
      decimal_value->sign(TRUE);
  }
  DBUG_VOID_RETURN;
}


/*
  Store decimal value in the binary buffer

  SYNOPSIS
    store_value(const my_decimal *decimal_value)
    decimal_value   my_decimal

  DESCRIPTION
    checks if decimal_value fits into field size.
    if it does, stores the decimal in the buffer using binary format.
    Otherwise sets maximal number that can be stored in the field.
unknown's avatar
unknown committed
2360 2361 2362 2363

  RETURN
   0 ok
   1 error
unknown's avatar
unknown committed
2364 2365 2366 2367
*/

bool Field_new_decimal::store_value(const my_decimal *decimal_value)
{
unknown's avatar
unknown committed
2368 2369
  int error= 0;
  DBUG_ENTER("Field_new_decimal::store_value");
unknown's avatar
unknown committed
2370 2371 2372 2373 2374 2375
#ifndef DBUG_OFF
  {
    char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
    DBUG_PRINT("enter", ("value: %s", dbug_decimal_as_string(dbug_buff, decimal_value)));
  }
#endif
unknown's avatar
unknown committed
2376 2377 2378 2379 2380 2381

  /* check that we do not try to write negative value in unsigned field */
  if (unsigned_flag && decimal_value->sign())
  {
    DBUG_PRINT("info", ("unsigned overflow"));
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2382
    error= 1;
unknown's avatar
unknown committed
2383 2384 2385 2386 2387
    decimal_value= &decimal_zero;
  }
#ifndef DBUG_OFF
  {
    char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
2388
    DBUG_PRINT("info", ("saving with precision %d  scale: %d  value %s",
unknown's avatar
unknown committed
2389 2390
                        (int)precision, (int)dec,
                        dbug_decimal_as_string(dbug_buff, decimal_value)));
unknown's avatar
unknown committed
2391
  }
unknown's avatar
unknown committed
2392
#endif
unknown's avatar
unknown committed
2393

unknown's avatar
unknown committed
2394 2395
  if (warn_if_overflow(my_decimal2binary(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
                                         decimal_value, ptr, precision, dec)))
unknown's avatar
unknown committed
2396 2397 2398
  {
    my_decimal buff;
    DBUG_PRINT("info", ("overflow"));
unknown's avatar
unknown committed
2399 2400
    set_value_on_overflow(&buff, decimal_value->sign());
    my_decimal2binary(E_DEC_FATAL_ERROR, &buff, ptr, precision, dec);
2401
    error= 1;
unknown's avatar
unknown committed
2402
  }
2403 2404
  DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (byte *) ptr,
                                          bin_size););
unknown's avatar
unknown committed
2405
  DBUG_RETURN(error);
unknown's avatar
unknown committed
2406 2407 2408 2409 2410 2411 2412 2413
}


int Field_new_decimal::store(const char *from, uint length,
                             CHARSET_INFO *charset)
{
  int err;
  my_decimal decimal_value;
unknown's avatar
unknown committed
2414 2415
  DBUG_ENTER("Field_new_decimal::store(char*)");

2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429
  if ((err= str2my_decimal(E_DEC_FATAL_ERROR &
                      ~(E_DEC_OVERFLOW | E_DEC_BAD_NUM),
                      from, length, charset,  &decimal_value)) &&
      table->in_use->abort_on_warning)
  {
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_ERROR,
                        ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
                        ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
                        "decimal", from, field_name,
                        (ulong) table->in_use->row_count);
    DBUG_RETURN(err);
  }

  switch (err) {
unknown's avatar
unknown committed
2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446
  case E_DEC_TRUNCATED:
    set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
    break;
  case E_DEC_OVERFLOW:
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
    set_value_on_overflow(&decimal_value, decimal_value.sign());
    break;
  case E_DEC_BAD_NUM:
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
                        ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
                        "decimal", from, field_name,
                        (ulong) table->in_use->row_count);
    my_decimal_set_zero(&decimal_value);
    break;
  }

unknown's avatar
unknown committed
2447 2448 2449 2450 2451
#ifndef DBUG_OFF
  char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
  DBUG_PRINT("enter", ("value: %s",
                       dbug_decimal_as_string(dbug_buff, &decimal_value)));
#endif
unknown's avatar
unknown committed
2452 2453 2454 2455 2456 2457 2458 2459
  store_value(&decimal_value);
  DBUG_RETURN(err);
}


int Field_new_decimal::store(double nr)
{
  my_decimal decimal_value;
unknown's avatar
unknown committed
2460 2461 2462 2463 2464
  int err;
  DBUG_ENTER("Field_new_decimal::store(double)");

  err= double2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW, nr,
                         &decimal_value);
unknown's avatar
unknown committed
2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475
  /*
    TODO: fix following when double2my_decimal when double2decimal
    will return E_DEC_TRUNCATED always correctly
  */
  if (!err)
  {
    double nr2;
    my_decimal2double(E_DEC_FATAL_ERROR, &decimal_value, &nr2);
    if (nr2 != nr)
      err= E_DEC_TRUNCATED;
  }
unknown's avatar
unknown committed
2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487
  if (err)
  {
    if (check_overflow(err))
      set_value_on_overflow(&decimal_value, decimal_value.sign());
    /* Only issue a warning if store_value doesn't issue an warning */
    table->in_use->got_warning= 0;
  }
  if (store_value(&decimal_value))
    err= 1;
  else if (err && !table->in_use->got_warning)
    err= warn_if_overflow(err);
  DBUG_RETURN(err);
unknown's avatar
unknown committed
2488 2489 2490
}


2491
int Field_new_decimal::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
2492 2493 2494
{
  my_decimal decimal_value;
  int err;
unknown's avatar
unknown committed
2495 2496

  if ((err= int2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
2497
                           nr, unsigned_val, &decimal_value)))
unknown's avatar
unknown committed
2498 2499 2500 2501 2502 2503 2504 2505 2506 2507
  {
    if (check_overflow(err))
      set_value_on_overflow(&decimal_value, decimal_value.sign());
    /* Only issue a warning if store_value doesn't issue an warning */
    table->in_use->got_warning= 0;
  }
  if (store_value(&decimal_value))
    err= 1;
  else if (err && !table->in_use->got_warning)
    err= warn_if_overflow(err);
unknown's avatar
unknown committed
2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540
  return err;
}


int Field_new_decimal::store_decimal(const my_decimal *decimal_value)
{
  return store_value(decimal_value);
}


double Field_new_decimal::val_real(void)
{
  double dbl;
  my_decimal decimal_value;
  my_decimal2double(E_DEC_FATAL_ERROR, val_decimal(&decimal_value), &dbl);
  return dbl;
}


longlong Field_new_decimal::val_int(void)
{
  longlong i;
  my_decimal decimal_value;
  my_decimal2int(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
                 unsigned_flag, &i);
  return i;
}


my_decimal* Field_new_decimal::val_decimal(my_decimal *decimal_value)
{
  DBUG_ENTER("Field_new_decimal::val_decimal");
  binary2my_decimal(E_DEC_FATAL_ERROR, ptr, decimal_value,
unknown's avatar
unknown committed
2541
                    precision, dec);
2542 2543
  DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (byte *) ptr,
                                          bin_size););
unknown's avatar
unknown committed
2544 2545 2546 2547 2548
  DBUG_RETURN(decimal_value);
}


String *Field_new_decimal::val_str(String *val_buffer,
unknown's avatar
unknown committed
2549
                                   String *val_ptr __attribute__((unused)))
unknown's avatar
unknown committed
2550 2551
{
  my_decimal decimal_value;
unknown's avatar
unknown committed
2552
  uint fixed_precision= zerofill ? precision : 0;
unknown's avatar
unknown committed
2553
  my_decimal2string(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
unknown's avatar
unknown committed
2554
                    fixed_precision, dec, '0', val_buffer);
unknown's avatar
unknown committed
2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575
  return val_buffer;
}


int Field_new_decimal::cmp(const char *a,const char*b)
{
  return memcmp(a, b, bin_size);
}


void Field_new_decimal::sort_string(char *buff,
                                    uint length __attribute__((unused)))
{
  memcpy(buff, ptr, bin_size);
}


void Field_new_decimal::sql_type(String &str) const
{
  CHARSET_INFO *cs= str.charset();
  str.length(cs->cset->snprintf(cs, (char*) str.ptr(), str.alloced_length(),
unknown's avatar
unknown committed
2576
                                "decimal(%d,%d)", precision, (int)dec));
unknown's avatar
unknown committed
2577 2578 2579
  add_zerofill_and_unsigned(str);
}

unknown's avatar
unknown committed
2580

unknown's avatar
unknown committed
2581 2582 2583 2584
/****************************************************************************
** tiny int
****************************************************************************/

unknown's avatar
unknown committed
2585
int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
2586
{
2587
  int not_used;				// We can ignore result from str2int
2588
  char *end;
2589
  long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
unknown's avatar
unknown committed
2590
  int error= 0;
unknown's avatar
unknown committed
2591 2592 2593 2594 2595 2596

  if (unsigned_flag)
  {
    if (tmp < 0)
    {
      tmp=0; /* purecov: inspected */
2597
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2598
      error= 1;
unknown's avatar
unknown committed
2599 2600 2601 2602
    }
    else if (tmp > 255)
    {
      tmp= 255;
2603
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2604
      error= 1;
unknown's avatar
unknown committed
2605
    }
unknown's avatar
unknown committed
2606
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
2607
      error= 1;
unknown's avatar
unknown committed
2608 2609 2610 2611 2612 2613
  }
  else
  {
    if (tmp < -128)
    {
      tmp= -128;
2614
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2615
      error= 1;
unknown's avatar
unknown committed
2616 2617 2618 2619
    }
    else if (tmp >= 128)
    {
      tmp= 127;
2620
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2621
      error= 1;
unknown's avatar
unknown committed
2622
    }
unknown's avatar
unknown committed
2623
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
2624
      error= 1;
unknown's avatar
unknown committed
2625 2626
  }
  ptr[0]= (char) tmp;
2627
  return error;
unknown's avatar
unknown committed
2628 2629 2630
}


unknown's avatar
unknown committed
2631
int Field_tiny::store(double nr)
unknown's avatar
unknown committed
2632
{
unknown's avatar
unknown committed
2633
  int error= 0;
unknown's avatar
unknown committed
2634 2635 2636 2637 2638 2639
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0.0)
    {
      *ptr=0;
2640
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2641
      error= 1;
unknown's avatar
unknown committed
2642 2643 2644 2645
    }
    else if (nr > 255.0)
    {
      *ptr=(char) 255;
2646
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2647
      error= 1;
unknown's avatar
unknown committed
2648 2649 2650 2651 2652 2653 2654 2655 2656
    }
    else
      *ptr=(char) nr;
  }
  else
  {
    if (nr < -128.0)
    {
      *ptr= (char) -128;
2657
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2658
      error= 1;
unknown's avatar
unknown committed
2659 2660 2661 2662
    }
    else if (nr > 127.0)
    {
      *ptr=127;
2663
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2664
      error= 1;
unknown's avatar
unknown committed
2665 2666
    }
    else
unknown's avatar
unknown committed
2667
      *ptr=(char) (int) nr;
unknown's avatar
unknown committed
2668
  }
2669
  return error;
unknown's avatar
unknown committed
2670 2671
}

2672 2673

int Field_tiny::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
2674
{
unknown's avatar
unknown committed
2675
  int error= 0;
2676

unknown's avatar
unknown committed
2677 2678
  if (unsigned_flag)
  {
2679
    if (nr < 0 && !unsigned_val)
unknown's avatar
unknown committed
2680
    {
2681
      *ptr= 0;
2682
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2683
      error= 1;
unknown's avatar
unknown committed
2684
    }
2685
    else if ((ulonglong) nr > (ulonglong) 255)
unknown's avatar
unknown committed
2686 2687
    {
      *ptr= (char) 255;
2688
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2689
      error= 1;
unknown's avatar
unknown committed
2690 2691 2692 2693 2694 2695
    }
    else
      *ptr=(char) nr;
  }
  else
  {
2696 2697 2698
    if (nr < 0 && unsigned_val)
      nr= 256;                                    // Generate overflow
    if (nr < -128)
unknown's avatar
unknown committed
2699 2700
    {
      *ptr= (char) -128;
2701
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2702
      error= 1;
unknown's avatar
unknown committed
2703
    }
2704
    else if (nr > 127)
unknown's avatar
unknown committed
2705 2706
    {
      *ptr=127;
2707
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2708
      error= 1;
unknown's avatar
unknown committed
2709 2710 2711 2712
    }
    else
      *ptr=(char) nr;
  }
2713
  return error;
unknown's avatar
unknown committed
2714 2715 2716 2717 2718 2719 2720 2721 2722 2723
}


double Field_tiny::val_real(void)
{
  int tmp= unsigned_flag ? (int) ((uchar*) ptr)[0] :
    (int) ((signed char*) ptr)[0];
  return (double) tmp;
}

2724

unknown's avatar
unknown committed
2725 2726 2727 2728 2729 2730 2731
longlong Field_tiny::val_int(void)
{
  int tmp= unsigned_flag ? (int) ((uchar*) ptr)[0] :
    (int) ((signed char*) ptr)[0];
  return (longlong) tmp;
}

2732

unknown's avatar
unknown committed
2733 2734 2735
String *Field_tiny::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
2736
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
2737
  uint length;
2738 2739
  uint mlength=max(field_length+1,5*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
2740
  char *to=(char*) val_buffer->ptr();
2741

unknown's avatar
unknown committed
2742
  if (unsigned_flag)
2743 2744
    length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
					   (long) *((uchar*) ptr));
unknown's avatar
unknown committed
2745
  else
2746 2747
    length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
					   (long) *((signed char*) ptr));
2748
  
unknown's avatar
unknown committed
2749 2750 2751 2752 2753 2754
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}

2755 2756 2757 2758
bool Field_tiny::send_binary(Protocol *protocol)
{
  return protocol->store_tiny((longlong) (int8) ptr[0]);
}
unknown's avatar
unknown committed
2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778

int Field_tiny::cmp(const char *a_ptr, const char *b_ptr)
{
  signed char a,b;
  a=(signed char) a_ptr[0]; b= (signed char) b_ptr[0];
  if (unsigned_flag)
    return ((uchar) a < (uchar) b) ? -1 : ((uchar) a > (uchar) b) ? 1 : 0;
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

void Field_tiny::sort_string(char *to,uint length __attribute__((unused)))
{
  if (unsigned_flag)
    *to= *ptr;
  else
    to[0] = (char) ((uchar) ptr[0] ^ (uchar) 128);	/* Revers signbit */
}

void Field_tiny::sql_type(String &res) const
{
unknown's avatar
unknown committed
2779
  CHARSET_INFO *cs=res.charset();
2780
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2781
			  "tinyint(%d)",(int) field_length));
unknown's avatar
unknown committed
2782 2783 2784 2785
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
2786
 Field type short int (2 byte)
unknown's avatar
unknown committed
2787 2788
****************************************************************************/

unknown's avatar
unknown committed
2789
int Field_short::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
2790
{
2791
  int not_used;				// We can ignore result from str2int
2792
  char *end;
2793
  long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
unknown's avatar
unknown committed
2794
  int error= 0;
2795

unknown's avatar
unknown committed
2796 2797 2798 2799 2800
  if (unsigned_flag)
  {
    if (tmp < 0)
    {
      tmp=0;
2801
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2802
      error= 1;
unknown's avatar
unknown committed
2803
    }
unknown's avatar
unknown committed
2804
    else if (tmp > UINT_MAX16)
unknown's avatar
unknown committed
2805
    {
unknown's avatar
unknown committed
2806
      tmp=UINT_MAX16;
2807
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2808
      error= 1;
unknown's avatar
unknown committed
2809
    }
unknown's avatar
unknown committed
2810
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
2811
      error= 1;
unknown's avatar
unknown committed
2812 2813 2814 2815 2816 2817
  }
  else
  {
    if (tmp < INT_MIN16)
    {
      tmp= INT_MIN16;
2818
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2819
      error= 1;
unknown's avatar
unknown committed
2820 2821 2822 2823
    }
    else if (tmp > INT_MAX16)
    {
      tmp=INT_MAX16;
2824
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2825
      error= 1;
unknown's avatar
unknown committed
2826
    }
unknown's avatar
unknown committed
2827
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
2828
      error= 1;
unknown's avatar
unknown committed
2829 2830
  }
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
2831
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
2832 2833 2834 2835 2836 2837
  {
    int2store(ptr,tmp);
  }
  else
#endif
    shortstore(ptr,(short) tmp);
2838
  return error;
unknown's avatar
unknown committed
2839 2840 2841
}


unknown's avatar
unknown committed
2842
int Field_short::store(double nr)
unknown's avatar
unknown committed
2843
{
unknown's avatar
unknown committed
2844
  int error= 0;
unknown's avatar
unknown committed
2845 2846 2847 2848 2849 2850 2851
  int16 res;
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
2852
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2853
      error= 1;
unknown's avatar
unknown committed
2854
    }
unknown's avatar
unknown committed
2855
    else if (nr > (double) UINT_MAX16)
unknown's avatar
unknown committed
2856
    {
unknown's avatar
unknown committed
2857
      res=(int16) UINT_MAX16;
2858
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2859
      error= 1;
unknown's avatar
unknown committed
2860 2861 2862 2863 2864 2865 2866 2867 2868
    }
    else
      res=(int16) (uint16) nr;
  }
  else
  {
    if (nr < (double) INT_MIN16)
    {
      res=INT_MIN16;
2869
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2870
      error= 1;
unknown's avatar
unknown committed
2871 2872 2873 2874
    }
    else if (nr > (double) INT_MAX16)
    {
      res=INT_MAX16;
2875
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2876
      error= 1;
unknown's avatar
unknown committed
2877 2878
    }
    else
unknown's avatar
unknown committed
2879
      res=(int16) (int) nr;
unknown's avatar
unknown committed
2880 2881
  }
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
2882
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
2883 2884 2885 2886 2887 2888
  {
    int2store(ptr,res);
  }
  else
#endif
    shortstore(ptr,res);
2889
  return error;
unknown's avatar
unknown committed
2890 2891
}

2892 2893

int Field_short::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
2894
{
unknown's avatar
unknown committed
2895
  int error= 0;
unknown's avatar
unknown committed
2896
  int16 res;
2897

unknown's avatar
unknown committed
2898 2899
  if (unsigned_flag)
  {
2900
    if (nr < 0L && !unsigned_val)
unknown's avatar
unknown committed
2901 2902
    {
      res=0;
2903
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2904
      error= 1;
unknown's avatar
unknown committed
2905
    }
2906
    else if ((ulonglong) nr > (ulonglong) UINT_MAX16)
unknown's avatar
unknown committed
2907
    {
unknown's avatar
unknown committed
2908
      res=(int16) UINT_MAX16;
2909
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2910
      error= 1;
unknown's avatar
unknown committed
2911 2912 2913 2914 2915 2916
    }
    else
      res=(int16) (uint16) nr;
  }
  else
  {
2917 2918 2919
    if (nr < 0 && unsigned_val)
      nr= UINT_MAX16+1;                         // Generate overflow

unknown's avatar
unknown committed
2920 2921 2922
    if (nr < INT_MIN16)
    {
      res=INT_MIN16;
2923
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2924
      error= 1;
unknown's avatar
unknown committed
2925
    }
2926
    else if (nr > (longlong) INT_MAX16)
unknown's avatar
unknown committed
2927 2928
    {
      res=INT_MAX16;
2929
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2930
      error= 1;
unknown's avatar
unknown committed
2931 2932 2933 2934 2935
    }
    else
      res=(int16) nr;
  }
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
2936
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
2937 2938 2939 2940 2941 2942
  {
    int2store(ptr,res);
  }
  else
#endif
    shortstore(ptr,res);
2943
  return error;
unknown's avatar
unknown committed
2944 2945 2946 2947 2948 2949 2950
}


double Field_short::val_real(void)
{
  short j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
2951
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962
    j=sint2korr(ptr);
  else
#endif
    shortget(j,ptr);
  return unsigned_flag ? (double) (unsigned short) j : (double) j;
}

longlong Field_short::val_int(void)
{
  short j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
2963
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
2964 2965 2966 2967 2968 2969 2970
    j=sint2korr(ptr);
  else
#endif
    shortget(j,ptr);
  return unsigned_flag ? (longlong) (unsigned short) j : (longlong) j;
}

2971

unknown's avatar
unknown committed
2972 2973 2974
String *Field_short::val_str(String *val_buffer,
			     String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
2975
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
2976
  uint length;
2977 2978
  uint mlength=max(field_length+1,7*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
2979 2980 2981
  char *to=(char*) val_buffer->ptr();
  short j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
2982
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
2983 2984 2985 2986 2987 2988
    j=sint2korr(ptr);
  else
#endif
    shortget(j,ptr);

  if (unsigned_flag)
2989 2990
    length=(uint) cs->cset->long10_to_str(cs, to, mlength, 10, 
					  (long) (uint16) j);
unknown's avatar
unknown committed
2991
  else
2992
    length=(uint) cs->cset->long10_to_str(cs, to, mlength,-10, (long) j);
unknown's avatar
unknown committed
2993 2994 2995 2996 2997 2998 2999
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


3000 3001 3002 3003 3004 3005
bool Field_short::send_binary(Protocol *protocol)
{
  return protocol->store_short(Field_short::val_int());
}


unknown's avatar
unknown committed
3006 3007 3008 3009
int Field_short::cmp(const char *a_ptr, const char *b_ptr)
{
  short a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3010
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030
  {
    a=sint2korr(a_ptr);
    b=sint2korr(b_ptr);
  }
  else
#endif
  {
    shortget(a,a_ptr);
    shortget(b,b_ptr);
  }

  if (unsigned_flag)
    return ((unsigned short) a < (unsigned short) b) ? -1 :
    ((unsigned short) a > (unsigned short) b) ? 1 : 0;
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

void Field_short::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3031
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
3032 3033 3034 3035
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
unknown's avatar
unknown committed
3036
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3037 3038 3039 3040 3041 3042 3043 3044
    to[1]   = ptr[1];
  }
  else
#endif
  {
    if (unsigned_flag)
      to[0] = ptr[1];
    else
unknown's avatar
unknown committed
3045
      to[0] = (char) (ptr[1] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3046 3047 3048 3049 3050 3051
    to[1]   = ptr[0];
  }
}

void Field_short::sql_type(String &res) const
{
unknown's avatar
unknown committed
3052
  CHARSET_INFO *cs=res.charset();
3053
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3054
			  "smallint(%d)",(int) field_length));
unknown's avatar
unknown committed
3055 3056 3057 3058 3059
  add_zerofill_and_unsigned(res);
}


/****************************************************************************
3060
  Field type medium int (3 byte)
unknown's avatar
unknown committed
3061 3062
****************************************************************************/

unknown's avatar
unknown committed
3063
int Field_medium::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3064
{
3065
  int not_used;				// We can ignore result from str2int
3066
  char *end;
3067
  long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
unknown's avatar
unknown committed
3068
  int error= 0;
unknown's avatar
unknown committed
3069 3070 3071 3072 3073 3074

  if (unsigned_flag)
  {
    if (tmp < 0)
    {
      tmp=0;
3075
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3076
      error= 1;
unknown's avatar
unknown committed
3077 3078 3079 3080
    }
    else if (tmp >= (long) (1L << 24))
    {
      tmp=(long) (1L << 24)-1L;
3081
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3082
      error= 1;
unknown's avatar
unknown committed
3083
    }
unknown's avatar
unknown committed
3084
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
3085
      error= 1;
unknown's avatar
unknown committed
3086 3087 3088 3089 3090 3091
  }
  else
  {
    if (tmp < INT_MIN24)
    {
      tmp= INT_MIN24;
3092
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3093
      error= 1;
unknown's avatar
unknown committed
3094 3095 3096 3097
    }
    else if (tmp > INT_MAX24)
    {
      tmp=INT_MAX24;
3098
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3099
      error= 1;
unknown's avatar
unknown committed
3100
    }
unknown's avatar
unknown committed
3101
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
3102
      error= 1;
unknown's avatar
unknown committed
3103 3104 3105
  }

  int3store(ptr,tmp);
3106
  return error;
unknown's avatar
unknown committed
3107 3108 3109
}


unknown's avatar
unknown committed
3110
int Field_medium::store(double nr)
unknown's avatar
unknown committed
3111
{
unknown's avatar
unknown committed
3112
  int error= 0;
unknown's avatar
unknown committed
3113 3114 3115 3116 3117 3118
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      int3store(ptr,0);
3119
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3120
      error= 1;
unknown's avatar
unknown committed
3121 3122 3123
    }
    else if (nr >= (double) (long) (1L << 24))
    {
unknown's avatar
unknown committed
3124
      uint32 tmp=(uint32) (1L << 24)-1L;
unknown's avatar
unknown committed
3125
      int3store(ptr,tmp);
3126
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3127
      error= 1;
unknown's avatar
unknown committed
3128 3129
    }
    else
unknown's avatar
unknown committed
3130
      int3store(ptr,(uint32) nr);
unknown's avatar
unknown committed
3131 3132 3133 3134 3135 3136 3137
  }
  else
  {
    if (nr < (double) INT_MIN24)
    {
      long tmp=(long) INT_MIN24;
      int3store(ptr,tmp);
3138
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3139
      error= 1;
unknown's avatar
unknown committed
3140 3141 3142 3143 3144
    }
    else if (nr > (double) INT_MAX24)
    {
      long tmp=(long) INT_MAX24;
      int3store(ptr,tmp);
3145
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3146
      error= 1;
unknown's avatar
unknown committed
3147 3148 3149 3150
    }
    else
      int3store(ptr,(long) nr);
  }
3151
  return error;
unknown's avatar
unknown committed
3152 3153
}

3154 3155

int Field_medium::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
3156
{
unknown's avatar
unknown committed
3157
  int error= 0;
3158

unknown's avatar
unknown committed
3159 3160
  if (unsigned_flag)
  {
3161
    if (nr < 0 && !unsigned_val)
unknown's avatar
unknown committed
3162 3163
    {
      int3store(ptr,0);
3164
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3165
      error= 1;
unknown's avatar
unknown committed
3166
    }
3167
    else if ((ulonglong) nr >= (ulonglong) (long) (1L << 24))
unknown's avatar
unknown committed
3168
    {
3169
      long tmp= (long) (1L << 24)-1L;
unknown's avatar
unknown committed
3170
      int3store(ptr,tmp);
3171
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3172
      error= 1;
unknown's avatar
unknown committed
3173 3174
    }
    else
unknown's avatar
unknown committed
3175
      int3store(ptr,(uint32) nr);
unknown's avatar
unknown committed
3176 3177 3178
  }
  else
  {
3179 3180 3181
    if (nr < 0 && unsigned_val)
      nr= (ulonglong) (long) (1L << 24);        // Generate overflow

unknown's avatar
unknown committed
3182 3183
    if (nr < (longlong) INT_MIN24)
    {
3184
      long tmp= (long) INT_MIN24;
unknown's avatar
unknown committed
3185
      int3store(ptr,tmp);
3186
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3187
      error= 1;
unknown's avatar
unknown committed
3188 3189 3190 3191 3192
    }
    else if (nr > (longlong) INT_MAX24)
    {
      long tmp=(long) INT_MAX24;
      int3store(ptr,tmp);
3193
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3194
      error= 1;
unknown's avatar
unknown committed
3195 3196 3197 3198
    }
    else
      int3store(ptr,(long) nr);
  }
3199
  return error;
unknown's avatar
unknown committed
3200 3201 3202 3203 3204 3205 3206 3207 3208
}


double Field_medium::val_real(void)
{
  long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
  return (double) j;
}

3209

unknown's avatar
unknown committed
3210 3211 3212 3213 3214 3215
longlong Field_medium::val_int(void)
{
  long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
  return (longlong) j;
}

3216

unknown's avatar
unknown committed
3217 3218 3219
String *Field_medium::val_str(String *val_buffer,
			      String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
3220
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
3221
  uint length;
3222 3223
  uint mlength=max(field_length+1,10*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
3224 3225 3226
  char *to=(char*) val_buffer->ptr();
  long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);

3227
  length=(uint) cs->cset->long10_to_str(cs,to,mlength,-10,j);
unknown's avatar
unknown committed
3228 3229 3230 3231 3232 3233 3234
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer); /* purecov: inspected */
  return val_buffer;
}


3235 3236 3237 3238 3239 3240
bool Field_medium::send_binary(Protocol *protocol)
{
  return protocol->store_long(Field_medium::val_int());
}


unknown's avatar
unknown committed
3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269
int Field_medium::cmp(const char *a_ptr, const char *b_ptr)
{
  long a,b;
  if (unsigned_flag)
  {
    a=uint3korr(a_ptr);
    b=uint3korr(b_ptr);
  }
  else
  {
    a=sint3korr(a_ptr);
    b=sint3korr(b_ptr);
  }
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

void Field_medium::sort_string(char *to,uint length __attribute__((unused)))
{
  if (unsigned_flag)
    to[0] = ptr[2];
  else
    to[0] = (uchar) (ptr[2] ^ 128);		/* Revers signbit */
  to[1] = ptr[1];
  to[2] = ptr[0];
}


void Field_medium::sql_type(String &res) const
{
unknown's avatar
unknown committed
3270
  CHARSET_INFO *cs=res.charset();
3271
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(), 
3272
			  "mediumint(%d)",(int) field_length));
unknown's avatar
unknown committed
3273 3274 3275 3276 3277 3278 3279
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
** long int
****************************************************************************/

unknown's avatar
unknown committed
3280 3281 3282 3283 3284
/*
  A helper function to check whether the next character
  in the string "s" is MINUS SIGN. 
*/
#ifdef HAVE_CHARSET_ucs2
3285 3286 3287 3288 3289 3290
static bool test_if_minus(CHARSET_INFO *cs,
                          const char *s, const char *e)
{
  my_wc_t wc;
  return cs->cset->mb_wc(cs, &wc, (uchar*) s, (uchar*) e) > 0 && wc == '-';
}
unknown's avatar
unknown committed
3291 3292 3293 3294 3295 3296
#else
/*
  If not UCS2 support is compiled then it is easier
*/
#define test_if_minus(cs, s, e)  (*s == '-')
#endif
3297

unknown's avatar
unknown committed
3298

unknown's avatar
unknown committed
3299
int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3300
{
3301
  ulong tmp_scan;
unknown's avatar
unknown committed
3302 3303 3304
  longlong tmp;
  long store_tmp;
  int error;
3305
  char *end;
unknown's avatar
unknown committed
3306

3307 3308 3309
  tmp_scan= cs->cset->scan(cs, from, from+len, MY_SEQ_SPACES);
  len-= tmp_scan;
  from+= tmp_scan;
unknown's avatar
unknown committed
3310

unknown's avatar
unknown committed
3311
  end= (char*) from+len;
unknown's avatar
unknown committed
3312
  tmp= cs->cset->strtoll10(cs, from, &end, &error);
unknown's avatar
unknown committed
3313 3314

  if (error != MY_ERRNO_EDOM)
unknown's avatar
unknown committed
3315
  {
unknown's avatar
unknown committed
3316
    if (unsigned_flag)
unknown's avatar
unknown committed
3317
    {
unknown's avatar
unknown committed
3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329
      if (error < 0)
      {
        error= 1;
        tmp= 0;
      }
      else if ((ulonglong) tmp > (ulonglong) UINT_MAX32)
      {
        tmp= UINT_MAX32;
        error= 1;
      }
      else
        error= 0;
unknown's avatar
unknown committed
3330 3331
    }
    else
3332
    {
unknown's avatar
unknown committed
3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346
      if (error < 0)
      {
        error= 0;
        if (tmp < INT_MIN32)
        {
          tmp= INT_MIN32;
          error= 1;
        }
      }
      else if (tmp > INT_MAX32)
      {
        tmp= INT_MAX32;
        error= 1;
      }
3347 3348
    }
  }
unknown's avatar
unknown committed
3349
  if (error)
unknown's avatar
unknown committed
3350
  {
unknown's avatar
unknown committed
3351
    error= error != MY_ERRNO_EDOM ? 1 : 2;
unknown's avatar
unknown committed
3352
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3353
  }
unknown's avatar
unknown committed
3354 3355
  else if (from+len != end && table->in_use->count_cuted_fields &&
           check_int(from,len,end,cs))
unknown's avatar
unknown committed
3356
    error= 2;
unknown's avatar
unknown committed
3357 3358
    
  store_tmp= (long) tmp;
unknown's avatar
unknown committed
3359
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3360
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3361
  {
unknown's avatar
unknown committed
3362
    int4store(ptr, store_tmp);
unknown's avatar
unknown committed
3363 3364 3365
  }
  else
#endif
unknown's avatar
unknown committed
3366
    longstore(ptr, store_tmp);
3367
  return error;
unknown's avatar
unknown committed
3368 3369 3370
}


unknown's avatar
unknown committed
3371
int Field_long::store(double nr)
unknown's avatar
unknown committed
3372
{
unknown's avatar
unknown committed
3373
  int error= 0;
unknown's avatar
unknown committed
3374 3375 3376 3377 3378 3379 3380
  int32 res;
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
unknown's avatar
unknown committed
3381
      error= 1;
unknown's avatar
unknown committed
3382
    }
3383
    else if (nr > (double) UINT_MAX32)
unknown's avatar
unknown committed
3384
    {
3385
      res= UINT_MAX32;
3386
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3387
      error= 1;
unknown's avatar
unknown committed
3388 3389 3390 3391 3392 3393 3394 3395 3396
    }
    else
      res=(int32) (ulong) nr;
  }
  else
  {
    if (nr < (double) INT_MIN32)
    {
      res=(int32) INT_MIN32;
unknown's avatar
unknown committed
3397
      error= 1;
unknown's avatar
unknown committed
3398 3399 3400 3401
    }
    else if (nr > (double) INT_MAX32)
    {
      res=(int32) INT_MAX32;
unknown's avatar
unknown committed
3402
      error= 1;
unknown's avatar
unknown committed
3403 3404
    }
    else
unknown's avatar
unknown committed
3405
      res=(int32) (longlong) nr;
unknown's avatar
unknown committed
3406
  }
unknown's avatar
unknown committed
3407 3408 3409
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);

unknown's avatar
unknown committed
3410
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3411
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3412 3413 3414 3415 3416 3417
  {
    int4store(ptr,res);
  }
  else
#endif
    longstore(ptr,res);
3418
  return error;
unknown's avatar
unknown committed
3419 3420 3421
}


3422
int Field_long::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
3423
{
unknown's avatar
unknown committed
3424
  int error= 0;
unknown's avatar
unknown committed
3425
  int32 res;
unknown's avatar
unknown committed
3426
  DBUG_ASSERT(table->in_use == current_thd);    // General safety
3427
  
unknown's avatar
unknown committed
3428 3429
  if (unsigned_flag)
  {
3430
    if (nr < 0 && !unsigned_val)
unknown's avatar
unknown committed
3431 3432
    {
      res=0;
unknown's avatar
unknown committed
3433
      error= 1;
unknown's avatar
unknown committed
3434
    }
3435
    else if ((ulonglong) nr >= (LL(1) << 32))
unknown's avatar
unknown committed
3436 3437
    {
      res=(int32) (uint32) ~0L;
unknown's avatar
unknown committed
3438
      error= 1;
unknown's avatar
unknown committed
3439 3440 3441 3442 3443 3444
    }
    else
      res=(int32) (uint32) nr;
  }
  else
  {
3445
    if (nr < 0 && unsigned_val)
3446
      nr= ((longlong) INT_MAX32) + 1;           // Generate overflow
3447
    if (nr < (longlong) INT_MIN32) 
unknown's avatar
unknown committed
3448 3449
    {
      res=(int32) INT_MIN32;
unknown's avatar
unknown committed
3450
      error= 1;
unknown's avatar
unknown committed
3451 3452 3453 3454
    }
    else if (nr > (longlong) INT_MAX32)
    {
      res=(int32) INT_MAX32;
unknown's avatar
unknown committed
3455
      error= 1;
unknown's avatar
unknown committed
3456 3457 3458 3459
    }
    else
      res=(int32) nr;
  }
unknown's avatar
unknown committed
3460 3461 3462
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);

unknown's avatar
unknown committed
3463
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3464
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3465 3466 3467 3468 3469 3470
  {
    int4store(ptr,res);
  }
  else
#endif
    longstore(ptr,res);
3471
  return error;
unknown's avatar
unknown committed
3472 3473 3474 3475 3476 3477 3478
}


double Field_long::val_real(void)
{
  int32 j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3479
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3480 3481 3482 3483 3484 3485 3486 3487 3488 3489
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return unsigned_flag ? (double) (uint32) j : (double) j;
}

longlong Field_long::val_int(void)
{
  int32 j;
3490 3491
  /* See the comment in Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
unknown's avatar
unknown committed
3492
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3493
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3494 3495 3496 3497 3498 3499 3500 3501 3502 3503
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return unsigned_flag ? (longlong) (uint32) j : (longlong) j;
}

String *Field_long::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
3504
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
3505
  uint length;
3506 3507
  uint mlength=max(field_length+1,12*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
3508 3509 3510
  char *to=(char*) val_buffer->ptr();
  int32 j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3511
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3512 3513 3514 3515 3516
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);

3517
  if (unsigned_flag)
3518
    length=cs->cset->long10_to_str(cs,to,mlength, 10,(long) (uint32)j);
3519
  else
3520
    length=cs->cset->long10_to_str(cs,to,mlength,-10,(long) j);
unknown's avatar
unknown committed
3521 3522 3523 3524 3525 3526 3527
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


3528 3529 3530 3531 3532
bool Field_long::send_binary(Protocol *protocol)
{
  return protocol->store_long(Field_long::val_int());
}

unknown's avatar
unknown committed
3533 3534 3535 3536
int Field_long::cmp(const char *a_ptr, const char *b_ptr)
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3537
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548
  {
    a=sint4korr(a_ptr);
    b=sint4korr(b_ptr);
  }
  else
#endif
  {
    longget(a,a_ptr);
    longget(b,b_ptr);
  }
  if (unsigned_flag)
unknown's avatar
unknown committed
3549
    return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
unknown's avatar
unknown committed
3550 3551 3552 3553 3554 3555
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

void Field_long::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3556
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
3557 3558 3559 3560
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
unknown's avatar
unknown committed
3561
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3562 3563 3564 3565 3566 3567 3568 3569 3570 3571
    to[1]   = ptr[1];
    to[2]   = ptr[2];
    to[3]   = ptr[3];
  }
  else
#endif
  {
    if (unsigned_flag)
      to[0] = ptr[3];
    else
unknown's avatar
unknown committed
3572
      to[0] = (char) (ptr[3] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3573 3574 3575 3576 3577 3578 3579 3580 3581
    to[1]   = ptr[2];
    to[2]   = ptr[1];
    to[3]   = ptr[0];
  }
}


void Field_long::sql_type(String &res) const
{
unknown's avatar
unknown committed
3582
  CHARSET_INFO *cs=res.charset();
3583
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3584
			  "int(%d)",(int) field_length));
unknown's avatar
unknown committed
3585 3586 3587 3588
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
3589
 Field type longlong int (8 bytes)
unknown's avatar
unknown committed
3590 3591
****************************************************************************/

unknown's avatar
unknown committed
3592
int Field_longlong::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3593
{
3594 3595
  longlong tmp;
  int error= 0;
3596
  char *end;
3597

3598
  tmp= cs->cset->scan(cs, from, from+len, MY_SEQ_SPACES);
3599
  len-= (uint)tmp;
unknown's avatar
unknown committed
3600
  from+= tmp;
unknown's avatar
unknown committed
3601 3602
  if (unsigned_flag)
  {
3603
    if (!len || test_if_minus(cs, from, from + len))
unknown's avatar
unknown committed
3604 3605
    {
      tmp=0;					// Set negative to 0
unknown's avatar
unknown committed
3606
      error= 1;
unknown's avatar
unknown committed
3607 3608
    }
    else
3609
      tmp=(longlong) my_strntoull(cs,from,len,10,&end,&error);
unknown's avatar
unknown committed
3610 3611
  }
  else
3612
    tmp=my_strntoll(cs,from,len,10,&end,&error);
unknown's avatar
unknown committed
3613
  if (error)
3614
  {
unknown's avatar
unknown committed
3615
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3616 3617
    error= 1;
  }
unknown's avatar
unknown committed
3618 3619
  else if (from+len != end && table->in_use->count_cuted_fields &&
           check_int(from,len,end,cs))
unknown's avatar
unknown committed
3620
    error= 2;
unknown's avatar
unknown committed
3621
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3622
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3623 3624 3625 3626 3627 3628
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
3629
  return error;
unknown's avatar
unknown committed
3630 3631 3632
}


unknown's avatar
unknown committed
3633
int Field_longlong::store(double nr)
unknown's avatar
unknown committed
3634
{
unknown's avatar
unknown committed
3635
  int error= 0;
unknown's avatar
unknown committed
3636
  longlong res;
unknown's avatar
unknown committed
3637 3638

  nr= rint(nr);
unknown's avatar
unknown committed
3639 3640 3641 3642 3643
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
unknown's avatar
unknown committed
3644
      error= 1;
unknown's avatar
unknown committed
3645
    }
unknown's avatar
unknown committed
3646
    else if (nr >= (double) ULONGLONG_MAX)
unknown's avatar
unknown committed
3647 3648
    {
      res= ~(longlong) 0;
unknown's avatar
unknown committed
3649
      error= 1;
unknown's avatar
unknown committed
3650 3651 3652 3653 3654 3655
    }
    else
      res=(longlong) (ulonglong) nr;
  }
  else
  {
unknown's avatar
unknown committed
3656
    if (nr <= (double) LONGLONG_MIN)
unknown's avatar
unknown committed
3657
    {
unknown's avatar
unknown committed
3658
      res= LONGLONG_MIN;
unknown's avatar
unknown committed
3659
      error= (nr < (double) LONGLONG_MIN);
unknown's avatar
unknown committed
3660
    }
3661
    else if (nr >= (double) (ulonglong) LONGLONG_MAX)
unknown's avatar
unknown committed
3662
    {
unknown's avatar
unknown committed
3663
      res= LONGLONG_MAX;
unknown's avatar
unknown committed
3664
      error= (nr > (double) LONGLONG_MAX);
unknown's avatar
unknown committed
3665 3666 3667 3668
    }
    else
      res=(longlong) nr;
  }
unknown's avatar
unknown committed
3669 3670 3671
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);

unknown's avatar
unknown committed
3672
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3673
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3674 3675 3676 3677 3678 3679
  {
    int8store(ptr,res);
  }
  else
#endif
    longlongstore(ptr,res);
3680
  return error;
unknown's avatar
unknown committed
3681 3682 3683
}


3684
int Field_longlong::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
3685
{
3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701
  int error= 0;

  if (nr < 0)                                   // Only possible error
  {
    /*
      if field is unsigned and value is signed (< 0) or
      if field is signed and value is unsigned we have an overflow
    */
    if (unsigned_flag != unsigned_val)
    {
      nr= unsigned_flag ? (ulonglong) 0 : (ulonglong) LONGLONG_MAX;
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
      error= 1;
    }
  }

unknown's avatar
unknown committed
3702
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3703
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3704 3705 3706 3707 3708 3709
  {
    int8store(ptr,nr);
  }
  else
#endif
    longlongstore(ptr,nr);
3710
  return error;
unknown's avatar
unknown committed
3711 3712 3713 3714 3715 3716 3717
}


double Field_longlong::val_real(void)
{
  longlong j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3718
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3719 3720 3721 3722 3723 3724
  {
    j=sint8korr(ptr);
  }
  else
#endif
    longlongget(j,ptr);
3725 3726 3727 3728 3729 3730 3731
  /* The following is open coded to avoid a bug in gcc 3.3 */
  if (unsigned_flag)
  {
    ulonglong tmp= (ulonglong) j;
    return ulonglong2double(tmp);
  }
  return (double) j;
unknown's avatar
unknown committed
3732 3733
}

3734

unknown's avatar
unknown committed
3735 3736 3737 3738
longlong Field_longlong::val_int(void)
{
  longlong j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3739
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750
    j=sint8korr(ptr);
  else
#endif
    longlongget(j,ptr);
  return j;
}


String *Field_longlong::val_str(String *val_buffer,
				String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
3751
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
3752
  uint length;
3753 3754
  uint mlength=max(field_length+1,22*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
3755 3756 3757
  char *to=(char*) val_buffer->ptr();
  longlong j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3758
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3759 3760 3761 3762 3763
    j=sint8korr(ptr);
  else
#endif
    longlongget(j,ptr);

3764
  length=(uint) (cs->cset->longlong10_to_str)(cs,to,mlength,
unknown's avatar
unknown committed
3765
					unsigned_flag ? 10 : -10, j);
unknown's avatar
unknown committed
3766 3767 3768 3769 3770 3771 3772
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


3773 3774 3775 3776 3777 3778
bool Field_longlong::send_binary(Protocol *protocol)
{
  return protocol->store_longlong(Field_longlong::val_int(), unsigned_flag);
}


unknown's avatar
unknown committed
3779 3780 3781 3782
int Field_longlong::cmp(const char *a_ptr, const char *b_ptr)
{
  longlong a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3783
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802
  {
    a=sint8korr(a_ptr);
    b=sint8korr(b_ptr);
  }
  else
#endif
  {
    longlongget(a,a_ptr);
    longlongget(b,b_ptr);
  }
  if (unsigned_flag)
    return ((ulonglong) a < (ulonglong) b) ? -1 :
    ((ulonglong) a > (ulonglong) b) ? 1 : 0;
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

void Field_longlong::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3803
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
3804 3805 3806 3807
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
unknown's avatar
unknown committed
3808
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822
    to[1]   = ptr[1];
    to[2]   = ptr[2];
    to[3]   = ptr[3];
    to[4]   = ptr[4];
    to[5]   = ptr[5];
    to[6]   = ptr[6];
    to[7]   = ptr[7];
  }
  else
#endif
  {
    if (unsigned_flag)
      to[0] = ptr[7];
    else
unknown's avatar
unknown committed
3823
      to[0] = (char) (ptr[7] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836
    to[1]   = ptr[6];
    to[2]   = ptr[5];
    to[3]   = ptr[4];
    to[4]   = ptr[3];
    to[5]   = ptr[2];
    to[6]   = ptr[1];
    to[7]   = ptr[0];
  }
}


void Field_longlong::sql_type(String &res) const
{
unknown's avatar
unknown committed
3837
  CHARSET_INFO *cs=res.charset();
3838
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3839
			  "bigint(%d)",(int) field_length));
unknown's avatar
unknown committed
3840 3841 3842
  add_zerofill_and_unsigned(res);
}

unknown's avatar
unknown committed
3843

unknown's avatar
unknown committed
3844
/****************************************************************************
unknown's avatar
unknown committed
3845
  single precision float
unknown's avatar
unknown committed
3846 3847
****************************************************************************/

unknown's avatar
unknown committed
3848
int Field_float::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3849
{
unknown's avatar
unknown committed
3850
  int error;
3851
  char *end;
unknown's avatar
unknown committed
3852
  double nr= my_strntod(cs,(char*) from,len,&end,&error);
unknown's avatar
unknown committed
3853 3854
  if (error || (!len || (uint) (end-from) != len &&
                table->in_use->count_cuted_fields))
3855
  {
unknown's avatar
unknown committed
3856
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
3857
                (error ? ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED), 1);
unknown's avatar
unknown committed
3858
    error= error ? 1 : 2;
3859
  }
unknown's avatar
unknown committed
3860 3861
  Field_float::store(nr);
  return error;
unknown's avatar
unknown committed
3862 3863 3864
}


unknown's avatar
unknown committed
3865
int Field_float::store(double nr)
unknown's avatar
unknown committed
3866 3867
{
  float j;
unknown's avatar
unknown committed
3868
  int error= 0;
3869

3870
  if (isnan(nr))
unknown's avatar
unknown committed
3871
  {
3872 3873
    j= 0;
    set_null();
3874
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3875
    error= 1;
unknown's avatar
unknown committed
3876
  }
3877
  else if (unsigned_flag && nr < 0)
unknown's avatar
unknown committed
3878
  {
3879
    j= 0;
3880
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3881
    error= 1;
unknown's avatar
unknown committed
3882
  }
3883
  else
unknown's avatar
unknown committed
3884
  {
3885 3886 3887 3888 3889 3890 3891
    double max_value;
    if (dec >= NOT_FIXED_DEC)
    {
      max_value= FLT_MAX;
    }
    else
    {
unknown's avatar
unknown committed
3892 3893
      uint tmp=min(field_length,array_elements(log_10)-1);
      max_value= (log_10[tmp]-1)/log_10[dec];
3894 3895 3896 3897 3898 3899
      /*
	The following comparison is needed to not get an overflow if nr
	is close to FLT_MAX
      */
      if (fabs(nr) < FLT_MAX/10.0e+32)
	nr= floor(nr*log_10[dec]+0.5)/log_10[dec];
3900 3901 3902 3903
    }
    if (nr < -max_value)
    {
      j= (float)-max_value;
3904
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3905 3906 3907 3908 3909
      error= 1;
    }
    else if (nr > max_value)
    {
      j= (float)max_value;
3910
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3911 3912 3913 3914
      error= 1;
    }
    else
      j= (float) nr;
unknown's avatar
unknown committed
3915
  }
3916
  
unknown's avatar
unknown committed
3917
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3918
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3919 3920 3921 3922 3923 3924
  {
    float4store(ptr,j);
  }
  else
#endif
    memcpy_fixed(ptr,(byte*) &j,sizeof(j));
3925
  return error;
unknown's avatar
unknown committed
3926 3927 3928
}


3929
int Field_float::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
3930
{
3931
  return store(unsigned_val ? ulonglong2double((ulonglong) nr) : (double) nr);
unknown's avatar
unknown committed
3932 3933
}

3934

unknown's avatar
unknown committed
3935 3936 3937 3938
double Field_float::val_real(void)
{
  float j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3939
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952
  {
    float4get(j,ptr);
  }
  else
#endif
    memcpy_fixed((byte*) &j,ptr,sizeof(j));
  return ((double) j);
}

longlong Field_float::val_int(void)
{
  float j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3953
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3954 3955 3956 3957 3958 3959
  {
    float4get(j,ptr);
  }
  else
#endif
    memcpy_fixed((byte*) &j,ptr,sizeof(j));
3960
  return (longlong) rint(j);
unknown's avatar
unknown committed
3961 3962 3963 3964 3965 3966 3967 3968
}


String *Field_float::val_str(String *val_buffer,
			     String *val_ptr __attribute__((unused)))
{
  float nr;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3969
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3970 3971 3972 3973 3974 3975 3976
  {
    float4get(nr,ptr);
  }
  else
#endif
    memcpy_fixed((byte*) &nr,ptr,sizeof(nr));

3977 3978
  uint to_length=max(field_length,70);
  val_buffer->alloc(to_length);
unknown's avatar
unknown committed
3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026
  char *to=(char*) val_buffer->ptr();

  if (dec >= NOT_FIXED_DEC)
  {
    sprintf(to,"%-*.*g",(int) field_length,FLT_DIG,nr);
    to=strcend(to,' ');
    *to=0;
  }
  else
  {
#ifdef HAVE_FCONVERT
    char buff[70],*pos=buff;
    int decpt,sign,tmp_dec=dec;

    VOID(sfconvert(&nr,tmp_dec,&decpt,&sign,buff));
    if (sign)
    {
      *to++='-';
    }
    if (decpt < 0)
    {					/* val_buffer is < 0 */
      *to++='0';
      if (!tmp_dec)
	goto end;
      *to++='.';
      if (-decpt > tmp_dec)
	decpt= - (int) tmp_dec;
      tmp_dec=(uint) ((int) tmp_dec+decpt);
      while (decpt++ < 0)
	*to++='0';
    }
    else if (decpt == 0)
    {
      *to++= '0';
      if (!tmp_dec)
	goto end;
      *to++='.';
    }
    else
    {
      while (decpt-- > 0)
	*to++= *pos++;
      if (!tmp_dec)
	goto end;
      *to++='.';
    }
    while (tmp_dec--)
      *to++= *pos++;
unknown's avatar
unknown committed
4027
#else
4028 4029 4030
#ifdef HAVE_SNPRINTF
    to[to_length-1]=0;			// Safety
    snprintf(to,to_length-1,"%.*f",dec,nr);
4031
    to=strend(to);
unknown's avatar
unknown committed
4032
#else
4033
    to+= my_sprintf(to,(to,"%.*f",dec,nr));
unknown's avatar
unknown committed
4034
#endif
unknown's avatar
unknown committed
4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050
#endif
  }
#ifdef HAVE_FCONVERT
 end:
#endif
  val_buffer->length((uint) (to-val_buffer->ptr()));
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


int Field_float::cmp(const char *a_ptr, const char *b_ptr)
{
  float a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4051
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070
  {
    float4get(a,a_ptr);
    float4get(b,b_ptr);
  }
  else
#endif
  {
    memcpy_fixed(&a,a_ptr,sizeof(float));
    memcpy_fixed(&b,b_ptr,sizeof(float));
  }
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

#define FLT_EXP_DIG (sizeof(float)*8-FLT_MANT_DIG)

void Field_float::sort_string(char *to,uint length __attribute__((unused)))
{
  float nr;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4071
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095
  {
    float4get(nr,ptr);
  }
  else
#endif
    memcpy_fixed(&nr,ptr,sizeof(float));

  uchar *tmp= (uchar*) to;
  if (nr == (float) 0.0)
  {						/* Change to zero string */
    tmp[0]=(uchar) 128;
    bzero((char*) tmp+1,sizeof(nr)-1);
  }
  else
  {
#ifdef WORDS_BIGENDIAN
    memcpy_fixed(tmp,&nr,sizeof(nr));
#else
    tmp[0]= ptr[3]; tmp[1]=ptr[2]; tmp[2]= ptr[1]; tmp[3]=ptr[0];
#endif
    if (tmp[0] & 128)				/* Negative */
    {						/* make complement */
      uint i;
      for (i=0 ; i < sizeof(nr); i++)
unknown's avatar
unknown committed
4096
	tmp[i]= (uchar) (tmp[i] ^ (uchar) 255);
unknown's avatar
unknown committed
4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109
    }
    else
    {
      ushort exp_part=(((ushort) tmp[0] << 8) | (ushort) tmp[1] |
		       (ushort) 32768);
      exp_part+= (ushort) 1 << (16-1-FLT_EXP_DIG);
      tmp[0]= (uchar) (exp_part >> 8);
      tmp[1]= (uchar) exp_part;
    }
  }
}


4110 4111 4112 4113 4114 4115
bool Field_float::send_binary(Protocol *protocol)
{
  return protocol->store((float) Field_float::val_real(), dec, (String*) 0);
}


unknown's avatar
unknown committed
4116 4117 4118
void Field_float::sql_type(String &res) const
{
  if (dec == NOT_FIXED_DEC)
4119
  {
4120
    res.set_ascii(STRING_WITH_LEN("float"));
4121
  }
unknown's avatar
unknown committed
4122
  else
4123
  {
4124
    CHARSET_INFO *cs= res.charset();
4125
    res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
4126
			    "float(%d,%d)",(int) field_length,dec));
4127
  }
unknown's avatar
unknown committed
4128 4129 4130
  add_zerofill_and_unsigned(res);
}

unknown's avatar
unknown committed
4131

unknown's avatar
unknown committed
4132
/****************************************************************************
unknown's avatar
unknown committed
4133
  double precision floating point numbers
unknown's avatar
unknown committed
4134 4135
****************************************************************************/

unknown's avatar
unknown committed
4136
int Field_double::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4137
{
unknown's avatar
unknown committed
4138
  int error;
4139
  char *end;
unknown's avatar
unknown committed
4140
  double nr= my_strntod(cs,(char*) from, len, &end, &error);
unknown's avatar
unknown committed
4141 4142
  if (error || (!len || (uint) (end-from) != len &&
                table->in_use->count_cuted_fields))
unknown's avatar
unknown committed
4143
  {
unknown's avatar
unknown committed
4144
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4145
                (error ? ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED), 1);
unknown's avatar
unknown committed
4146
    error= error ? 1 : 2;
unknown's avatar
unknown committed
4147
  }
unknown's avatar
unknown committed
4148 4149
  Field_double::store(nr);
  return error;
unknown's avatar
unknown committed
4150 4151 4152
}


unknown's avatar
unknown committed
4153
int Field_double::store(double nr)
unknown's avatar
unknown committed
4154
{
unknown's avatar
unknown committed
4155
  int error= 0;
4156

4157 4158 4159 4160
  if (isnan(nr))
  {
    nr= 0;
    set_null();
4161
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
4162 4163 4164
    error= 1;
  }
  else if (unsigned_flag && nr < 0)
unknown's avatar
unknown committed
4165
  {
4166
    nr= 0;
4167
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
4168
    error= 1;
unknown's avatar
unknown committed
4169
  }
4170 4171 4172 4173 4174 4175 4176 4177 4178
  else 
  {
    double max_value;
    if (dec >= NOT_FIXED_DEC)
    {
      max_value= DBL_MAX;
    }
    else
    {
unknown's avatar
unknown committed
4179 4180
      uint tmp=min(field_length,array_elements(log_10)-1);
      max_value= (log_10[tmp]-1)/log_10[dec];
4181 4182
      if (fabs(nr) < DBL_MAX/10.0e+32)
	nr= floor(nr*log_10[dec]+0.5)/log_10[dec];
4183 4184 4185 4186
    }
    if (nr < -max_value)
    {
      nr= -max_value;
4187
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
4188 4189 4190 4191 4192
      error= 1;
    }
    else if (nr > max_value)
    {
      nr= max_value;
4193
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
4194 4195 4196 4197
      error= 1;
    }
  }

unknown's avatar
unknown committed
4198
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4199
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4200 4201 4202 4203 4204 4205
  {
    float8store(ptr,nr);
  }
  else
#endif
    doublestore(ptr,nr);
4206
  return error;
unknown's avatar
unknown committed
4207 4208 4209
}


4210
int Field_double::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
4211
{
4212
  return store(unsigned_val ? ulonglong2double((ulonglong) nr) : (double) nr);
unknown's avatar
unknown committed
4213 4214
}

4215

unknown's avatar
unknown committed
4216 4217 4218 4219 4220 4221
int Field_real::store_decimal(const my_decimal *dm)
{
  double dbl;
  my_decimal2double(E_DEC_FATAL_ERROR, dm, &dbl);
  return store(dbl);
}
unknown's avatar
unknown committed
4222 4223 4224 4225 4226

double Field_double::val_real(void)
{
  double j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4227
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239
  {
    float8get(j,ptr);
  }
  else
#endif
    doubleget(j,ptr);
  return j;
}

longlong Field_double::val_int(void)
{
  double j;
unknown's avatar
unknown committed
4240
  longlong res;
unknown's avatar
unknown committed
4241
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4242
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4243 4244 4245 4246 4247 4248
  {
    float8get(j,ptr);
  }
  else
#endif
    doubleget(j,ptr);
4249 4250
  /* Check whether we fit into longlong range */
  if (j <= (double) LONGLONG_MIN)
unknown's avatar
unknown committed
4251 4252 4253 4254
  {
    res= (longlong) LONGLONG_MIN;
    goto warn;
  }
4255
  if (j >= (double) (ulonglong) LONGLONG_MAX)
unknown's avatar
unknown committed
4256 4257 4258 4259
  {
    res= (longlong) LONGLONG_MAX;
    goto warn;
  }
4260
  return (longlong) rint(j);
unknown's avatar
unknown committed
4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272

warn:
  {
    char buf[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
    String tmp(buf, sizeof(buf), &my_charset_latin1), *str;
    str= val_str(&tmp, 0);
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE,
                        ER(ER_TRUNCATED_WRONG_VALUE), "INTEGER",
                        str->c_ptr());
  }
  return res;
unknown's avatar
unknown committed
4273 4274 4275
}


unknown's avatar
unknown committed
4276 4277 4278 4279 4280 4281 4282
my_decimal *Field_real::val_decimal(my_decimal *decimal_value)
{
  double2my_decimal(E_DEC_FATAL_ERROR, val_real(), decimal_value);
  return decimal_value;
}


unknown's avatar
unknown committed
4283 4284 4285 4286 4287
String *Field_double::val_str(String *val_buffer,
			      String *val_ptr __attribute__((unused)))
{
  double nr;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4288
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4289 4290 4291 4292 4293 4294 4295
  {
    float8get(nr,ptr);
  }
  else
#endif
    doubleget(nr,ptr);

4296
  uint to_length=max(field_length, DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE);
unknown's avatar
unknown committed
4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307
  val_buffer->alloc(to_length);
  char *to=(char*) val_buffer->ptr();

  if (dec >= NOT_FIXED_DEC)
  {
    sprintf(to,"%-*.*g",(int) field_length,DBL_DIG,nr);
    to=strcend(to,' ');
  }
  else
  {
#ifdef HAVE_FCONVERT
unknown's avatar
unknown committed
4308
    char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
4309
    char *pos= buff;
unknown's avatar
unknown committed
4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347
    int decpt,sign,tmp_dec=dec;

    VOID(fconvert(nr,tmp_dec,&decpt,&sign,buff));
    if (sign)
    {
      *to++='-';
    }
    if (decpt < 0)
    {					/* val_buffer is < 0 */
      *to++='0';
      if (!tmp_dec)
	goto end;
      *to++='.';
      if (-decpt > tmp_dec)
	decpt= - (int) tmp_dec;
      tmp_dec=(uint) ((int) tmp_dec+decpt);
      while (decpt++ < 0)
	*to++='0';
    }
    else if (decpt == 0)
    {
      *to++= '0';
      if (!tmp_dec)
	goto end;
      *to++='.';
    }
    else
    {
      while (decpt-- > 0)
	*to++= *pos++;
      if (!tmp_dec)
	goto end;
      *to++='.';
    }
    while (tmp_dec--)
      *to++= *pos++;
#else
#ifdef HAVE_SNPRINTF
unknown's avatar
unknown committed
4348
    to[to_length-1]=0;			// Safety
unknown's avatar
unknown committed
4349
    snprintf(to,to_length-1,"%.*f",dec,nr);
4350
    to=strend(to);
unknown's avatar
unknown committed
4351
#else
4352
    to+= my_sprintf(to,(to,"%.*f",dec,nr));
unknown's avatar
unknown committed
4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365
#endif
#endif
  }
#ifdef HAVE_FCONVERT
 end:
#endif

  val_buffer->length((uint) (to-val_buffer->ptr()));
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}

4366 4367
bool Field_double::send_binary(Protocol *protocol)
{
unknown's avatar
unknown committed
4368
  return protocol->store((double) Field_double::val_real(), dec, (String*) 0);
4369 4370
}

unknown's avatar
unknown committed
4371 4372 4373 4374 4375

int Field_double::cmp(const char *a_ptr, const char *b_ptr)
{
  double a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4376
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4377 4378 4379 4380 4381 4382 4383
  {
    float8get(a,a_ptr);
    float8get(b,b_ptr);
  }
  else
#endif
  {
unknown's avatar
unknown committed
4384 4385
    doubleget(a, a_ptr);
    doubleget(b, b_ptr);
unknown's avatar
unknown committed
4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398
  }
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}


#define DBL_EXP_DIG (sizeof(double)*8-DBL_MANT_DIG)

/* The following should work for IEEE */

void Field_double::sort_string(char *to,uint length __attribute__((unused)))
{
  double nr;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4399
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4400 4401 4402 4403 4404
  {
    float8get(nr,ptr);
  }
  else
#endif
unknown's avatar
unknown committed
4405
    doubleget(nr,ptr);
unknown's avatar
unknown committed
4406 4407 4408 4409 4410 4411
  change_double_for_sort(nr, (byte*) to);
}


void Field_double::sql_type(String &res) const
{
unknown's avatar
unknown committed
4412
  CHARSET_INFO *cs=res.charset();
unknown's avatar
unknown committed
4413
  if (dec == NOT_FIXED_DEC)
4414
  {
4415
    res.set_ascii(STRING_WITH_LEN("double"));
4416
  }
unknown's avatar
unknown committed
4417
  else
4418
  {
4419
    res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
4420
			    "double(%d,%d)",(int) field_length,dec));
4421
  }
unknown's avatar
unknown committed
4422 4423 4424 4425
  add_zerofill_and_unsigned(res);
}


4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449
/*
  TIMESTAMP type.
  Holds datetime values in range from 1970-01-01 00:00:01 UTC to 
  2038-01-01 00:00:00 UTC stored as number of seconds since Unix 
  Epoch in UTC.
  
  Up to one of timestamps columns in the table can be automatically 
  set on row update and/or have NOW() as default value.
  TABLE::timestamp_field points to Field object for such timestamp with 
  auto-set-on-update. TABLE::time_stamp holds offset in record + 1 for this
  field, and is used by handler code which performs updates required.
  
  Actually SQL-99 says that we should allow niladic functions (like NOW())
  as defaults for any field. Current limitations (only NOW() and only 
  for one TIMESTAMP field) are because of restricted binary .frm format 
  and should go away in the future.
  
  Also because of this limitation of binary .frm format we use 5 different
  unireg_check values with TIMESTAMP field to distinguish various cases of
  DEFAULT or ON UPDATE values. These values are:
  
  TIMESTAMP_OLD_FIELD - old timestamp, if there was not any fields with
    auto-set-on-update (or now() as default) in this table before, then this 
    field has NOW() as default and is updated when row changes, else it is 
unknown's avatar
unknown committed
4450
    field which has 0 as default value and is not automatically updated.
4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469
  TIMESTAMP_DN_FIELD - field with NOW() as default but not set on update
    automatically (TIMESTAMP DEFAULT NOW())
  TIMESTAMP_UN_FIELD - field which is set on update automatically but has not 
    NOW() as default (but it may has 0 or some other const timestamp as 
    default) (TIMESTAMP ON UPDATE NOW()).
  TIMESTAMP_DNUN_FIELD - field which has now() as default and is auto-set on 
    update. (TIMESTAMP DEFAULT NOW() ON UPDATE NOW())
  NONE - field which is not auto-set on update with some other than NOW() 
    default value (TIMESTAMP DEFAULT 0).

  Note that TIMESTAMP_OLD_FIELD's are never created explicitly now, they are 
  left only for preserving ability to read old tables. Such fields replaced 
  with their newer analogs in CREATE TABLE and in SHOW CREATE TABLE. This is 
  because we want to prefer NONE unireg_check before TIMESTAMP_OLD_FIELD for 
  "TIMESTAMP DEFAULT 'Const'" field. (Old timestamps allowed such 
  specification too but ignored default value for first timestamp, which of 
  course is non-standard.) In most cases user won't notice any change, only
  exception is different behavior of old/new timestamps during ALTER TABLE.
 */
unknown's avatar
unknown committed
4470 4471

Field_timestamp::Field_timestamp(char *ptr_arg, uint32 len_arg,
4472
                                 uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
4473 4474
				 enum utype unireg_check_arg,
				 const char *field_name_arg,
unknown's avatar
unknown committed
4475
				 TABLE_SHARE *share,
4476
				 CHARSET_INFO *cs)
4477
  :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
unknown's avatar
unknown committed
4478
	     unireg_check_arg, field_name_arg, cs)
unknown's avatar
unknown committed
4479
{
unknown's avatar
unknown committed
4480 4481
  /* For 4.0 MYD and 4.0 InnoDB compatibility */
  flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
unknown's avatar
unknown committed
4482
  if (!share->timestamp_field && unireg_check != NONE)
unknown's avatar
unknown committed
4483
  {
4484
    /* This timestamp has auto-update */
unknown's avatar
unknown committed
4485 4486
    share->timestamp_field= this;
    flags|= TIMESTAMP_FLAG;
unknown's avatar
unknown committed
4487 4488 4489 4490
  }
}


4491
/*
4492 4493
  Get auto-set type for TIMESTAMP field.

4494
  SYNOPSIS
4495 4496 4497 4498 4499
    get_auto_set_type()

  DESCRIPTION
    Returns value indicating during which operations this TIMESTAMP field
    should be auto-set to current timestamp.
4500
*/
4501
timestamp_auto_set_type Field_timestamp::get_auto_set_type() const
4502
{
4503 4504 4505 4506 4507 4508
  switch (unireg_check)
  {
  case TIMESTAMP_DN_FIELD:
    return TIMESTAMP_AUTO_SET_ON_INSERT;
  case TIMESTAMP_UN_FIELD:
    return TIMESTAMP_AUTO_SET_ON_UPDATE;
4509 4510
  case TIMESTAMP_OLD_FIELD:
    /*
unknown's avatar
unknown committed
4511
      Although we can have several such columns in legacy tables this
4512 4513 4514 4515 4516
      function should be called only for first of them (i.e. the one
      having auto-set property).
    */
    DBUG_ASSERT(table->timestamp_field == this);
    /* Fall-through */
4517 4518 4519 4520 4521 4522 4523 4524 4525 4526
  case TIMESTAMP_DNUN_FIELD:
    return TIMESTAMP_AUTO_SET_ON_BOTH;
  default:
    /*
      Normally this function should not be called for TIMESTAMPs without
      auto-set property.
    */
    DBUG_ASSERT(0);
    return TIMESTAMP_NO_AUTO_SET;
  }
4527 4528 4529
}


unknown's avatar
unknown committed
4530
int Field_timestamp::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4531
{
4532 4533 4534 4535
  TIME l_time;
  my_time_t tmp= 0;
  int error;
  bool have_smth_to_conv;
4536
  my_bool in_dst_time_gap;
4537 4538
  THD *thd= table->in_use;

4539
  /* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
unknown's avatar
unknown committed
4540
  have_smth_to_conv= (str_to_datetime(from, len, &l_time,
4541 4542 4543
                                      (table->in_use->variables.sql_mode &
                                       MODE_NO_ZERO_DATE) |
                                      MODE_NO_ZERO_IN_DATE, &error) >
4544
                      MYSQL_TIMESTAMP_ERROR);
4545

unknown's avatar
unknown committed
4546 4547 4548
  if (error || !have_smth_to_conv)
  {
    error= 1;
4549
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
4550
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
unknown's avatar
unknown committed
4551
  }
4552

unknown's avatar
unknown committed
4553 4554
  /* Only convert a correct date (not a zero date) */
  if (have_smth_to_conv && l_time.month)
4555 4556 4557
  {
    if (!(tmp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
    {
4558
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4559
                           ER_WARN_DATA_OUT_OF_RANGE,
4560
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
4561 4562 4563 4564 4565
      error= 1;
    }
    else if (in_dst_time_gap)
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4566
                           ER_WARN_INVALID_TIMESTAMP,
4567
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
4568 4569 4570 4571
      error= 1;
    }
  }

unknown's avatar
unknown committed
4572
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4573
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4574 4575 4576 4577 4578 4579
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
4580
  return error;
unknown's avatar
unknown committed
4581 4582
}

unknown's avatar
unknown committed
4583

unknown's avatar
unknown committed
4584
int Field_timestamp::store(double nr)
unknown's avatar
unknown committed
4585
{
unknown's avatar
unknown committed
4586
  int error= 0;
unknown's avatar
unknown committed
4587 4588
  if (nr < 0 || nr > 99991231235959.0)
  {
4589 4590
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                         ER_WARN_DATA_OUT_OF_RANGE,
4591
                         nr, MYSQL_TIMESTAMP_DATETIME);
unknown's avatar
unknown committed
4592 4593
    nr= 0;					// Avoid overflow on buff
    error= 1;
unknown's avatar
unknown committed
4594
  }
4595
  error|= Field_timestamp::store((longlong) rint(nr), FALSE);
4596
  return error;
unknown's avatar
unknown committed
4597 4598 4599
}


4600
int Field_timestamp::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
4601 4602
{
  TIME l_time;
4603 4604
  my_time_t timestamp= 0;
  int error;
4605
  my_bool in_dst_time_gap;
4606
  THD *thd= table->in_use;
unknown's avatar
unknown committed
4607

4608
  /* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
4609 4610 4611
  longlong tmp= number_to_datetime(nr, &l_time, (thd->variables.sql_mode &
                                                 MODE_NO_ZERO_DATE) |
                                   MODE_NO_ZERO_IN_DATE, &error);
4612
  if (tmp == LL(-1))
4613 4614 4615 4616 4617
  {
    error= 2;
  }

  if (!error && tmp)
unknown's avatar
unknown committed
4618
  {
4619 4620
    if (!(timestamp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
    {
4621 4622 4623
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                           ER_WARN_DATA_OUT_OF_RANGE,
                           nr, MYSQL_TIMESTAMP_DATETIME, 1);
4624 4625 4626 4627 4628
      error= 1;
    }
    if (in_dst_time_gap)
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4629 4630
                           ER_WARN_INVALID_TIMESTAMP,
                           nr, MYSQL_TIMESTAMP_DATETIME, 1);
4631 4632
      error= 1;
    }
4633 4634
  } else if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4635
                         WARN_DATA_TRUNCATED,
4636
                         nr, MYSQL_TIMESTAMP_DATETIME, 1);
4637

unknown's avatar
unknown committed
4638
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4639
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4640 4641 4642 4643 4644
  {
    int4store(ptr,timestamp);
  }
  else
#endif
unknown's avatar
unknown committed
4645
    longstore(ptr,(uint32) timestamp);
4646

unknown's avatar
unknown committed
4647
  return error;
unknown's avatar
unknown committed
4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658
}


double Field_timestamp::val_real(void)
{
  return (double) Field_timestamp::val_int();
}

longlong Field_timestamp::val_int(void)
{
  uint32 temp;
4659 4660
  TIME time_tmp;
  THD  *thd= table->in_use;
unknown's avatar
unknown committed
4661 4662

#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4663
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4664 4665 4666 4667 4668 4669 4670
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);

  if (temp == 0L)				// No time
    return(0);					/* purecov: inspected */
4671 4672 4673 4674 4675 4676 4677
  
  thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp, (my_time_t)temp);
  thd->time_zone_used= 1;
  
  return time_tmp.year * LL(10000000000) + time_tmp.month * LL(100000000) +
         time_tmp.day * 1000000L + time_tmp.hour * 10000L +
         time_tmp.minute * 100 + time_tmp.second;
unknown's avatar
unknown committed
4678 4679 4680
}


unknown's avatar
unknown committed
4681
String *Field_timestamp::val_str(String *val_buffer, String *val_ptr)
unknown's avatar
unknown committed
4682
{
4683
  uint32 temp, temp2;
4684 4685
  TIME time_tmp;
  THD *thd= table->in_use;
unknown's avatar
unknown committed
4686
  char *to;
unknown's avatar
unknown committed
4687 4688

  val_buffer->alloc(field_length+1);
unknown's avatar
unknown committed
4689
  to= (char*) val_buffer->ptr();
4690
  val_buffer->length(field_length);
unknown's avatar
unknown committed
4691 4692

#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4693
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4694 4695 4696 4697 4698 4699 4700
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);

  if (temp == 0L)
  {				      /* Zero time is "000000" */
4701
    val_ptr->set(STRING_WITH_LEN("0000-00-00 00:00:00"), &my_charset_bin);
4702
    return val_ptr;
unknown's avatar
unknown committed
4703
  }
unknown's avatar
unknown committed
4704
  val_buffer->set_charset(&my_charset_bin);	// Safety
4705 4706 4707
  
  thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp,(my_time_t)temp);
  thd->time_zone_used= 1;
4708

4709
  temp= time_tmp.year % 100;
4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723
  if (temp < YY_PART_YEAR)
  {
    *to++= '2';
    *to++= '0';
  }
  else
  {
    *to++= '1';
    *to++= '9';
  }
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= '-';
4724
  temp=time_tmp.month;
4725 4726 4727 4728
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= '-';
4729
  temp=time_tmp.day;
4730 4731 4732 4733
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ' ';
4734
  temp=time_tmp.hour;
4735 4736 4737 4738
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ':';
4739
  temp=time_tmp.minute;
4740 4741 4742 4743
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ':';
4744
  temp=time_tmp.second;
4745 4746 4747 4748
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to= 0;
unknown's avatar
unknown committed
4749 4750 4751
  return val_buffer;
}

4752

4753
bool Field_timestamp::get_date(TIME *ltime, uint fuzzydate)
unknown's avatar
unknown committed
4754 4755
{
  long temp;
4756
  THD *thd= table->in_use;
unknown's avatar
unknown committed
4757
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4758
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4759 4760 4761 4762 4763 4764
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);
  if (temp == 0L)
  {				      /* Zero time is "000000" */
unknown's avatar
unknown committed
4765
    if (fuzzydate & TIME_NO_ZERO_DATE)
unknown's avatar
unknown committed
4766
      return 1;
unknown's avatar
unknown committed
4767 4768 4769 4770
    bzero((char*) ltime,sizeof(*ltime));
  }
  else
  {
4771 4772
    thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)temp);
    thd->time_zone_used= 1;
unknown's avatar
unknown committed
4773 4774 4775 4776 4777 4778
  }
  return 0;
}

bool Field_timestamp::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
4779
  return Field_timestamp::get_date(ltime,0);
unknown's avatar
unknown committed
4780 4781
}

4782 4783 4784 4785

bool Field_timestamp::send_binary(Protocol *protocol)
{
  TIME tm;
unknown's avatar
unknown committed
4786
  Field_timestamp::get_date(&tm, 0);
4787 4788 4789 4790
  return protocol->store(&tm);
}


unknown's avatar
unknown committed
4791 4792 4793 4794
int Field_timestamp::cmp(const char *a_ptr, const char *b_ptr)
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4795
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808
  {
    a=sint4korr(a_ptr);
    b=sint4korr(b_ptr);
  }
  else
#endif
  {
  longget(a,a_ptr);
  longget(b,b_ptr);
  }
  return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
}

4809

unknown's avatar
unknown committed
4810 4811 4812
void Field_timestamp::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4813
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832
  {
    to[0] = ptr[0];
    to[1] = ptr[1];
    to[2] = ptr[2];
    to[3] = ptr[3];
  }
  else
#endif
  {
    to[0] = ptr[3];
    to[1] = ptr[2];
    to[2] = ptr[1];
    to[3] = ptr[0];
  }
}


void Field_timestamp::sql_type(String &res) const
{
4833
  res.set_ascii(STRING_WITH_LEN("timestamp"));
unknown's avatar
unknown committed
4834 4835 4836 4837 4838
}


void Field_timestamp::set_time()
{
4839
  long tmp= (long) table->in_use->query_start();
4840
  set_notnull();
unknown's avatar
unknown committed
4841
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4842
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
}

/****************************************************************************
** time type
** In string context: HH:MM:SS
** In number context: HHMMSS
** Stored as a 3 byte unsigned int
****************************************************************************/

unknown's avatar
unknown committed
4858
int Field_time::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4859 4860 4861
{
  TIME ltime;
  long tmp;
4862 4863 4864
  int error;

  if (str_to_time(from, len, &ltime, &error))
4865
  {
unknown's avatar
unknown committed
4866
    tmp=0L;
unknown's avatar
unknown committed
4867
    error= 2;
4868
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
4869
                         from, len, MYSQL_TIMESTAMP_TIME, 1);
4870
  }
unknown's avatar
unknown committed
4871 4872
  else
  {
4873 4874
    if (error)
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4875
                           WARN_DATA_TRUNCATED,
4876
                           from, len, MYSQL_TIMESTAMP_TIME, 1);
4877

unknown's avatar
unknown committed
4878 4879 4880 4881 4882 4883
    if (ltime.month)
      ltime.day=0;
    tmp=(ltime.day*24L+ltime.hour)*10000L+(ltime.minute*100+ltime.second);
    if (tmp > 8385959)
    {
      tmp=8385959;
4884 4885
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                           ER_WARN_DATA_OUT_OF_RANGE,
4886
                           from, len, MYSQL_TIMESTAMP_TIME, !error);
unknown's avatar
unknown committed
4887
      error= 1;
unknown's avatar
unknown committed
4888
    }
unknown's avatar
unknown committed
4889 4890
    if (error > 1)
      error= 2;
unknown's avatar
unknown committed
4891
  }
4892
  
unknown's avatar
unknown committed
4893 4894
  if (ltime.neg)
    tmp= -tmp;
4895
  error |= Field_time::store((longlong) tmp, FALSE);
4896
  return error;
unknown's avatar
unknown committed
4897 4898 4899
}


4900 4901 4902 4903 4904 4905 4906 4907 4908 4909
int Field_time::store_time(TIME *ltime, timestamp_type type)
{
  long tmp= ((ltime->month ? 0 : ltime->day * 24L) + ltime->hour) * 10000L +
            (ltime->minute * 100 + ltime->second);
  if (ltime->neg)
    tmp= -tmp;
  return Field_time::store((longlong) tmp);
}


unknown's avatar
unknown committed
4910
int Field_time::store(double nr)
unknown's avatar
unknown committed
4911 4912
{
  long tmp;
unknown's avatar
unknown committed
4913
  int error= 0;
unknown's avatar
unknown committed
4914 4915 4916
  if (nr > 8385959.0)
  {
    tmp=8385959L;
4917
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4918
                         ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
4919
    error= 1;
unknown's avatar
unknown committed
4920 4921 4922 4923
  }
  else if (nr < -8385959.0)
  {
    tmp= -8385959L;
4924
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4925
                         ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
4926
    error= 1;
unknown's avatar
unknown committed
4927 4928 4929 4930 4931 4932 4933 4934 4935
  }
  else
  {
    tmp=(long) floor(fabs(nr));			// Remove fractions
    if (nr < 0)
      tmp= -tmp;
    if (tmp % 100 > 59 || tmp/100 % 100 > 59)
    {
      tmp=0;
4936
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4937 4938
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
4939
      error= 1;
unknown's avatar
unknown committed
4940 4941 4942
    }
  }
  int3store(ptr,tmp);
4943
  return error;
unknown's avatar
unknown committed
4944 4945 4946
}


4947
int Field_time::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
4948 4949
{
  long tmp;
unknown's avatar
unknown committed
4950
  int error= 0;
4951
  if (nr < (longlong) -8385959L && !unsigned_val)
unknown's avatar
unknown committed
4952
  {
4953
    tmp= -8385959L;
4954
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4955 4956
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
4957
    error= 1;
unknown's avatar
unknown committed
4958
  }
4959
  else if (nr > (longlong) 8385959 || nr < 0 && unsigned_val)
unknown's avatar
unknown committed
4960
  {
4961
    tmp=8385959L;
4962
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4963 4964
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
4965
    error= 1;
unknown's avatar
unknown committed
4966 4967 4968 4969 4970 4971 4972
  }
  else
  {
    tmp=(long) nr;
    if (tmp % 100 > 59 || tmp/100 % 100 > 59)
    {
      tmp=0;
4973
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4974 4975
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
4976
      error= 1;
unknown's avatar
unknown committed
4977 4978 4979
    }
  }
  int3store(ptr,tmp);
4980
  return error;
unknown's avatar
unknown committed
4981 4982 4983 4984 4985
}


double Field_time::val_real(void)
{
unknown's avatar
unknown committed
4986
  uint32 j= (uint32) uint3korr(ptr);
unknown's avatar
unknown committed
4987 4988 4989 4990 4991 4992 4993 4994
  return (double) j;
}

longlong Field_time::val_int(void)
{
  return (longlong) sint3korr(ptr);
}

4995 4996 4997 4998 4999 5000

/*
  This function is multi-byte safe as the result string is always of type
  my_charset_bin
*/

unknown's avatar
unknown committed
5001 5002 5003
String *Field_time::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
5004
  TIME ltime;
5005
  val_buffer->alloc(19);
unknown's avatar
unknown committed
5006
  long tmp=(long) sint3korr(ptr);
5007
  ltime.neg= 0;
unknown's avatar
unknown committed
5008 5009 5010
  if (tmp < 0)
  {
    tmp= -tmp;
5011 5012 5013 5014 5015 5016
    ltime.neg= 1;
  }
  ltime.day= (uint) 0;
  ltime.hour= (uint) (tmp/10000);
  ltime.minute= (uint) (tmp/100 % 100);
  ltime.second= (uint) (tmp % 100);
5017
  make_time((DATE_TIME_FORMAT*) 0, &ltime, val_buffer);
unknown's avatar
unknown committed
5018 5019 5020
  return val_buffer;
}

5021

unknown's avatar
unknown committed
5022
/*
unknown's avatar
unknown committed
5023
  Normally we would not consider 'time' as a valid date, but we allow
unknown's avatar
unknown committed
5024 5025 5026 5027 5028
  get_date() here to be able to do things like
  DATE_FORMAT(time, "%l.%i %p")
*/
 
bool Field_time::get_date(TIME *ltime, uint fuzzydate)
5029
{
unknown's avatar
unknown committed
5030
  long tmp;
unknown's avatar
unknown committed
5031
  if (!(fuzzydate & TIME_FUZZY_DATE))
unknown's avatar
unknown committed
5032
  {
5033 5034 5035 5036
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_WARN_DATA_OUT_OF_RANGE,
                        ER(ER_WARN_DATA_OUT_OF_RANGE), field_name,
                        table->in_use->row_count);
unknown's avatar
unknown committed
5037 5038 5039
    return 1;
  }
  tmp=(long) sint3korr(ptr);
5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053
  ltime->neg=0;
  if (tmp < 0)
  {
    ltime->neg= 1;
    tmp=-tmp;
  }
  ltime->hour=tmp/10000;
  tmp-=ltime->hour*10000;
  ltime->minute=   tmp/100;
  ltime->second= tmp % 100;
  ltime->year= ltime->month= ltime->day= ltime->second_part= 0;
  return 0;
}

unknown's avatar
unknown committed
5054

unknown's avatar
unknown committed
5055 5056 5057 5058 5059 5060 5061 5062 5063
bool Field_time::get_time(TIME *ltime)
{
  long tmp=(long) sint3korr(ptr);
  ltime->neg=0;
  if (tmp < 0)
  {
    ltime->neg= 1;
    tmp=-tmp;
  }
unknown's avatar
unknown committed
5064
  ltime->day= 0;
unknown's avatar
unknown committed
5065
  ltime->hour=   (int) (tmp/10000);
unknown's avatar
unknown committed
5066
  tmp-=ltime->hour*10000;
unknown's avatar
unknown committed
5067 5068
  ltime->minute= (int) tmp/100;
  ltime->second= (int) tmp % 100;
unknown's avatar
unknown committed
5069
  ltime->second_part=0;
5070
  ltime->time_type= MYSQL_TIMESTAMP_TIME;
unknown's avatar
unknown committed
5071 5072 5073
  return 0;
}

5074 5075 5076 5077 5078

bool Field_time::send_binary(Protocol *protocol)
{
  TIME tm;
  Field_time::get_time(&tm);
5079 5080
  tm.day= tm.hour/24;				// Move hours to days
  tm.hour-= tm.day*24;
unknown's avatar
unknown committed
5081
  return protocol->store_time(&tm);
5082 5083 5084
}


unknown's avatar
unknown committed
5085 5086
int Field_time::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
5087 5088 5089
  int32 a,b;
  a=(int32) sint3korr(a_ptr);
  b=(int32) sint3korr(b_ptr);
unknown's avatar
unknown committed
5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

void Field_time::sort_string(char *to,uint length __attribute__((unused)))
{
  to[0] = (uchar) (ptr[2] ^ 128);
  to[1] = ptr[1];
  to[2] = ptr[0];
}

void Field_time::sql_type(String &res) const
{
5102
  res.set_ascii(STRING_WITH_LEN("time"));
unknown's avatar
unknown committed
5103 5104 5105 5106 5107 5108 5109 5110
}

/****************************************************************************
** year type
** Save in a byte the year 0, 1901->2155
** Can handle 2 byte or 4 byte years!
****************************************************************************/

unknown's avatar
unknown committed
5111
int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5112
{
5113
  char *end;
unknown's avatar
unknown committed
5114 5115
  int error;
  long nr= my_strntol(cs, from, len, 10, &end, &error);
unknown's avatar
unknown committed
5116

unknown's avatar
unknown committed
5117
  if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155 || error)
unknown's avatar
unknown committed
5118 5119
  {
    *ptr=0;
5120
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
5121
    return 1;
unknown's avatar
unknown committed
5122
  }
unknown's avatar
unknown committed
5123 5124 5125
  if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
    error= 1;

unknown's avatar
unknown committed
5126 5127 5128 5129 5130 5131 5132 5133
  if (nr != 0 || len != 4)
  {
    if (nr < YY_PART_YEAR)
      nr+=100;					// 2000 - 2069
    else if (nr > 1900)
      nr-= 1900;
  }
  *ptr= (char) (unsigned char) nr;
unknown's avatar
unknown committed
5134
  return error;
unknown's avatar
unknown committed
5135 5136
}

unknown's avatar
unknown committed
5137

unknown's avatar
unknown committed
5138
int Field_year::store(double nr)
unknown's avatar
unknown committed
5139 5140
{
  if (nr < 0.0 || nr >= 2155.0)
5141
  {
5142
    (void) Field_year::store((longlong) -1, FALSE);
5143 5144
    return 1;
  }
5145
  return Field_year::store((longlong) nr, FALSE);
unknown's avatar
unknown committed
5146 5147
}

5148 5149

int Field_year::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
5150 5151 5152
{
  if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155)
  {
5153
    *ptr= 0;
5154
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
5155
    return 1;
unknown's avatar
unknown committed
5156 5157 5158 5159 5160 5161 5162 5163 5164
  }
  if (nr != 0 || field_length != 4)		// 0000 -> 0; 00 -> 2000
  {
    if (nr < YY_PART_YEAR)
      nr+=100;					// 2000 - 2069
    else if (nr > 1900)
      nr-= 1900;
  }
  *ptr= (char) (unsigned char) nr;
5165
  return 0;
unknown's avatar
unknown committed
5166 5167
}

5168

unknown's avatar
unknown committed
5169 5170 5171
bool Field_year::send_binary(Protocol *protocol)
{
  ulonglong tmp= Field_year::val_int();
5172
  return protocol->store_short(tmp);
unknown's avatar
unknown committed
5173
}
unknown's avatar
unknown committed
5174

5175

unknown's avatar
unknown committed
5176 5177 5178 5179 5180
double Field_year::val_real(void)
{
  return (double) Field_year::val_int();
}

5181

unknown's avatar
unknown committed
5182 5183 5184 5185 5186 5187 5188 5189 5190 5191
longlong Field_year::val_int(void)
{
  int tmp= (int) ((uchar*) ptr)[0];
  if (field_length != 4)
    tmp%=100;					// Return last 2 char
  else if (tmp)
    tmp+=1900;
  return (longlong) tmp;
}

5192

unknown's avatar
unknown committed
5193 5194 5195 5196 5197 5198 5199 5200 5201 5202
String *Field_year::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
  val_buffer->alloc(5);
  val_buffer->length(field_length);
  char *to=(char*) val_buffer->ptr();
  sprintf(to,field_length == 2 ? "%02d" : "%04d",(int) Field_year::val_int());
  return val_buffer;
}

5203

unknown's avatar
unknown committed
5204 5205
void Field_year::sql_type(String &res) const
{
unknown's avatar
unknown committed
5206
  CHARSET_INFO *cs=res.charset();
5207
  res.length(cs->cset->snprintf(cs,(char*)res.ptr(),res.alloced_length(),
5208
			  "year(%d)",(int) field_length));
unknown's avatar
unknown committed
5209 5210 5211 5212 5213 5214 5215 5216 5217 5218
}


/****************************************************************************
** date type
** In string context: YYYY-MM-DD
** In number context: YYYYMMDD
** Stored as a 4 byte unsigned int
****************************************************************************/

unknown's avatar
unknown committed
5219
int Field_date::store(const char *from, uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5220 5221
{
  TIME l_time;
unknown's avatar
unknown committed
5222
  uint32 tmp;
5223
  int error;
5224

unknown's avatar
unknown committed
5225 5226 5227 5228 5229
  if (str_to_datetime(from, len, &l_time, TIME_FUZZY_DATE |
                      (table->in_use->variables.sql_mode &
                       (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                        MODE_INVALID_DATES)),
                      &error) <= MYSQL_TIMESTAMP_ERROR)
5230
  {
5231
    tmp= 0;
unknown's avatar
unknown committed
5232
    error= 2;
5233
  }
unknown's avatar
unknown committed
5234
  else
unknown's avatar
unknown committed
5235
    tmp=(uint32) l_time.year*10000L + (uint32) (l_time.month*100+l_time.day);
5236 5237

  if (error)
5238
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
5239
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
5240

unknown's avatar
unknown committed
5241
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5242
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5243 5244 5245 5246 5247 5248
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
5249
  return error;
unknown's avatar
unknown committed
5250 5251 5252
}


unknown's avatar
unknown committed
5253
int Field_date::store(double nr)
unknown's avatar
unknown committed
5254
{
5255
  longlong tmp;
unknown's avatar
unknown committed
5256
  int error= 0;
unknown's avatar
unknown committed
5257 5258 5259 5260
  if (nr >= 19000000000000.0 && nr <= 99991231235959.0)
    nr=floor(nr/1000000.0);			// Timestamp to date
  if (nr < 0.0 || nr > 99991231.0)
  {
5261
    tmp= LL(0);
5262 5263
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                         ER_WARN_DATA_OUT_OF_RANGE,
5264
                         nr, MYSQL_TIMESTAMP_DATE);
unknown's avatar
unknown committed
5265
    error= 1;
unknown's avatar
unknown committed
5266 5267
  }
  else
5268
    tmp= (longlong) rint(nr);
5269

5270
  return Field_date::store(tmp, TRUE);
unknown's avatar
unknown committed
5271 5272 5273
}


5274
int Field_date::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
5275
{
5276 5277 5278 5279 5280 5281 5282 5283 5284 5285
  TIME not_used;
  int error;
  longlong initial_nr= nr;

  nr= number_to_datetime(nr, &not_used, (TIME_FUZZY_DATE |
                                         (table->in_use->variables.sql_mode &
                                          (MODE_NO_ZERO_IN_DATE |
                                           MODE_NO_ZERO_DATE |
                                           MODE_INVALID_DATES))), &error);

5286
  if (nr == LL(-1))
unknown's avatar
unknown committed
5287
  {
5288 5289
    nr= 0;
    error= 2;
unknown's avatar
unknown committed
5290
  }
5291

5292
  if (nr >= 19000000000000.0 && nr <= 99991231235959.0)
5293
    nr= (longlong) floor(nr/1000000.0);         // Timestamp to date
5294

5295 5296 5297 5298 5299
  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                         error == 2 ? ER_WARN_DATA_OUT_OF_RANGE :
                         WARN_DATA_TRUNCATED, initial_nr,
                         MYSQL_TIMESTAMP_DATETIME, 1);
5300

unknown's avatar
unknown committed
5301
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5302
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5303
  {
5304
    int4store(ptr, nr);
unknown's avatar
unknown committed
5305 5306 5307
  }
  else
#endif
5308
    longstore(ptr, nr);
5309
  return error;
unknown's avatar
unknown committed
5310 5311 5312
}


unknown's avatar
unknown committed
5313 5314 5315 5316 5317 5318 5319 5320 5321 5322
bool Field_date::send_binary(Protocol *protocol)
{
  longlong tmp= Field_date::val_int();
  TIME tm;
  tm.year= (uint32) tmp/10000L % 10000;
  tm.month= (uint32) tmp/100 % 100;
  tm.day= (uint32) tmp % 100;
  return protocol->store_date(&tm);
}

unknown's avatar
unknown committed
5323 5324 5325 5326 5327

double Field_date::val_real(void)
{
  int32 j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5328
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5329 5330 5331 5332 5333 5334 5335
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return (double) (uint32) j;
}

5336

unknown's avatar
unknown committed
5337 5338 5339 5340
longlong Field_date::val_int(void)
{
  int32 j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5341
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5342 5343 5344 5345 5346 5347 5348
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return (longlong) (uint32) j;
}

5349

unknown's avatar
unknown committed
5350 5351 5352
String *Field_date::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
5353
  TIME ltime;
unknown's avatar
unknown committed
5354 5355 5356
  val_buffer->alloc(field_length);
  int32 tmp;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5357
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5358 5359 5360 5361
    tmp=sint4korr(ptr);
  else
#endif
    longget(tmp,ptr);
5362 5363 5364 5365
  ltime.neg= 0;
  ltime.year= (int) ((uint32) tmp/10000L % 10000);
  ltime.month= (int) ((uint32) tmp/100 % 100);
  ltime.day= (int) ((uint32) tmp % 100);
5366
  make_date((DATE_TIME_FORMAT *) 0, &ltime, val_buffer);
unknown's avatar
unknown committed
5367 5368 5369
  return val_buffer;
}

5370

unknown's avatar
unknown committed
5371 5372 5373 5374
int Field_date::cmp(const char *a_ptr, const char *b_ptr)
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5375
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392
  {
    a=sint4korr(a_ptr);
    b=sint4korr(b_ptr);
  }
  else
#endif
  {
    longget(a,a_ptr);
    longget(b,b_ptr);
  }
  return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
}


void Field_date::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5393
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411
  {
    to[0] = ptr[0];
    to[1] = ptr[1];
    to[2] = ptr[2];
    to[3] = ptr[3];
  }
  else
#endif
  {
    to[0] = ptr[3];
    to[1] = ptr[2];
    to[2] = ptr[1];
    to[3] = ptr[0];
  }
}

void Field_date::sql_type(String &res) const
{
5412
  res.set_ascii(STRING_WITH_LEN("date"));
unknown's avatar
unknown committed
5413 5414
}

5415

unknown's avatar
unknown committed
5416 5417 5418 5419 5420 5421
/****************************************************************************
** The new date type
** This is identical to the old date type, but stored on 3 bytes instead of 4
** In number context: YYYYMMDD
****************************************************************************/

unknown's avatar
unknown committed
5422
int Field_newdate::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5423 5424 5425
{
  TIME l_time;
  long tmp;
5426
  int error;
unknown's avatar
unknown committed
5427 5428 5429 5430 5431 5432
  if (str_to_datetime(from, len, &l_time,
                      (TIME_FUZZY_DATE |
                       (table->in_use->variables.sql_mode &
                        (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                         MODE_INVALID_DATES))),
                      &error) <= MYSQL_TIMESTAMP_ERROR)
5433
  {
5434
    tmp= 0L;
unknown's avatar
unknown committed
5435
    error= 2;
5436
  }
unknown's avatar
unknown committed
5437 5438
  else
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
5439 5440

  if (error)
5441
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
5442
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
5443

unknown's avatar
unknown committed
5444
  int3store(ptr,tmp);
5445
  return error;
unknown's avatar
unknown committed
5446 5447
}

5448

unknown's avatar
unknown committed
5449
int Field_newdate::store(double nr)
unknown's avatar
unknown committed
5450 5451
{
  if (nr < 0.0 || nr > 99991231235959.0)
5452
  {
5453
    int3store(ptr,(int32) 0);
5454
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
5455
                         WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATE);
5456 5457
    return 1;
  }
5458
  return Field_newdate::store((longlong) rint(nr), FALSE);
unknown's avatar
unknown committed
5459 5460 5461
}


5462
int Field_newdate::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
5463
{
5464
  TIME l_time;
5465
  longlong tmp;
5466
  int error;
5467 5468 5469 5470 5471 5472
  if (number_to_datetime(nr, &l_time,
                         (TIME_FUZZY_DATE |
                          (table->in_use->variables.sql_mode &
                           (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                            MODE_INVALID_DATES))),
                         &error) == LL(-1))
5473 5474 5475
  {
    tmp= 0L;
    error= 2;
unknown's avatar
unknown committed
5476 5477
  }
  else
5478
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
5479

5480 5481 5482 5483 5484 5485
  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                         error == 2 ? ER_WARN_DATA_OUT_OF_RANGE :
                         WARN_DATA_TRUNCATED,nr,MYSQL_TIMESTAMP_DATE, 1);

  int3store(ptr,tmp);
5486
  return error;
unknown's avatar
unknown committed
5487 5488
}

5489

5490
int Field_newdate::store_time(TIME *ltime,timestamp_type type)
unknown's avatar
unknown committed
5491 5492
{
  long tmp;
5493
  int error= 0;
5494
  if (type == MYSQL_TIMESTAMP_DATE || type == MYSQL_TIMESTAMP_DATETIME)
unknown's avatar
unknown committed
5495 5496 5497 5498
    tmp=ltime->year*16*32+ltime->month*32+ltime->day;
  else
  {
    tmp=0;
5499
    error= 1;
5500
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5501 5502
  }
  int3store(ptr,tmp);
5503
  return error;
unknown's avatar
unknown committed
5504 5505
}

5506

unknown's avatar
unknown committed
5507 5508 5509 5510 5511 5512
bool Field_newdate::send_binary(Protocol *protocol)
{
  TIME tm;
  Field_newdate::get_date(&tm,0);
  return protocol->store_date(&tm);
}
unknown's avatar
unknown committed
5513

5514

unknown's avatar
unknown committed
5515 5516 5517 5518 5519
double Field_newdate::val_real(void)
{
  return (double) Field_newdate::val_int();
}

5520

unknown's avatar
unknown committed
5521 5522
longlong Field_newdate::val_int(void)
{
unknown's avatar
unknown committed
5523
  ulong j= uint3korr(ptr);
unknown's avatar
unknown committed
5524 5525 5526 5527
  j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
  return (longlong) j;
}

5528

unknown's avatar
unknown committed
5529 5530 5531 5532 5533
String *Field_newdate::val_str(String *val_buffer,
			       String *val_ptr __attribute__((unused)))
{
  val_buffer->alloc(field_length);
  val_buffer->length(field_length);
unknown's avatar
unknown committed
5534
  uint32 tmp=(uint32) uint3korr(ptr);
unknown's avatar
unknown committed
5535 5536 5537 5538
  int part;
  char *pos=(char*) val_buffer->ptr()+10;

  /* Open coded to get more speed */
unknown's avatar
unknown committed
5539
  *pos--=0;					// End NULL
unknown's avatar
unknown committed
5540
  part=(int) (tmp & 31);
unknown's avatar
unknown committed
5541 5542 5543
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
unknown's avatar
unknown committed
5544
  part=(int) (tmp >> 5 & 15);
unknown's avatar
unknown committed
5545 5546 5547
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
unknown's avatar
unknown committed
5548
  part=(int) (tmp >> 9);
unknown's avatar
unknown committed
5549 5550 5551 5552
  *pos--= (char) ('0'+part%10); part/=10;
  *pos--= (char) ('0'+part%10); part/=10;
  *pos--= (char) ('0'+part%10); part/=10;
  *pos=   (char) ('0'+part);
unknown's avatar
unknown committed
5553 5554 5555
  return val_buffer;
}

5556

5557
bool Field_newdate::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
5558
{
unknown's avatar
unknown committed
5559
  uint32 tmp=(uint32) uint3korr(ptr);
unknown's avatar
unknown committed
5560 5561 5562
  ltime->day=   tmp & 31;
  ltime->month= (tmp >> 5) & 15;
  ltime->year=  (tmp >> 9);
5563
  ltime->time_type= MYSQL_TIMESTAMP_DATE;
5564
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
unknown's avatar
unknown committed
5565 5566
  return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
          1 : 0);
unknown's avatar
unknown committed
5567 5568
}

5569

unknown's avatar
unknown committed
5570 5571
bool Field_newdate::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
5572
  return Field_newdate::get_date(ltime,0);
unknown's avatar
unknown committed
5573 5574
}

5575

unknown's avatar
unknown committed
5576 5577
int Field_newdate::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
5578 5579 5580
  uint32 a,b;
  a=(uint32) uint3korr(a_ptr);
  b=(uint32) uint3korr(b_ptr);
unknown's avatar
unknown committed
5581 5582 5583
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

5584

unknown's avatar
unknown committed
5585 5586 5587 5588 5589 5590 5591
void Field_newdate::sort_string(char *to,uint length __attribute__((unused)))
{
  to[0] = ptr[2];
  to[1] = ptr[1];
  to[2] = ptr[0];
}

5592

unknown's avatar
unknown committed
5593 5594
void Field_newdate::sql_type(String &res) const
{
5595
  res.set_ascii(STRING_WITH_LEN("date"));
unknown's avatar
unknown committed
5596 5597 5598 5599 5600 5601 5602 5603 5604 5605
}


/****************************************************************************
** datetime type
** In string context: YYYY-MM-DD HH:MM:DD
** In number context: YYYYMMDDHHMMDD
** Stored as a 8 byte unsigned int. Should sometimes be change to a 6 byte int.
****************************************************************************/

unknown's avatar
unknown committed
5606
int Field_datetime::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5607
{
5608 5609 5610
  TIME time_tmp;
  int error;
  ulonglong tmp= 0;
5611
  enum enum_mysql_timestamp_type func_res;
5612

5613 5614 5615 5616 5617 5618 5619
  func_res= str_to_datetime(from, len, &time_tmp,
                            (TIME_FUZZY_DATE |
                             (table->in_use->variables.sql_mode &
                              (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                               MODE_INVALID_DATES))),
                            &error);
  if ((int) func_res > (int) MYSQL_TIMESTAMP_ERROR)
5620
    tmp= TIME_to_ulonglong_datetime(&time_tmp);
5621 5622 5623
  else
    error= 1;                                 // Fix if invalid zero date

5624
  if (error)
5625
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
5626
                         ER_WARN_DATA_OUT_OF_RANGE,
5627
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
5628

unknown's avatar
unknown committed
5629
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5630
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5631 5632 5633 5634 5635 5636
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
5637
  return error;
unknown's avatar
unknown committed
5638 5639 5640
}


unknown's avatar
unknown committed
5641
int Field_datetime::store(double nr)
unknown's avatar
unknown committed
5642
{
unknown's avatar
unknown committed
5643
  int error= 0;
unknown's avatar
unknown committed
5644 5645
  if (nr < 0.0 || nr > 99991231235959.0)
  {
5646 5647
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE,
5648
                         nr, MYSQL_TIMESTAMP_DATETIME);
5649
    nr= 0.0;
unknown's avatar
unknown committed
5650
    error= 1;
unknown's avatar
unknown committed
5651
  }
5652
  error|= Field_datetime::store((longlong) rint(nr), FALSE);
5653
  return error;
unknown's avatar
unknown committed
5654 5655 5656
}


5657
int Field_datetime::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
5658
{
5659
  TIME not_used;
5660 5661 5662
  int error;
  longlong initial_nr= nr;

5663 5664 5665 5666 5667 5668
  nr= number_to_datetime(nr, &not_used, (TIME_FUZZY_DATE |
                                         (table->in_use->variables.sql_mode &
                                          (MODE_NO_ZERO_IN_DATE |
                                           MODE_NO_ZERO_DATE |
                                           MODE_INVALID_DATES))), &error);

5669
  if (nr == LL(-1))
5670
  {
5671 5672
    nr= 0;
    error= 2;
5673
  }
5674

5675 5676 5677 5678 5679 5680
  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                         error == 2 ? ER_WARN_DATA_OUT_OF_RANGE :
                         WARN_DATA_TRUNCATED, initial_nr,
                         MYSQL_TIMESTAMP_DATETIME, 1);

unknown's avatar
unknown committed
5681
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5682
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5683 5684 5685 5686 5687 5688
  {
    int8store(ptr,nr);
  }
  else
#endif
    longlongstore(ptr,nr);
5689
  return error;
unknown's avatar
unknown committed
5690 5691
}

unknown's avatar
unknown committed
5692

5693
int Field_datetime::store_time(TIME *ltime,timestamp_type type)
unknown's avatar
unknown committed
5694 5695
{
  longlong tmp;
5696
  int error= 0;
5697 5698 5699 5700
  /*
    We don't perform range checking here since values stored in TIME
    structure always fit into DATETIME range.
  */
5701
  if (type == MYSQL_TIMESTAMP_DATE || type == MYSQL_TIMESTAMP_DATETIME)
unknown's avatar
unknown committed
5702 5703 5704 5705 5706
    tmp=((ltime->year*10000L+ltime->month*100+ltime->day)*LL(1000000)+
	 (ltime->hour*10000L+ltime->minute*100+ltime->second));
  else
  {
    tmp=0;
5707
    error= 1;
5708
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5709 5710
  }
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5711
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5712 5713 5714 5715 5716 5717
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
5718
  return error;
unknown's avatar
unknown committed
5719 5720
}

unknown's avatar
unknown committed
5721 5722 5723
bool Field_datetime::send_binary(Protocol *protocol)
{
  TIME tm;
5724
  Field_datetime::get_date(&tm, TIME_FUZZY_DATE);
unknown's avatar
unknown committed
5725 5726 5727
  return protocol->store(&tm);
}

unknown's avatar
unknown committed
5728 5729 5730 5731 5732 5733 5734 5735 5736 5737

double Field_datetime::val_real(void)
{
  return (double) Field_datetime::val_int();
}

longlong Field_datetime::val_int(void)
{
  longlong j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5738
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757
    j=sint8korr(ptr);
  else
#endif
    longlongget(j,ptr);
  return j;
}


String *Field_datetime::val_str(String *val_buffer,
				String *val_ptr __attribute__((unused)))
{
  val_buffer->alloc(field_length);
  val_buffer->length(field_length);
  ulonglong tmp;
  long part1,part2;
  char *pos;
  int part3;

#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5758
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5759 5760 5761 5762 5763 5764
    tmp=sint8korr(ptr);
  else
#endif
    longlongget(tmp,ptr);

  /*
unknown's avatar
unknown committed
5765
    Avoid problem with slow longlong arithmetic and sprintf
unknown's avatar
unknown committed
5766 5767 5768 5769 5770 5771 5772
  */

  part1=(long) (tmp/LL(1000000));
  part2=(long) (tmp - (ulonglong) part1*LL(1000000));

  pos=(char*) val_buffer->ptr()+19;
  *pos--=0;
unknown's avatar
unknown committed
5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791
  *pos--= (char) ('0'+(char) (part2%10)); part2/=10;
  *pos--= (char) ('0'+(char) (part2%10)); part3= (int) (part2 / 10);
  *pos--= ':';
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos--= ':';
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos--= (char) ('0'+(char) part3);
  *pos--= ' ';
  *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
  *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
  *pos--= '-';
  *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
  *pos--= (char) ('0'+(char) (part1%10)); part3= (int) (part1/10);
  *pos--= '-';
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos=(char) ('0'+(char) part3);
unknown's avatar
unknown committed
5792 5793 5794
  return val_buffer;
}

5795
bool Field_datetime::get_date(TIME *ltime, uint fuzzydate)
unknown's avatar
unknown committed
5796 5797
{
  longlong tmp=Field_datetime::val_int();
unknown's avatar
unknown committed
5798 5799 5800
  uint32 part1,part2;
  part1=(uint32) (tmp/LL(1000000));
  part2=(uint32) (tmp - (ulonglong) part1*LL(1000000));
unknown's avatar
unknown committed
5801

5802
  ltime->time_type=	MYSQL_TIMESTAMP_DATETIME;
unknown's avatar
unknown committed
5803 5804 5805 5806 5807 5808 5809 5810
  ltime->neg=		0;
  ltime->second_part=	0;
  ltime->second=	(int) (part2%100);
  ltime->minute=	(int) (part2/100%100);
  ltime->hour=		(int) (part2/10000);
  ltime->day=		(int) (part1%100);
  ltime->month= 	(int) (part1/100%100);
  ltime->year= 		(int) (part1/10000);
unknown's avatar
unknown committed
5811
  return (!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ? 1 : 0;
unknown's avatar
unknown committed
5812 5813 5814 5815
}

bool Field_datetime::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
5816
  return Field_datetime::get_date(ltime,0);
unknown's avatar
unknown committed
5817 5818 5819 5820 5821 5822
}

int Field_datetime::cmp(const char *a_ptr, const char *b_ptr)
{
  longlong a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5823
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840
  {
    a=sint8korr(a_ptr);
    b=sint8korr(b_ptr);
  }
  else
#endif
  {
    longlongget(a,a_ptr);
    longlongget(b,b_ptr);
  }
  return ((ulonglong) a < (ulonglong) b) ? -1 :
    ((ulonglong) a > (ulonglong) b) ? 1 : 0;
}

void Field_datetime::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5841
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868
  {
    to[0] = ptr[0];
    to[1] = ptr[1];
    to[2] = ptr[2];
    to[3] = ptr[3];
    to[4] = ptr[4];
    to[5] = ptr[5];
    to[6] = ptr[6];
    to[7] = ptr[7];
  }
  else
#endif
  {
    to[0] = ptr[7];
    to[1] = ptr[6];
    to[2] = ptr[5];
    to[3] = ptr[4];
    to[4] = ptr[3];
    to[5] = ptr[2];
    to[6] = ptr[1];
    to[7] = ptr[0];
  }
}


void Field_datetime::sql_type(String &res) const
{
5869
  res.set_ascii(STRING_WITH_LEN("datetime"));
unknown's avatar
unknown committed
5870 5871 5872 5873 5874 5875 5876 5877 5878
}

/****************************************************************************
** string type
** A string may be varchar or binary
****************************************************************************/

	/* Copy a string and fill with space */

unknown's avatar
unknown committed
5879
int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5880
{
5881
  int error= 0, well_formed_error;
unknown's avatar
unknown committed
5882
  uint32 not_used;
unknown's avatar
unknown committed
5883
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
5884
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
5885
  uint copy_length;
5886

5887 5888
  /* See the comment for Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
5889

unknown's avatar
unknown committed
5890
  /* Convert character set if necessary */
unknown's avatar
unknown committed
5891
  if (String::needs_conversion(length, cs, field_charset, &not_used))
5892
  {
5893 5894
    uint conv_errors;
    tmpstr.copy(from, length, cs, field_charset, &conv_errors);
unknown's avatar
unknown committed
5895
    from= tmpstr.ptr();
5896
    length= tmpstr.length();
5897
    if (conv_errors)
unknown's avatar
unknown committed
5898
      error= 2;
unknown's avatar
unknown committed
5899
  }
unknown's avatar
unknown committed
5900

5901
  /* Make sure we don't break a multibyte sequence or copy malformed data. */
5902
  copy_length= field_charset->cset->well_formed_len(field_charset,
5903 5904 5905
                                                    from,from+length,
                                                    field_length/
                                                    field_charset->mbmaxlen,
5906
                                                    &well_formed_error);
5907
  memmove(ptr, from, copy_length);
5908 5909 5910

  /* Append spaces if the string was shorter than the field. */
  if (copy_length < field_length)
unknown's avatar
unknown committed
5911
    field_charset->cset->fill(field_charset,ptr+copy_length,
5912
                              field_length-copy_length,
5913
                              field_charset->pad_char);
5914 5915 5916 5917 5918

  /*
    Check if we lost any important data (anything in a binary string,
    or any non-space in others).
  */
5919
  if ((copy_length < length) && table->in_use->count_cuted_fields)
5920 5921
  {
    if (binary())
unknown's avatar
unknown committed
5922
      error= 2;
5923 5924 5925 5926 5927 5928 5929 5930 5931
    else
    {
      const char *end=from+length;
      from+= copy_length;
      from+= field_charset->cset->scan(field_charset, from, end,
                                       MY_SEQ_SPACES);
      if (from != end)
        error= 2;
    }
unknown's avatar
unknown committed
5932
  }
5933
  if (error)
5934 5935 5936 5937
  {
    if (table->in_use->abort_on_warning)
      set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
    else
5938
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
5939
  }
5940
  return error;
unknown's avatar
unknown committed
5941 5942 5943
}


5944 5945 5946 5947
/*
  Store double value in Field_string or Field_varstring.

  SYNOPSIS
unknown's avatar
unknown committed
5948
    store(double nr)
5949 5950 5951 5952 5953 5954
    nr            number

  DESCRIPTION
    Pretty prints double number into field_length characters buffer.
*/

unknown's avatar
unknown committed
5955
int Field_str::store(double nr)
unknown's avatar
unknown committed
5956
{
5957
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
5958
  uint length;
unknown's avatar
unknown committed
5959
  bool use_scientific_notation= TRUE;
5960
  uint char_length= field_length / charset()->mbmaxlen;
5961 5962 5963 5964 5965 5966
  /*
    Check fabs(nr) against longest value that can be stored in field,
    which depends on whether the value is < 1 or not, and negative or not
  */
  double anr= fabs(nr);
  int neg= (nr < 0.0) ? 1 : 0;
5967
  if (char_length > 4 && char_length < 32 &&
unknown's avatar
Merge  
unknown committed
5968
      (anr < 1.0 ? anr > 1/(log_10[max(0,(int) char_length-neg-2)]) /* -2 for "0." */
5969
                 : anr < log_10[char_length-neg]-1))
unknown's avatar
unknown committed
5970
    use_scientific_notation= FALSE;
unknown's avatar
unknown committed
5971

unknown's avatar
unknown committed
5972 5973
  length= (uint) my_sprintf(buff, (buff, "%-.*g",
                                   (use_scientific_notation ?
5974 5975
                                    max(0, (int)char_length-neg-5) :
                                    char_length),
unknown's avatar
unknown committed
5976
                                   nr));
5977 5978 5979 5980 5981
  /*
    +1 below is because "precision" in %g above means the
    max. number of significant digits, not the output width.
    Thus the width can be larger than number of significant digits by 1
    (for decimal point)
5982
    the test for char_length < 5 is for extreme cases,
5983
    like inserting 500.0 in char(1)
5984
  */
5985
  DBUG_ASSERT(char_length < 5 || length <= char_length+1);
5986
  return store((const char *) buff, length, charset());
5987 5988
}

unknown's avatar
unknown committed
5989

unknown's avatar
unknown committed
5990 5991
uint Field::is_equal(create_field *new_field)
{
5992
  return (new_field->sql_type == real_type());
unknown's avatar
unknown committed
5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003
}


uint Field_str::is_equal(create_field *new_field)
{
  if (((new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
       !(flags & (BINCMP_FLAG | BINARY_FLAG))) ||
      (!(new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
	(flags & (BINCMP_FLAG | BINARY_FLAG))))
    return 0; /* One of the fields is binary and the other one isn't */

6004
  return ((new_field->sql_type == real_type()) &&
unknown's avatar
unknown committed
6005 6006 6007 6008 6009
	  new_field->charset == field_charset &&
	  new_field->length == max_length());
}


6010
int Field_string::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
6011
{
unknown's avatar
unknown committed
6012 6013 6014
  char buff[64];
  int  l;
  CHARSET_INFO *cs=charset();
6015 6016
  l= (cs->cset->longlong10_to_str)(cs,buff,sizeof(buff),
                                   unsigned_val ? 10 : -10, nr);
unknown's avatar
unknown committed
6017
  return Field_string::store(buff,(uint)l,cs);
unknown's avatar
unknown committed
6018 6019
}

6020

unknown's avatar
unknown committed
6021 6022
int Field_longstr::store_decimal(const my_decimal *d)
{
6023 6024
  char buff[DECIMAL_MAX_STR_LENGTH+1];
  String str(buff, sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
6025
  my_decimal2string(E_DEC_FATAL_ERROR, d, 0, 0, 0, &str);
6026
  return store(str.ptr(), str.length(), str.charset());
unknown's avatar
unknown committed
6027
}
unknown's avatar
unknown committed
6028

6029

unknown's avatar
unknown committed
6030 6031
double Field_string::val_real(void)
{
6032
  int not_used;
6033 6034 6035
  char *end_not_used;
  CHARSET_INFO *cs= charset();
  return my_strntod(cs,ptr,field_length,&end_not_used,&not_used);
unknown's avatar
unknown committed
6036 6037 6038 6039 6040
}


longlong Field_string::val_int(void)
{
6041
  int not_used;
6042
  char *end_not_used;
6043
  CHARSET_INFO *cs=charset();
6044
  return my_strntoll(cs,ptr,field_length,10,&end_not_used,&not_used);
unknown's avatar
unknown committed
6045 6046 6047 6048 6049 6050
}


String *Field_string::val_str(String *val_buffer __attribute__((unused)),
			      String *val_ptr)
{
unknown's avatar
unknown committed
6051
  uint length= field_charset->cset->lengthsp(field_charset, ptr, field_length);
6052 6053
  /* See the comment for Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
unknown's avatar
unknown committed
6054
  val_ptr->set((const char*) ptr, length, field_charset);
unknown's avatar
unknown committed
6055 6056 6057 6058
  return val_ptr;
}


unknown's avatar
unknown committed
6059 6060 6061 6062 6063 6064 6065 6066
my_decimal *Field_string::val_decimal(my_decimal *decimal_value)
{
  str2my_decimal(E_DEC_FATAL_ERROR, ptr, field_length, charset(),
                 decimal_value);
  return decimal_value;
}


unknown's avatar
unknown committed
6067 6068
int Field_string::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
6069 6070
  uint a_len, b_len;

unknown's avatar
unknown committed
6071
  if (field_charset->strxfrm_multiply > 1)
6072 6073 6074 6075 6076
  {
    /*
      We have to remove end space to be able to compare multi-byte-characters
      like in latin_de 'ae' and 0xe4
    */
6077
    return field_charset->coll->strnncollsp(field_charset,
unknown's avatar
unknown committed
6078 6079
                                            (const uchar*) a_ptr, field_length,
                                            (const uchar*) b_ptr,
6080
                                            field_length, 0);
6081
  }
unknown's avatar
unknown committed
6082 6083 6084 6085 6086 6087 6088 6089
  if (field_charset->mbmaxlen != 1)
  {
    uint char_len= field_length/field_charset->mbmaxlen;
    a_len= my_charpos(field_charset, a_ptr, a_ptr + field_length, char_len);
    b_len= my_charpos(field_charset, b_ptr, b_ptr + field_length, char_len);
  }
  else
    a_len= b_len= field_length;
6090 6091
  return my_strnncoll(field_charset,(const uchar*) a_ptr, a_len,
                                    (const uchar*) b_ptr, b_len);
unknown's avatar
unknown committed
6092 6093
}

6094

unknown's avatar
unknown committed
6095 6096
void Field_string::sort_string(char *to,uint length)
{
6097
  uint tmp=my_strnxfrm(field_charset,
6098 6099
		       (unsigned char *) to, length,
		       (unsigned char *) ptr, field_length);
6100
  DBUG_ASSERT(tmp == length);
unknown's avatar
unknown committed
6101 6102 6103 6104 6105
}


void Field_string::sql_type(String &res) const
{
6106
  THD *thd= table->in_use;
unknown's avatar
unknown committed
6107
  CHARSET_INFO *cs=res.charset();
6108 6109 6110 6111 6112 6113 6114
  ulong length;

  length= cs->cset->snprintf(cs,(char*) res.ptr(),
                             res.alloced_length(), "%s(%d)",
                             ((type() == MYSQL_TYPE_VAR_STRING &&
                               !thd->variables.new_mode) ?
                              (has_charset() ? "varchar" : "varbinary") :
6115
			      (has_charset() ? "char" : "binary")),
6116
                             (int) field_length / charset()->mbmaxlen);
6117
  res.length(length);
6118 6119
  if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
      has_charset() && (charset()->state & MY_CS_BINSORT))
6120
    res.append(STRING_WITH_LEN(" binary"));
unknown's avatar
unknown committed
6121 6122
}

6123

unknown's avatar
unknown committed
6124
char *Field_string::pack(char *to, const char *from, uint max_length)
6125
{
unknown's avatar
unknown committed
6126 6127
  uint length=      min(field_length,max_length);
  uint char_length= max_length/field_charset->mbmaxlen;
6128
  if (length > char_length)
unknown's avatar
unknown committed
6129
    char_length= my_charpos(field_charset, from, from+length, char_length);
6130
  set_if_smaller(length, char_length);
unknown's avatar
unknown committed
6131 6132
  while (length && from[length-1] == ' ')
    length--;
6133
  *to++= (char) (uchar) length;
6134
  if (field_length > 255)
6135
    *to++= (char) (uchar) (length >> 8);
6136 6137
  memcpy(to, from, length);
  return to+length;
6138 6139 6140
}


unknown's avatar
unknown committed
6141 6142
const char *Field_string::unpack(char *to, const char *from)
{
6143 6144 6145 6146 6147 6148 6149 6150
  uint length;
  if (field_length > 255)
  {
    length= uint2korr(from);
    from+= 2;
  }
  else
    length= (uint) (uchar) *from++;
unknown's avatar
unknown committed
6151 6152 6153 6154 6155 6156
  memcpy(to, from, (int) length);
  bfill(to+length, field_length - length, ' ');
  return from+length;
}


6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174
/*
  Compare two packed keys

  SYNOPSIS
    pack_cmp()
     a			New key
     b			Original key
     length		Key length
     insert_or_update	1 if this is an insert or update

  RETURN
    < 0	  a < b
    0	  a = b
    > 0   a > b
*/

int Field_string::pack_cmp(const char *a, const char *b, uint length,
                           my_bool insert_or_update)
unknown's avatar
unknown committed
6175
{
6176
  uint a_length, b_length;
6177
  if (length > 255)
6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188
  {
    a_length= uint2korr(a);
    b_length= uint2korr(b);
    a+= 2;
    b+= 2;
  }
  else
  {
    a_length= (uint) (uchar) *a++;
    b_length= (uint) (uchar) *b++;
  }
6189 6190 6191 6192
  return field_charset->coll->strnncollsp(field_charset,
                                          (const uchar*) a, a_length,
                                          (const uchar*) b, b_length,
                                          insert_or_update);
unknown's avatar
unknown committed
6193 6194 6195
}


6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212
/*
  Compare a packed key against row

  SYNOPSIS
    pack_cmp()
     key		Original key
     length		Key length. (May be less than field length)
     insert_or_update	1 if this is an insert or update

  RETURN
    < 0	  row < key
    0	  row = key
    > 0   row > key
*/

int Field_string::pack_cmp(const char *key, uint length,
                           my_bool insert_or_update)
6213
{
6214 6215 6216
  uint row_length, key_length;
  char *end;
  if (length > 255)
6217
  {
6218 6219
    key_length= uint2korr(key);
    key+= 2;
6220 6221
  }
  else
6222 6223 6224 6225
    key_length= (uint) (uchar) *key++;
  
  /* Only use 'length' of key, not field_length */
  end= ptr + length;
6226 6227
  while (end > ptr && end[-1] == ' ')
    end--;
6228 6229 6230 6231 6232 6233
  row_length= (uint) (end - ptr);

  return field_charset->coll->strnncollsp(field_charset,
                                          (const uchar*) ptr, row_length,
                                          (const uchar*) key, key_length,
                                          insert_or_update);
6234 6235 6236
}


6237
uint Field_string::packed_col_length(const char *data_ptr, uint length)
unknown's avatar
unknown committed
6238
{
6239
  if (length > 255)
6240
    return uint2korr(data_ptr)+2;
6241
  return (uint) ((uchar) *data_ptr)+1;
unknown's avatar
unknown committed
6242 6243
}

6244

unknown's avatar
unknown committed
6245 6246
uint Field_string::max_packed_col_length(uint max_length)
{
6247
  return (max_length > 255 ? 2 : 1)+max_length;
unknown's avatar
unknown committed
6248 6249 6250
}


6251 6252
Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table)
{
unknown's avatar
unknown committed
6253
  Field *field;
6254 6255 6256 6257 6258 6259 6260 6261
  if (type() != MYSQL_TYPE_VAR_STRING || table == new_table)
    return Field::new_field(root, new_table);

  /*
    Old VARCHAR field which should be modified to a VARCHAR on copy
    This is done to ensure that ALTER TABLE will convert old VARCHAR fields
    to now VARCHAR fields.
  */
unknown's avatar
unknown committed
6262 6263
  if ((field= new Field_varstring(field_length, maybe_null(), field_name,
                                  new_table->s, charset())))
6264
  {
unknown's avatar
unknown committed
6265
    field->init(new_table);
6266 6267 6268 6269 6270
    /*
      delayed_insert::get_local_table() needs a ptr copied from old table.
      This is what other new_field() methods do too. The above method of
      Field_varstring sets ptr to NULL.
    */
unknown's avatar
unknown committed
6271 6272 6273
    field->ptr= ptr;
    field->null_ptr= null_ptr;
    field->null_bit= null_bit;
6274
  }
unknown's avatar
unknown committed
6275
  return field;
6276 6277
}

unknown's avatar
unknown committed
6278

unknown's avatar
unknown committed
6279
/****************************************************************************
6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292
  VARCHAR type
  Data in field->ptr is stored as:
    1 or 2 bytes length-prefix-header  (from Field_varstring::length_bytes)
    data

  NOTE:
  When VARCHAR is stored in a key (for handler::index_read() etc) it's always
  stored with a 2 byte prefix. (Just like blob keys).

  Normally length_bytes is calculated as (field_length < 256 : 1 ? 2)
  The exception is if there is a prefix key field that is part of a long
  VARCHAR, in which case field_length for this may be 1 but the length_bytes
  is 2.
unknown's avatar
unknown committed
6293 6294 6295
****************************************************************************/


unknown's avatar
unknown committed
6296
int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
6297
{
6298
  uint32 not_used, copy_length;
unknown's avatar
unknown committed
6299
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
6300
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
6301
  int error_code= 0, well_formed_error;
unknown's avatar
unknown committed
6302
  enum MYSQL_ERROR::enum_warning_level level= MYSQL_ERROR::WARN_LEVEL_WARN;
unknown's avatar
unknown committed
6303

unknown's avatar
unknown committed
6304
  /* Convert character set if necessary */
unknown's avatar
unknown committed
6305
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
6306
  { 
6307 6308
    uint conv_errors;
    tmpstr.copy(from, length, cs, field_charset, &conv_errors);
unknown's avatar
unknown committed
6309 6310
    from= tmpstr.ptr();
    length=  tmpstr.length();
6311
    if (conv_errors)
unknown's avatar
unknown committed
6312
      error_code= WARN_DATA_TRUNCATED;
unknown's avatar
unknown committed
6313
  }
6314 6315 6316 6317 6318 6319 6320
  /* 
    Make sure we don't break a multibyte sequence
    as well as don't copy a malformed data.
  */
  copy_length= field_charset->cset->well_formed_len(field_charset,
						    from,from+length,
						    field_length/
unknown's avatar
unknown committed
6321 6322
						    field_charset->mbmaxlen,
                                                    &well_formed_error);
6323
  memmove(ptr + length_bytes, from, copy_length);
6324 6325 6326 6327
  if (length_bytes == 1)
    *ptr= (uchar) copy_length;
  else
    int2store(ptr, copy_length);
6328 6329

  // Check if we lost something other than just trailing spaces
unknown's avatar
unknown committed
6330 6331
  if ((copy_length < length) && table->in_use->count_cuted_fields &&
      !error_code)
6332
  {
6333 6334 6335 6336 6337 6338 6339 6340 6341
    if (!binary())
    {
      const char *end= from + length;
      from+= copy_length;
      from+= field_charset->cset->scan(field_charset, from, end, MY_SEQ_SPACES);
      /* If we lost only spaces then produce a NOTE, not a WARNING */
      if (from == end)
        level= MYSQL_ERROR::WARN_LEVEL_NOTE;
    }
unknown's avatar
unknown committed
6342
    error_code= WARN_DATA_TRUNCATED;
6343
  }
unknown's avatar
unknown committed
6344
  if (error_code)
6345
  {
unknown's avatar
unknown committed
6346 6347 6348 6349
    if (level == MYSQL_ERROR::WARN_LEVEL_WARN &&
        table->in_use->abort_on_warning)
      error_code= ER_DATA_TOO_LONG;
    set_warning(level, error_code, 1);
unknown's avatar
unknown committed
6350
    return 2;
6351
  }
unknown's avatar
unknown committed
6352
  return 0;
unknown's avatar
unknown committed
6353 6354 6355
}


6356
int Field_varstring::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
6357
{
unknown's avatar
unknown committed
6358
  char buff[64];
6359 6360 6361 6362
  uint  length;
  length= (uint) (field_charset->cset->longlong10_to_str)(field_charset,
                                                          buff,
                                                          sizeof(buff),
6363 6364 6365
                                                          (unsigned_val ? 10:
                                                           -10),
                                                           nr);
6366
  return Field_varstring::store(buff, length, field_charset);
unknown's avatar
unknown committed
6367 6368 6369 6370 6371
}


double Field_varstring::val_real(void)
{
6372
  int not_used;
6373
  char *end_not_used;
6374
  uint length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
6375
  return my_strntod(field_charset, ptr+length_bytes, length, &end_not_used,
6376
                    &not_used);
unknown's avatar
unknown committed
6377 6378 6379 6380 6381
}


longlong Field_varstring::val_int(void)
{
6382
  int not_used;
6383
  char *end_not_used;
6384
  uint length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
6385 6386
  return my_strntoll(field_charset, ptr+length_bytes, length, 10,
                     &end_not_used, &not_used);
unknown's avatar
unknown committed
6387 6388 6389 6390 6391
}

String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
				 String *val_ptr)
{
6392 6393
  uint length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
  val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
unknown's avatar
unknown committed
6394 6395 6396 6397
  return val_ptr;
}


unknown's avatar
unknown committed
6398 6399 6400 6401 6402 6403 6404 6405 6406
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
{
  uint length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
  str2my_decimal(E_DEC_FATAL_ERROR, ptr+length_bytes, length, charset(),
                 decimal_value);
  return decimal_value;
}


6407 6408
int Field_varstring::cmp_max(const char *a_ptr, const char *b_ptr,
                             uint max_len)
unknown's avatar
unknown committed
6409
{
6410
  uint a_length, b_length;
unknown's avatar
unknown committed
6411
  int diff;
6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422

  if (length_bytes == 1)
  {
    a_length= (uint) (uchar) *a_ptr;
    b_length= (uint) (uchar) *b_ptr;
  }
  else
  {
    a_length= uint2korr(a_ptr);
    b_length= uint2korr(b_ptr);
  }
6423 6424
  set_if_smaller(a_length, max_len);
  set_if_smaller(b_length, max_len);
6425 6426
  diff= field_charset->coll->strnncollsp(field_charset,
                                         (const uchar*) a_ptr+
6427
                                         length_bytes,
6428 6429
                                         a_length,
                                         (const uchar*) b_ptr+
6430
                                         length_bytes,
6431 6432
                                         b_length,0);
  return diff;
unknown's avatar
unknown committed
6433 6434
}

6435

6436 6437 6438 6439
/*
  NOTE: varstring and blob keys are ALWAYS stored with a 2 byte length prefix
*/

6440 6441
int Field_varstring::key_cmp(const byte *key_ptr, uint max_key_length)
{
6442 6443
  uint length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
  uint char_length= max_key_length / field_charset->mbmaxlen;
6444

6445 6446
  char_length= my_charpos(field_charset, ptr + length_bytes,
                          ptr + length_bytes + length, char_length);
6447
  set_if_smaller(length, char_length);
6448 6449 6450 6451 6452 6453
  return field_charset->coll->strnncollsp(field_charset, 
                                          (const uchar*) ptr + length_bytes,
                                          length,
                                          (const uchar*) key_ptr+
                                          HA_KEY_BLOB_LENGTH,
                                          uint2korr(key_ptr), 0);
unknown's avatar
unknown committed
6454 6455
}

6456

6457 6458 6459 6460 6461 6462 6463 6464
/*
  Compare to key segments (always 2 byte length prefix)

  NOTE
    This is used only to compare key segments created for index_read().
    (keys are created and compared in key.cc)
*/

6465 6466
int Field_varstring::key_cmp(const byte *a,const byte *b)
{
6467 6468 6469 6470 6471 6472 6473 6474
  return field_charset->coll->strnncollsp(field_charset,
                                          (const uchar*) a +
                                          HA_KEY_BLOB_LENGTH,
                                          uint2korr(a),
                                          (const uchar*) b +
                                          HA_KEY_BLOB_LENGTH,
                                          uint2korr(b),
                                          0);
6475 6476 6477
}


unknown's avatar
unknown committed
6478 6479
void Field_varstring::sort_string(char *to,uint length)
{
6480
  uint tot_length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491

  if (field_charset == &my_charset_bin)
  {
    /* Store length last in high-byte order to sort longer strings first */
    if (length_bytes == 1)
      to[length-1]= tot_length;
    else
      mi_int2store(to+length-2, tot_length);
    length-= length_bytes;
  }
 
6492 6493
  tot_length= my_strnxfrm(field_charset,
			  (uchar*) to, length,
6494
			  (uchar*) ptr + length_bytes,
6495
			  tot_length);
unknown's avatar
unknown committed
6496
  DBUG_ASSERT(tot_length == length);
unknown's avatar
unknown committed
6497 6498 6499
}


6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511
enum ha_base_keytype Field_varstring::key_type() const
{
  enum ha_base_keytype res;

  if (binary())
    res= length_bytes == 1 ? HA_KEYTYPE_VARBINARY1 : HA_KEYTYPE_VARBINARY2;
  else
    res= length_bytes == 1 ? HA_KEYTYPE_VARTEXT1 : HA_KEYTYPE_VARTEXT2;
  return res;
}


unknown's avatar
unknown committed
6512 6513
void Field_varstring::sql_type(String &res) const
{
6514
  THD *thd= table->in_use;
unknown's avatar
unknown committed
6515
  CHARSET_INFO *cs=res.charset();
6516 6517 6518 6519 6520 6521
  ulong length;

  length= cs->cset->snprintf(cs,(char*) res.ptr(),
                             res.alloced_length(), "%s(%d)",
                              (has_charset() ? "varchar" : "varbinary"),
                             (int) field_length / charset()->mbmaxlen);
6522
  res.length(length);
6523 6524
  if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
      has_charset() && (charset()->state & MY_CS_BINSORT))
6525
    res.append(STRING_WITH_LEN(" binary"));
unknown's avatar
unknown committed
6526 6527
}

6528

6529 6530 6531 6532 6533
/*
  Functions to create a packed row.
  Here the number of length bytes are depending on the given max_length
*/

unknown's avatar
unknown committed
6534 6535
char *Field_varstring::pack(char *to, const char *from, uint max_length)
{
6536
  uint length= length_bytes == 1 ? (uint) (uchar) *from : uint2korr(from);
6537
  set_if_smaller(max_length, field_length);
unknown's avatar
unknown committed
6538 6539
  if (length > max_length)
    length=max_length;
unknown's avatar
unknown committed
6540
  *to++= (char) (length & 255);
unknown's avatar
unknown committed
6541
  if (max_length > 255)
unknown's avatar
unknown committed
6542
    *to++= (char) (length >> 8);
unknown's avatar
unknown committed
6543
  if (length)
6544
    memcpy(to, from+length_bytes, length);
unknown's avatar
unknown committed
6545 6546 6547 6548
  return to+length;
}


6549
char *Field_varstring::pack_key(char *to, const char *key, uint max_length)
6550
{
6551
  uint length=  length_bytes == 1 ? (uint) (uchar) *key : uint2korr(key);
6552 6553
  uint char_length= ((field_charset->mbmaxlen > 1) ?
                     max_length/field_charset->mbmaxlen : max_length);
6554
  key+= length_bytes;
6555
  if (length > char_length)
6556
  {
6557
    char_length= my_charpos(field_charset, key, key+length, char_length);
6558 6559
    set_if_smaller(length, char_length);
  }
6560 6561 6562 6563
  *to++= (char) (length & 255);
  if (max_length > 255)
    *to++= (char) (length >> 8);
  if (length)
6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628
    memcpy(to, key, length);
  return to+length;
}


/*
  Unpack a key into a record buffer.

  SYNOPSIS
    unpack_key()
    to                          Pointer into the record buffer.
    key                         Pointer to the packed key.
    max_length                  Key length limit from key description.

  DESCRIPTION
    A VARCHAR key has a maximum size of 64K-1.
    In its packed form, the length field is one or two bytes long,
    depending on 'max_length'.

  RETURN
    Pointer to end of 'key' (To the next key part if multi-segment key)
*/

const char *Field_varstring::unpack_key(char *to, const char *key,
                                      uint max_length)
{
  /* get length of the blob key */
  uint32 length= *((uchar*) key++);
  if (max_length > 255)
    length+= (*((uchar*) key++)) << 8;

  /* put the length into the record buffer */
  if (length_bytes == 1)
    *ptr= (uchar) length;
  else
    int2store(ptr, length);
  memcpy(ptr + length_bytes, key, length);
  return key + length;
}

/*
  Create a packed key that will be used for storage in the index tree

  SYNOPSIS
    pack_key_from_key_image()
    to			Store packed key segment here
    from		Key segment (as given to index_read())
    max_length  	Max length of key

  RETURN
    end of key storage
*/

char *Field_varstring::pack_key_from_key_image(char *to, const char *from,
                                               uint max_length)
{
  /* Key length is always stored as 2 bytes */
  uint length= uint2korr(from);
  if (length > max_length)
    length= max_length;
  *to++= (char) (length & 255);
  if (max_length > 255)
    *to++= (char) (length >> 8);
  if (length)
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
6629 6630 6631 6632
  return to+length;
}


6633 6634 6635 6636
/*
  unpack field packed with Field_varstring::pack()
*/

unknown's avatar
unknown committed
6637 6638 6639
const char *Field_varstring::unpack(char *to, const char *from)
{
  uint length;
6640
  if (length_bytes == 1)
unknown's avatar
unknown committed
6641 6642 6643
    length= (uint) (uchar) (*to= *from++);
  else
  {
6644 6645 6646
    length= uint2korr(from);
    to[0]= *from++;
    to[1]= *from++;
unknown's avatar
unknown committed
6647 6648
  }
  if (length)
6649
    memcpy(to+ length_bytes, from, length);
unknown's avatar
unknown committed
6650 6651 6652 6653
  return from+length;
}


6654 6655
int Field_varstring::pack_cmp(const char *a, const char *b, uint key_length,
                              my_bool insert_or_update)
unknown's avatar
unknown committed
6656
{
6657
  uint a_length, b_length;
unknown's avatar
unknown committed
6658 6659
  if (key_length > 255)
  {
6660 6661
    a_length=uint2korr(a); a+= 2;
    b_length=uint2korr(b); b+= 2;
unknown's avatar
unknown committed
6662 6663 6664 6665 6666 6667
  }
  else
  {
    a_length= (uint) (uchar) *a++;
    b_length= (uint) (uchar) *b++;
  }
6668 6669 6670 6671
  return field_charset->coll->strnncollsp(field_charset,
                                          (const uchar*) a, a_length,
                                          (const uchar*) b, b_length,
                                          insert_or_update);
unknown's avatar
unknown committed
6672 6673
}

6674 6675 6676

int Field_varstring::pack_cmp(const char *b, uint key_length,
                              my_bool insert_or_update)
6677
{
6678 6679
  char *a= ptr+ length_bytes;
  uint a_length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
6680
  uint b_length;
6681 6682 6683
  uint char_length= ((field_charset->mbmaxlen > 1) ?
                     key_length / field_charset->mbmaxlen : key_length);

6684 6685
  if (key_length > 255)
  {
6686
    b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
6687 6688 6689
  }
  else
    b_length= (uint) (uchar) *b++;
6690 6691 6692 6693 6694

  if (a_length > char_length)
  {
    char_length= my_charpos(field_charset, a, a+a_length, char_length);
    set_if_smaller(a_length, char_length);
6695
  }
6696 6697 6698 6699 6700 6701

  return field_charset->coll->strnncollsp(field_charset,
                                          (const uchar*) a,
                                          a_length,
                                          (const uchar*) b, b_length,
                                          insert_or_update);
6702 6703
}

6704

6705
uint Field_varstring::packed_col_length(const char *data_ptr, uint length)
unknown's avatar
unknown committed
6706
{
6707
  if (length > 255)
6708
    return uint2korr(data_ptr)+2;
6709
  return (uint) ((uchar) *data_ptr)+1;
unknown's avatar
unknown committed
6710 6711
}

6712

unknown's avatar
unknown committed
6713 6714
uint Field_varstring::max_packed_col_length(uint max_length)
{
6715
  return (max_length > 255 ? 2 : 1)+max_length;
unknown's avatar
unknown committed
6716 6717
}

6718 6719

void Field_varstring::get_key_image(char *buff, uint length, imagetype type)
6720
{
6721
  uint f_length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
6722
  uint char_length= length / field_charset->mbmaxlen;
6723 6724
  char *pos= ptr+length_bytes;
  char_length= my_charpos(field_charset, pos, pos + f_length, char_length);
6725
  set_if_smaller(f_length, char_length);
6726
  /* Key is always stored with 2 bytes */
6727
  int2store(buff,f_length);
6728
  memcpy(buff+HA_KEY_BLOB_LENGTH, pos, f_length);
6729
  if (f_length < length)
6730 6731 6732 6733 6734
  {
    /*
      Must clear this as we do a memcmp in opt_range.cc to detect
      identical keys
    */
6735
    bzero(buff+HA_KEY_BLOB_LENGTH+f_length, (length-f_length));
6736
  }
6737 6738
}

6739 6740

void Field_varstring::set_key_image(char *buff,uint length)
6741
{
6742
  length= uint2korr(buff);			// Real length is here
6743 6744
  (void) Field_varstring::store(buff+HA_KEY_BLOB_LENGTH, length,
                                field_charset);
6745 6746 6747
}


6748 6749 6750 6751 6752
int Field_varstring::cmp_binary(const char *a_ptr, const char *b_ptr,
                                uint32 max_length)
{
  uint32 a_length,b_length;

6753 6754 6755 6756 6757 6758 6759 6760 6761 6762
  if (length_bytes == 1)
  {
    a_length= (uint) (uchar) *a_ptr;
    b_length= (uint) (uchar) *b_ptr;
  }
  else
  {
    a_length= uint2korr(a_ptr);
    b_length= uint2korr(b_ptr);
  }
6763 6764 6765 6766
  set_if_smaller(a_length, max_length);
  set_if_smaller(b_length, max_length);
  if (a_length != b_length)
    return 1;
6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780
  return memcmp(a_ptr+length_bytes, b_ptr+length_bytes, a_length);
}


Field *Field_varstring::new_field(MEM_ROOT *root, struct st_table *new_table)
{
  Field_varstring *res= (Field_varstring*) Field::new_field(root, new_table);
  if (res)
    res->length_bytes= length_bytes;
  return res;
}


Field *Field_varstring::new_key_field(MEM_ROOT *root,
unknown's avatar
unknown committed
6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792
                                      struct st_table *new_table,
                                      char *new_ptr, uchar *new_null_ptr,
                                      uint new_null_bit)
{
  Field_varstring *res;
  if ((res= (Field_varstring*) Field::new_key_field(root,
                                                    new_table,
                                                    new_ptr,
                                                    new_null_ptr,
                                                    new_null_bit)))
  {
    /* Keys length prefixes are always packed with 2 bytes */
6793
    res->length_bytes= 2;
unknown's avatar
unknown committed
6794
  }
6795
  return res;
6796 6797
}

6798

unknown's avatar
unknown committed
6799 6800
uint Field_varstring::is_equal(create_field *new_field)
{
6801
  if (new_field->sql_type == real_type() &&
unknown's avatar
unknown committed
6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814
      new_field->charset == field_charset)
  {
    if (new_field->length == max_length())
      return IS_EQUAL_YES;
    if (new_field->length > max_length() &&
	((new_field->length <= 255 && max_length() <= 255) ||
	 (new_field->length > 255 && max_length() > 255)))
      return IS_EQUAL_PACK_LENGTH; // VARCHAR, longer variable length
  }
  return IS_EQUAL_NO;
}


unknown's avatar
unknown committed
6815 6816 6817 6818 6819 6820
/****************************************************************************
** blob type
** A blob is saved as a length and a pointer. The length is stored in the
** packlength slot and may be from 1-4.
****************************************************************************/

unknown's avatar
unknown committed
6821
Field_blob::Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
6822
		       enum utype unireg_check_arg, const char *field_name_arg,
unknown's avatar
unknown committed
6823
                       TABLE_SHARE *share, uint blob_pack_length,
6824
		       CHARSET_INFO *cs)
6825
  :Field_longstr(ptr_arg, BLOB_PACK_LENGTH_TO_MAX_LENGH(blob_pack_length),
unknown's avatar
unknown committed
6826 6827
                 null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
                 cs),
unknown's avatar
unknown committed
6828
   packlength(blob_pack_length)
unknown's avatar
unknown committed
6829 6830
{
  flags|= BLOB_FLAG;
unknown's avatar
unknown committed
6831
  share->blob_fields++;
6832
  /* TODO: why do not fill table->s->blob_field array here? */
unknown's avatar
unknown committed
6833 6834 6835
}


unknown's avatar
unknown committed
6836
void Field_blob::store_length(uint32 number)
unknown's avatar
unknown committed
6837 6838 6839 6840 6841 6842 6843
{
  switch (packlength) {
  case 1:
    ptr[0]= (uchar) number;
    break;
  case 2:
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
6844
    if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856
    {
      int2store(ptr,(unsigned short) number);
    }
    else
#endif
      shortstore(ptr,(unsigned short) number);
    break;
  case 3:
    int3store(ptr,number);
    break;
  case 4:
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
6857
    if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
6858 6859 6860 6861 6862 6863 6864 6865 6866 6867
    {
      int4store(ptr,number);
    }
    else
#endif
      longstore(ptr,number);
  }
}


unknown's avatar
unknown committed
6868
uint32 Field_blob::get_length(const char *pos)
unknown's avatar
unknown committed
6869 6870 6871
{
  switch (packlength) {
  case 1:
unknown's avatar
unknown committed
6872
    return (uint32) (uchar) pos[0];
unknown's avatar
unknown committed
6873 6874 6875 6876
  case 2:
    {
      uint16 tmp;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
6877
      if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
6878 6879 6880 6881
	tmp=sint2korr(pos);
      else
#endif
	shortget(tmp,pos);
unknown's avatar
unknown committed
6882
      return (uint32) tmp;
unknown's avatar
unknown committed
6883 6884
    }
  case 3:
unknown's avatar
unknown committed
6885
    return (uint32) uint3korr(pos);
unknown's avatar
unknown committed
6886 6887 6888 6889
  case 4:
    {
      uint32 tmp;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
6890
      if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
6891 6892 6893 6894
	tmp=uint4korr(pos);
      else
#endif
	longget(tmp,pos);
unknown's avatar
unknown committed
6895
      return (uint32) tmp;
unknown's avatar
unknown committed
6896 6897 6898 6899 6900 6901
    }
  }
  return 0;					// Impossible
}


6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937
/*
  Put a blob length field into a record buffer.

  SYNOPSIS
    Field_blob::put_length()
    pos                         Pointer into the record buffer.
    length                      The length value to put.

  DESCRIPTION
    Depending on the maximum length of a blob, its length field is
    put into 1 to 4 bytes. This is a property of the blob object,
    described by 'packlength'.

  RETURN
    nothing
*/

void Field_blob::put_length(char *pos, uint32 length)
{
  switch (packlength) {
  case 1:
    *pos= (char) length;
    break;
  case 2:
    int2store(pos, length);
    break;
  case 3:
    int3store(pos, length);
    break;
  case 4:
    int4store(pos, length);
    break;
  }
}


unknown's avatar
unknown committed
6938
int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
6939
{
6940
  int error= 0, well_formed_error;
unknown's avatar
unknown committed
6941
  if (!length)
unknown's avatar
unknown committed
6942 6943 6944 6945 6946
  {
    bzero(ptr,Field_blob::pack_length());
  }
  else
  {
unknown's avatar
unknown committed
6947
    bool was_conversion;
unknown's avatar
unknown committed
6948
    char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
6949
    String tmpstr(buff,sizeof(buff), &my_charset_bin);
6950
    uint copy_length;
unknown's avatar
unknown committed
6951
    uint32 not_used;
unknown's avatar
unknown committed
6952

unknown's avatar
unknown committed
6953
    /* Convert character set if necessary */
unknown's avatar
unknown committed
6954 6955
    if ((was_conversion= String::needs_conversion(length, cs, field_charset,
						  &not_used)))
unknown's avatar
unknown committed
6956
    { 
6957
      uint conv_errors;
unknown's avatar
unknown committed
6958 6959 6960 6961 6962 6963
      if (tmpstr.copy(from, length, cs, field_charset, &conv_errors))
      {
        /* Fatal OOM error */
        bzero(ptr,Field_blob::pack_length());
        return -1;
      }
unknown's avatar
unknown committed
6964 6965
      from= tmpstr.ptr();
      length=  tmpstr.length();
6966
      if (conv_errors)
unknown's avatar
unknown committed
6967
        error= 2;
unknown's avatar
unknown committed
6968
    }
6969 6970
    
    copy_length= max_data_length();
6971
    /*
unknown's avatar
unknown committed
6972
      copy_length is OK as last argument to well_formed_len as this is never
6973 6974 6975 6976
      used to limit the length of the data. The cut of long data is done with
      the 'min()' call below.
    */
    copy_length= field_charset->cset->well_formed_len(field_charset,
6977 6978 6979
                                                      from,from +
                                                      min(length, copy_length),
                                                      copy_length,
6980
                                                      &well_formed_error);
6981
    if (copy_length < length)
unknown's avatar
unknown committed
6982
      error= 2;
6983 6984
    Field_blob::store_length(copy_length);
    if (was_conversion || table->copy_blobs || copy_length <= MAX_FIELD_WIDTH)
unknown's avatar
unknown committed
6985
    {						// Must make a copy
unknown's avatar
unknown committed
6986 6987
      if (from != value.ptr())			// For valgrind
      {
6988
	value.copy(from,copy_length,charset());
unknown's avatar
unknown committed
6989
	from=value.ptr();
unknown's avatar
unknown committed
6990
      }
unknown's avatar
unknown committed
6991 6992 6993
    }
    bmove(ptr+packlength,(char*) &from,sizeof(char*));
  }
6994
  if (error)
6995 6996 6997 6998 6999 7000
  {
    if (table->in_use->abort_on_warning)
      set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
    else
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
  }
7001
  return 0;
unknown's avatar
unknown committed
7002 7003 7004
}


unknown's avatar
unknown committed
7005
int Field_blob::store(double nr)
unknown's avatar
unknown committed
7006
{
7007 7008 7009
  CHARSET_INFO *cs=charset();
  value.set(nr, 2, cs);
  return Field_blob::store(value.ptr(),(uint) value.length(), cs);
unknown's avatar
unknown committed
7010 7011 7012
}


7013
int Field_blob::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
7014
{
7015
  CHARSET_INFO *cs=charset();
7016 7017 7018 7019
  if (unsigned_val)
    value.set((ulonglong) nr, cs);
  else
    value.set(nr, cs);
7020
  return Field_blob::store(value.ptr(), (uint) value.length(), cs);
unknown's avatar
unknown committed
7021 7022
}

7023

unknown's avatar
unknown committed
7024 7025
double Field_blob::val_real(void)
{
7026
  int not_used;
7027 7028 7029 7030
  char *end_not_used, *blob;
  uint32 length;
  CHARSET_INFO *cs;

unknown's avatar
unknown committed
7031 7032 7033
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
    return 0.0;
7034 7035
  length= get_length(ptr);
  cs= charset();
unknown's avatar
unknown committed
7036
  return my_strntod(cs, blob, length, &end_not_used, &not_used);
unknown's avatar
unknown committed
7037 7038 7039 7040 7041
}


longlong Field_blob::val_int(void)
{
7042
  int not_used;
unknown's avatar
unknown committed
7043 7044 7045 7046
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
    return 0;
unknown's avatar
unknown committed
7047
  uint32 length=get_length(ptr);
7048
  return my_strntoll(charset(),blob,length,10,NULL,&not_used);
unknown's avatar
unknown committed
7049 7050 7051 7052 7053 7054 7055 7056
}

String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
			    String *val_ptr)
{
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
7057
    val_ptr->set("",0,charset());	// A bit safer than ->length(0)
unknown's avatar
unknown committed
7058
  else
7059
    val_ptr->set((const char*) blob,get_length(ptr),charset());
unknown's avatar
unknown committed
7060 7061 7062 7063
  return val_ptr;
}


unknown's avatar
unknown committed
7064 7065
my_decimal *Field_blob::val_decimal(my_decimal *decimal_value)
{
7066 7067
  const char *blob;
  memcpy_fixed(&blob, ptr+packlength, sizeof(const char*));
unknown's avatar
unknown committed
7068 7069 7070 7071 7072 7073 7074 7075
  if (!blob)
    blob= "";
  str2my_decimal(E_DEC_FATAL_ERROR, blob, get_length(ptr), charset(),
                 decimal_value);
  return decimal_value;
}


unknown's avatar
unknown committed
7076 7077
int Field_blob::cmp(const char *a,uint32 a_length, const char *b,
		    uint32 b_length)
unknown's avatar
unknown committed
7078
{
7079 7080 7081 7082
  return field_charset->coll->strnncollsp(field_charset, 
                                          (const uchar*)a, a_length,
                                          (const uchar*)b, b_length,
                                          0);
unknown's avatar
unknown committed
7083 7084 7085
}


7086 7087
int Field_blob::cmp_max(const char *a_ptr, const char *b_ptr,
                        uint max_length)
unknown's avatar
unknown committed
7088 7089 7090 7091
{
  char *blob1,*blob2;
  memcpy_fixed(&blob1,a_ptr+packlength,sizeof(char*));
  memcpy_fixed(&blob2,b_ptr+packlength,sizeof(char*));
7092 7093 7094 7095
  uint a_len= get_length(a_ptr), b_len= get_length(b_ptr);
  set_if_smaller(a_len, max_length);
  set_if_smaller(b_len, max_length);
  return Field_blob::cmp(blob1,a_len,blob2,b_len);
unknown's avatar
unknown committed
7096 7097 7098 7099
}


int Field_blob::cmp_binary(const char *a_ptr, const char *b_ptr,
unknown's avatar
unknown committed
7100
			   uint32 max_length)
unknown's avatar
unknown committed
7101 7102 7103
{
  char *a,*b;
  uint diff;
unknown's avatar
unknown committed
7104
  uint32 a_length,b_length;
unknown's avatar
unknown committed
7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119
  memcpy_fixed(&a,a_ptr+packlength,sizeof(char*));
  memcpy_fixed(&b,b_ptr+packlength,sizeof(char*));
  a_length=get_length(a_ptr);
  if (a_length > max_length)
    a_length=max_length;
  b_length=get_length(b_ptr);
  if (b_length > max_length)
    b_length=max_length;
  diff=memcmp(a,b,min(a_length,b_length));
  return diff ? diff : (int) (a_length - b_length);
}


/* The following is used only when comparing a key */

7120
void Field_blob::get_key_image(char *buff, uint length, imagetype type)
unknown's avatar
unknown committed
7121
{
unknown's avatar
unknown committed
7122
  uint32 blob_length= get_length(ptr);
unknown's avatar
unknown committed
7123
  char *blob;
unknown's avatar
unknown committed
7124

unknown's avatar
unknown committed
7125
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
7126
  if (type == itMBR)
unknown's avatar
unknown committed
7127
  {
unknown's avatar
unknown committed
7128
    const char *dummy;
unknown's avatar
unknown committed
7129
    MBR mbr;
7130 7131
    Geometry_buffer buffer;
    Geometry *gobj;
unknown's avatar
unknown committed
7132 7133 7134 7135 7136 7137 7138

    if (blob_length < SRID_SIZE)
    {
      bzero(buff, SIZEOF_STORED_DOUBLE*4);
      return;
    }
    get_ptr(&blob);
unknown's avatar
unknown committed
7139
    gobj= Geometry::construct(&buffer, blob, blob_length);
7140
    if (!gobj || gobj->get_mbr(&mbr, &dummy))
unknown's avatar
unknown committed
7141 7142 7143 7144 7145 7146 7147 7148
      bzero(buff, SIZEOF_STORED_DOUBLE*4);
    else
    {
      float8store(buff,    mbr.xmin);
      float8store(buff+8,  mbr.xmax);
      float8store(buff+16, mbr.ymin);
      float8store(buff+24, mbr.ymax);
    }
unknown's avatar
unknown committed
7149 7150
    return;
  }
unknown's avatar
unknown committed
7151
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
7152

7153
  get_ptr(&blob);
7154 7155 7156
  uint char_length= length / field_charset->mbmaxlen;
  char_length= my_charpos(field_charset, blob, blob + blob_length,
                          char_length);
7157
  set_if_smaller(blob_length, char_length);
7158

unknown's avatar
unknown committed
7159
  if ((uint32) length > blob_length)
unknown's avatar
unknown committed
7160
  {
7161 7162 7163 7164
    /*
      Must clear this as we do a memcmp in opt_range.cc to detect
      identical keys
    */
7165
    bzero(buff+HA_KEY_BLOB_LENGTH+blob_length, (length-blob_length));
unknown's avatar
unknown committed
7166
    length=(uint) blob_length;
unknown's avatar
unknown committed
7167
  }
unknown's avatar
unknown committed
7168
  int2store(buff,length);
7169
  memcpy(buff+HA_KEY_BLOB_LENGTH, blob, length);
unknown's avatar
unknown committed
7170 7171
}

7172 7173

void Field_blob::set_key_image(char *buff,uint length)
unknown's avatar
unknown committed
7174
{
7175
  length= uint2korr(buff);
7176
  (void) Field_blob::store(buff+HA_KEY_BLOB_LENGTH, length, field_charset);
unknown's avatar
unknown committed
7177 7178
}

unknown's avatar
unknown committed
7179

unknown's avatar
unknown committed
7180 7181 7182 7183 7184
int Field_blob::key_cmp(const byte *key_ptr, uint max_key_length)
{
  char *blob1;
  uint blob_length=get_length(ptr);
  memcpy_fixed(&blob1,ptr+packlength,sizeof(char*));
7185 7186 7187 7188
  CHARSET_INFO *cs= charset();
  uint char_length= max_key_length / cs->mbmaxlen;
  char_length= my_charpos(cs, blob1, blob1+blob_length, char_length);
  set_if_smaller(blob_length, char_length);
7189
  return Field_blob::cmp(blob1, blob_length,
7190 7191
			 (char*) key_ptr+HA_KEY_BLOB_LENGTH,
			 uint2korr(key_ptr));
unknown's avatar
unknown committed
7192 7193 7194 7195
}

int Field_blob::key_cmp(const byte *a,const byte *b)
{
7196 7197
  return Field_blob::cmp((char*) a+HA_KEY_BLOB_LENGTH, uint2korr(a),
			 (char*) b+HA_KEY_BLOB_LENGTH, uint2korr(b));
unknown's avatar
unknown committed
7198 7199 7200
}


7201 7202 7203 7204 7205 7206 7207
uint32 Field_blob::sort_length() const
{
  return (uint32) (current_thd->variables.max_sort_length + 
                   (field_charset == &my_charset_bin ? 0 : packlength));
}


unknown's avatar
unknown committed
7208 7209 7210 7211
void Field_blob::sort_string(char *to,uint length)
{
  char *blob;
  uint blob_length=get_length();
unknown's avatar
unknown committed
7212

unknown's avatar
unknown committed
7213 7214 7215 7216
  if (!blob_length)
    bzero(to,length);
  else
  {
7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241
    if (field_charset == &my_charset_bin)
    {
      char *pos;

      /*
        Store length of blob last in blob to shorter blobs before longer blobs
      */
      length-= packlength;
      pos= to+length;

      switch (packlength) {
      case 1:
        *pos= (char) blob_length;
        break;
      case 2:
        mi_int2store(pos, blob_length);
        break;
      case 3:
        mi_int3store(pos, blob_length);
        break;
      case 4:
        mi_int4store(pos, blob_length);
        break;
      }
    }
unknown's avatar
unknown committed
7242
    memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
unknown's avatar
unknown committed
7243 7244
    
    blob_length=my_strnxfrm(field_charset,
7245 7246
                            (uchar*) to, length, 
                            (uchar*) blob, blob_length);
7247
    DBUG_ASSERT(blob_length == length);
unknown's avatar
unknown committed
7248 7249 7250 7251 7252 7253 7254
  }
}


void Field_blob::sql_type(String &res) const
{
  const char *str;
7255
  uint length;
unknown's avatar
unknown committed
7256
  switch (packlength) {
7257 7258 7259 7260 7261
  default: str="tiny"; length=4; break;
  case 2:  str="";     length=0; break;
  case 3:  str="medium"; length= 6; break;
  case 4:  str="long";  length=4; break;
  }
7262
  res.set_ascii(str,length);
7263
  if (charset() == &my_charset_bin)
7264
    res.append(STRING_WITH_LEN("blob"));
7265 7266
  else
  {
7267
    res.append(STRING_WITH_LEN("text"));
unknown's avatar
unknown committed
7268 7269 7270 7271
  }
}


7272 7273 7274 7275
char *Field_blob::pack(char *to, const char *from, uint max_length)
{
  char *save=ptr;
  ptr=(char*) from;
unknown's avatar
unknown committed
7276
  uint32 length=get_length();			// Length of from string
7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298
  if (length > max_length)
  {
    ptr=to;
    length=max_length;
    store_length(length);			// Store max length
    ptr=(char*) from;
  }
  else
    memcpy(to,from,packlength);			// Copy length
  if (length)
  {
    get_ptr((char**) &from);
    memcpy(to+packlength, from,length);
  }
  ptr=save;					// Restore org row pointer
  return to+packlength+length;
}


const char *Field_blob::unpack(char *to, const char *from)
{
  memcpy(to,from,packlength);
unknown's avatar
unknown committed
7299
  uint32 length=get_length(from);
7300 7301 7302 7303 7304 7305 7306 7307
  from+=packlength;
  if (length)
    memcpy_fixed(to+packlength, &from, sizeof(from));
  else
    bzero(to+packlength,sizeof(from));
  return from+length;
}

unknown's avatar
unknown committed
7308 7309
/* Keys for blobs are like keys on varchars */

7310 7311
int Field_blob::pack_cmp(const char *a, const char *b, uint key_length,
                         my_bool insert_or_update)
unknown's avatar
unknown committed
7312
{
7313
  uint a_length, b_length;
unknown's avatar
unknown committed
7314 7315 7316 7317 7318 7319 7320 7321 7322 7323
  if (key_length > 255)
  {
    a_length=uint2korr(a); a+=2;
    b_length=uint2korr(b); b+=2;
  }
  else
  {
    a_length= (uint) (uchar) *a++;
    b_length= (uint) (uchar) *b++;
  }
7324 7325 7326 7327
  return field_charset->coll->strnncollsp(field_charset,
                                          (const uchar*) a, a_length,
                                          (const uchar*) b, b_length,
                                          insert_or_update);
unknown's avatar
unknown committed
7328 7329
}

7330

7331 7332
int Field_blob::pack_cmp(const char *b, uint key_length,
                         my_bool insert_or_update)
7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346
{
  char *a;
  memcpy_fixed(&a,ptr+packlength,sizeof(char*));
  if (!a)
    return key_length > 0 ? -1 : 0;
  uint a_length=get_length(ptr);
  uint b_length;

  if (key_length > 255)
  {
    b_length=uint2korr(b); b+=2;
  }
  else
    b_length= (uint) (uchar) *b++;
7347 7348 7349 7350
  return field_charset->coll->strnncollsp(field_charset,
                                          (const uchar*) a, a_length,
                                          (const uchar*) b, b_length,
                                          insert_or_update);
7351 7352
}

7353
/* Create a packed key that will be used for storage from a MySQL row */
7354

unknown's avatar
unknown committed
7355 7356
char *Field_blob::pack_key(char *to, const char *from, uint max_length)
{
7357 7358
  char *save=ptr;
  ptr=(char*) from;
unknown's avatar
unknown committed
7359
  uint32 length=get_length();			// Length of from string
7360 7361
  uint char_length= ((field_charset->mbmaxlen > 1) ?
                     max_length/field_charset->mbmaxlen : max_length);
7362 7363 7364 7365 7366
  if (length)
    get_ptr((char**) &from);
  if (length > char_length)
    char_length= my_charpos(field_charset, from, from+length, char_length);
  set_if_smaller(length, char_length);
7367 7368 7369
  *to++= (uchar) length;
  if (max_length > 255)				// 2 byte length
    *to++= (uchar) (length >> 8);
7370
  memcpy(to, from, length);
7371 7372 7373 7374
  ptr=save;					// Restore org row pointer
  return to+length;
}

7375 7376 7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387 7388 7389 7390 7391 7392 7393 7394 7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411 7412 7413 7414 7415 7416 7417 7418

/*
  Unpack a blob key into a record buffer.

  SYNOPSIS
    Field_blob::unpack_key()
    to                          Pointer into the record buffer.
    from                        Pointer to the packed key.
    max_length                  Key length limit from key description.

  DESCRIPTION
    A blob key has a maximum size of 64K-1.
    In its packed form, the length field is one or two bytes long,
    depending on 'max_length'.
    Depending on the maximum length of a blob, its length field is
    put into 1 to 4 bytes. This is a property of the blob object,
    described by 'packlength'.
    Blobs are internally stored apart from the record buffer, which
    contains a pointer to the blob buffer.

  RETURN
    Pointer into 'from' past the last byte copied from packed key.
*/

const char *Field_blob::unpack_key(char *to, const char *from, uint max_length)
{
  /* get length of the blob key */
  uint32 length= *((uchar*) from++);
  if (max_length > 255)
    length+= (*((uchar*) from++)) << 8;

  /* put the length into the record buffer */
  put_length(to, length);

  /* put the address of the blob buffer or NULL */
  if (length)
    memcpy_fixed(to + packlength, &from, sizeof(from));
  else
    bzero(to + packlength, sizeof(from));

  /* point to first byte of next field in 'from' */
  return from + length;
}

7419

7420 7421 7422 7423 7424 7425
/* Create a packed key that will be used for storage from a MySQL key */

char *Field_blob::pack_key_from_key_image(char *to, const char *from,
					  uint max_length)
{
  uint length=uint2korr(from);
unknown's avatar
unknown committed
7426 7427
  if (length > max_length)
    length=max_length;
unknown's avatar
unknown committed
7428
  *to++= (char) (length & 255);
unknown's avatar
unknown committed
7429
  if (max_length > 255)
unknown's avatar
unknown committed
7430
    *to++= (char) (length >> 8);
unknown's avatar
unknown committed
7431
  if (length)
7432
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
unknown's avatar
unknown committed
7433 7434 7435
  return to+length;
}

7436

7437
uint Field_blob::packed_col_length(const char *data_ptr, uint length)
7438 7439
{
  if (length > 255)
7440
    return uint2korr(data_ptr)+2;
7441
  return (uint) ((uchar) *data_ptr)+1;
7442 7443
}

7444

7445 7446 7447 7448
uint Field_blob::max_packed_col_length(uint max_length)
{
  return (max_length > 255 ? 2 : 1)+max_length;
}
7449

unknown's avatar
unknown committed
7450

unknown's avatar
unknown committed
7451
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
7452

7453
void Field_geom::get_key_image(char *buff, uint length, imagetype type)
unknown's avatar
unknown committed
7454 7455
{
  char *blob;
unknown's avatar
unknown committed
7456
  const char *dummy;
unknown's avatar
unknown committed
7457
  MBR mbr;
7458 7459 7460
  ulong blob_length= get_length(ptr);
  Geometry_buffer buffer;
  Geometry *gobj;
unknown's avatar
unknown committed
7461 7462 7463 7464 7465 7466 7467

  if (blob_length < SRID_SIZE)
  {
    bzero(buff, SIZEOF_STORED_DOUBLE*4);
    return;
  }
  get_ptr(&blob);
7468
  gobj= Geometry::construct(&buffer, blob, blob_length);
7469
  if (!gobj || gobj->get_mbr(&mbr, &dummy))
unknown's avatar
unknown committed
7470 7471 7472 7473 7474 7475 7476 7477
    bzero(buff, SIZEOF_STORED_DOUBLE*4);
  else
  {
    float8store(buff, mbr.xmin);
    float8store(buff + 8, mbr.xmax);
    float8store(buff + 16, mbr.ymin);
    float8store(buff + 24, mbr.ymax);
  }
unknown's avatar
unknown committed
7478 7479 7480 7481 7482
}


void Field_geom::sql_type(String &res) const
{
unknown's avatar
unknown committed
7483 7484 7485 7486
  CHARSET_INFO *cs= &my_charset_latin1;
  switch (geom_type)
  {
    case GEOM_POINT:
7487
     res.set(STRING_WITH_LEN("point"), cs);
unknown's avatar
unknown committed
7488 7489
     break;
    case GEOM_LINESTRING:
7490
     res.set(STRING_WITH_LEN("linestring"), cs);
unknown's avatar
unknown committed
7491 7492
     break;
    case GEOM_POLYGON:
7493
     res.set(STRING_WITH_LEN("polygon"), cs);
unknown's avatar
unknown committed
7494 7495
     break;
    case GEOM_MULTIPOINT:
7496
     res.set(STRING_WITH_LEN("multipoint"), cs);
unknown's avatar
unknown committed
7497 7498
     break;
    case GEOM_MULTILINESTRING:
7499
     res.set(STRING_WITH_LEN("multilinestring"), cs);
unknown's avatar
unknown committed
7500 7501
     break;
    case GEOM_MULTIPOLYGON:
7502
     res.set(STRING_WITH_LEN("multipolygon"), cs);
unknown's avatar
unknown committed
7503 7504
     break;
    case GEOM_GEOMETRYCOLLECTION:
7505
     res.set(STRING_WITH_LEN("geometrycollection"), cs);
unknown's avatar
unknown committed
7506 7507
     break;
    default:
7508
     res.set(STRING_WITH_LEN("geometry"), cs);
unknown's avatar
unknown committed
7509
  }
unknown's avatar
unknown committed
7510 7511 7512
}


7513 7514 7515 7516 7517 7518 7519 7520
int Field_geom::store(double nr)
{
  my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
             ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
  return -1;
}


7521
int Field_geom::store(longlong nr, bool unsigned_val)
7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536
{
  my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
             ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
  return -1;
}


int Field_geom::store_decimal(const my_decimal *)
{
  my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
             ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
  return -1;
}


unknown's avatar
unknown committed
7537 7538 7539 7540 7541 7542
int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
{
  if (!length)
    bzero(ptr, Field_blob::pack_length());
  else
  {
7543 7544
    if (from == Geometry::bad_geometry_data.ptr())
      goto err;
unknown's avatar
unknown committed
7545 7546 7547 7548
    // Check given WKB
    uint32 wkb_type;
    if (length < SRID_SIZE + WKB_HEADER_SIZE + SIZEOF_STORED_DOUBLE*2)
      goto err;
7549
    wkb_type= uint4korr(from + SRID_SIZE + 1);
7550
    if (wkb_type < (uint32) Geometry::wkb_point ||
unknown's avatar
unknown committed
7551
	wkb_type > (uint32) Geometry::wkb_end)
7552
      goto err;
unknown's avatar
unknown committed
7553 7554 7555 7556 7557 7558 7559 7560 7561
    Field_blob::store_length(length);
    if (table->copy_blobs || length <= MAX_FIELD_WIDTH)
    {						// Must make a copy
      value.copy(from, length, cs);
      from= value.ptr();
    }
    bmove(ptr + packlength, (char*) &from, sizeof(char*));
  }
  return 0;
unknown's avatar
unknown committed
7562 7563 7564

err:
  bzero(ptr, Field_blob::pack_length());  
7565 7566
  my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
             ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
unknown's avatar
unknown committed
7567
  return -1;
unknown's avatar
unknown committed
7568 7569
}

unknown's avatar
unknown committed
7570
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
7571

unknown's avatar
unknown committed
7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594
/****************************************************************************
** enum type.
** This is a string which only can have a selection of different values.
** If one uses this string in a number context one gets the type number.
****************************************************************************/

enum ha_base_keytype Field_enum::key_type() const
{
  switch (packlength) {
  default: return HA_KEYTYPE_BINARY;
  case 2: return HA_KEYTYPE_USHORT_INT;
  case 3: return HA_KEYTYPE_UINT24;
  case 4: return HA_KEYTYPE_ULONG_INT;
  case 8: return HA_KEYTYPE_ULONGLONG;
  }
}

void Field_enum::store_type(ulonglong value)
{
  switch (packlength) {
  case 1: ptr[0]= (uchar) value;  break;
  case 2:
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
7595
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7596 7597 7598 7599 7600 7601 7602 7603 7604 7605
  {
    int2store(ptr,(unsigned short) value);
  }
  else
#endif
    shortstore(ptr,(unsigned short) value);
  break;
  case 3: int3store(ptr,(long) value); break;
  case 4:
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
7606
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7607 7608 7609 7610 7611 7612 7613 7614 7615
  {
    int4store(ptr,value);
  }
  else
#endif
    longstore(ptr,(long) value);
  break;
  case 8:
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
7616
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631
  {
    int8store(ptr,value);
  }
  else
#endif
    longlongstore(ptr,value); break;
  }
}


/*
** Note. Storing a empty string in a enum field gives a warning
** (if there isn't a empty value in the enum)
*/

unknown's avatar
unknown committed
7632
int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
7633
{
7634
  int err= 0;
unknown's avatar
unknown committed
7635
  uint32 not_used;
unknown's avatar
unknown committed
7636
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
7637
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
7638

unknown's avatar
unknown committed
7639
  /* Convert character set if necessary */
unknown's avatar
unknown committed
7640
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
7641
  { 
7642 7643
    uint dummy_errors;
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
unknown's avatar
unknown committed
7644 7645 7646
    from= tmpstr.ptr();
    length=  tmpstr.length();
  }
7647 7648

  /* Remove end space */
7649
  length= field_charset->cset->lengthsp(field_charset, from, length);
7650
  uint tmp=find_type2(typelib, from, length, field_charset);
unknown's avatar
unknown committed
7651
  if (!tmp)
unknown's avatar
unknown committed
7652
  {
7653
    if (length < 6) // Can't be more than 99999 enums
unknown's avatar
unknown committed
7654
    {
unknown's avatar
unknown committed
7655
      /* This is for reading numbers with LOAD DATA INFILE */
7656
      char *end;
7657 7658
      tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
      if (err || end != from+length || tmp > typelib->count)
unknown's avatar
unknown committed
7659 7660
      {
	tmp=0;
7661
	set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
7662
      }
unknown's avatar
unknown committed
7663 7664
    }
    else
7665
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
7666
  }
unknown's avatar
unknown committed
7667
  store_type((ulonglong) tmp);
7668
  return err;
unknown's avatar
unknown committed
7669 7670 7671
}


unknown's avatar
unknown committed
7672
int Field_enum::store(double nr)
unknown's avatar
unknown committed
7673
{
7674
  return Field_enum::store((longlong) nr, FALSE);
unknown's avatar
unknown committed
7675 7676 7677
}


7678
int Field_enum::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
7679
{
unknown's avatar
unknown committed
7680
  int error= 0;
7681
  if ((ulonglong) nr > typelib->count || nr == 0)
unknown's avatar
unknown committed
7682
  {
7683
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
7684
    nr=0;
7685
    error=1;
unknown's avatar
unknown committed
7686 7687
  }
  store_type((ulonglong) (uint) nr);
7688
  return error;
unknown's avatar
unknown committed
7689 7690 7691 7692 7693 7694 7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706
}


double Field_enum::val_real(void)
{
  return (double) Field_enum::val_int();
}


longlong Field_enum::val_int(void)
{
  switch (packlength) {
  case 1:
    return (longlong) (uchar) ptr[0];
  case 2:
    {
      uint16 tmp;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
7707
      if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7708 7709 7710 7711 7712 7713 7714 7715 7716 7717 7718 7719
	tmp=sint2korr(ptr);
      else
#endif
	shortget(tmp,ptr);
      return (longlong) tmp;
    }
  case 3:
    return (longlong) uint3korr(ptr);
  case 4:
    {
      uint32 tmp;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
7720
      if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7721 7722 7723 7724 7725 7726 7727 7728 7729 7730
	tmp=uint4korr(ptr);
      else
#endif
	longget(tmp,ptr);
      return (longlong) tmp;
    }
  case 8:
    {
      longlong tmp;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
7731
      if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7732 7733 7734 7735 7736 7737 7738 7739 7740 7741 7742 7743 7744 7745 7746 7747
	tmp=sint8korr(ptr);
      else
#endif
	longlongget(tmp,ptr);
      return tmp;
    }
  }
  return 0;					// impossible
}


String *Field_enum::val_str(String *val_buffer __attribute__((unused)),
			    String *val_ptr)
{
  uint tmp=(uint) Field_enum::val_int();
  if (!tmp || tmp > typelib->count)
unknown's avatar
unknown committed
7748
    val_ptr->set("", 0, field_charset);
unknown's avatar
unknown committed
7749 7750
  else
    val_ptr->set((const char*) typelib->type_names[tmp-1],
7751
		 typelib->type_lengths[tmp-1],
7752
		 field_charset);
unknown's avatar
unknown committed
7753 7754 7755 7756 7757 7758 7759 7760 7761 7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 7772 7773 7774 7775 7776 7777 7778 7779 7780
  return val_ptr;
}

int Field_enum::cmp(const char *a_ptr, const char *b_ptr)
{
  char *old=ptr;
  ptr=(char*) a_ptr;
  ulonglong a=Field_enum::val_int();
  ptr=(char*) b_ptr;
  ulonglong b=Field_enum::val_int();
  ptr=old;
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

void Field_enum::sort_string(char *to,uint length __attribute__((unused)))
{
  ulonglong value=Field_enum::val_int();
  to+=packlength-1;
  for (uint i=0 ; i < packlength ; i++)
  {
    *to-- = (uchar) (value & 255);
    value>>=8;
  }
}


void Field_enum::sql_type(String &res) const
{
7781 7782 7783
  char buffer[255];
  String enum_item(buffer, sizeof(buffer), res.charset());

unknown's avatar
unknown committed
7784
  res.length(0);
7785
  res.append(STRING_WITH_LEN("enum("));
unknown's avatar
unknown committed
7786 7787

  bool flag=0;
7788 7789
  uint *len= typelib->type_lengths;
  for (const char **pos= typelib->type_names; *pos; pos++, len++)
unknown's avatar
unknown committed
7790
  {
7791
    uint dummy_errors;
unknown's avatar
unknown committed
7792 7793
    if (flag)
      res.append(',');
7794
    /* convert to res.charset() == utf8, then quote */
7795
    enum_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
7796 7797
    append_unescaped(&res, enum_item.ptr(), enum_item.length());
    flag= 1;
unknown's avatar
unknown committed
7798 7799 7800 7801 7802
  }
  res.append(')');
}


7803 7804 7805 7806 7807 7808 7809 7810
/*
   set type.
   This is a string which can have a collection of different values.
   Each string value is separated with a ','.
   For example "One,two,five"
   If one uses this string in a number context one gets the bits as a longlong
   number.
*/
unknown's avatar
unknown committed
7811 7812


unknown's avatar
unknown committed
7813
int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
7814
{
unknown's avatar
unknown committed
7815
  bool got_warning= 0;
7816
  int err= 0;
7817 7818
  char *not_used;
  uint not_used2;
unknown's avatar
unknown committed
7819
  uint32 not_used_offset;
unknown's avatar
unknown committed
7820
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
7821
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
7822

unknown's avatar
unknown committed
7823
  /* Convert character set if necessary */
unknown's avatar
unknown committed
7824
  if (String::needs_conversion(length, cs, field_charset, &not_used_offset))
unknown's avatar
unknown committed
7825
  { 
7826 7827
    uint dummy_errors;
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
unknown's avatar
unknown committed
7828 7829 7830
    from= tmpstr.ptr();
    length=  tmpstr.length();
  }
7831 7832
  ulonglong tmp= find_set(typelib, from, length, field_charset,
                          &not_used, &not_used2, &got_warning);
unknown's avatar
unknown committed
7833 7834 7835
  if (!tmp && length && length < 22)
  {
    /* This is for reading numbers with LOAD DATA INFILE */
7836
    char *end;
7837 7838
    tmp=my_strntoull(cs,from,length,10,&end,&err);
    if (err || end != from+length ||
unknown's avatar
unknown committed
7839
	tmp > (ulonglong) (((longlong) 1 << typelib->count) - (longlong) 1))
7840
    {
7841
      tmp=0;      
7842
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
7843
    }
unknown's avatar
unknown committed
7844
  }
unknown's avatar
unknown committed
7845
  else if (got_warning)
7846
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
7847
  store_type(tmp);
7848
  return err;
unknown's avatar
unknown committed
7849 7850 7851
}


7852
int Field_set::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
7853
{
unknown's avatar
unknown committed
7854
  int error= 0;
unknown's avatar
unknown committed
7855 7856 7857
  if ((ulonglong) nr > (ulonglong) (((longlong) 1 << typelib->count) -
				    (longlong) 1))
  {
7858
    nr&= (longlong) (((longlong) 1 << typelib->count) - (longlong) 1);    
7859
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
7860
    error=1;
unknown's avatar
unknown committed
7861 7862
  }
  store_type((ulonglong) nr);
7863
  return error;
unknown's avatar
unknown committed
7864 7865 7866 7867 7868 7869 7870 7871 7872 7873
}


String *Field_set::val_str(String *val_buffer,
			   String *val_ptr __attribute__((unused)))
{
  ulonglong tmp=(ulonglong) Field_enum::val_int();
  uint bitnr=0;

  val_buffer->length(0);
7874
  val_buffer->set_charset(field_charset);
unknown's avatar
unknown committed
7875 7876 7877 7878 7879
  while (tmp && bitnr < (uint) typelib->count)
  {
    if (tmp & 1)
    {
      if (val_buffer->length())
7880
	val_buffer->append(&field_separator, 1, &my_charset_latin1);
unknown's avatar
unknown committed
7881
      String str(typelib->type_names[bitnr],
7882
		 typelib->type_lengths[bitnr],
7883
		 field_charset);
unknown's avatar
unknown committed
7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894
      val_buffer->append(str);
    }
    tmp>>=1;
    bitnr++;
  }
  return val_buffer;
}


void Field_set::sql_type(String &res) const
{
7895 7896 7897
  char buffer[255];
  String set_item(buffer, sizeof(buffer), res.charset());

unknown's avatar
unknown committed
7898
  res.length(0);
7899
  res.append(STRING_WITH_LEN("set("));
unknown's avatar
unknown committed
7900 7901

  bool flag=0;
7902 7903
  uint *len= typelib->type_lengths;
  for (const char **pos= typelib->type_names; *pos; pos++, len++)
unknown's avatar
unknown committed
7904
  {
7905
    uint dummy_errors;
unknown's avatar
unknown committed
7906 7907
    if (flag)
      res.append(',');
7908
    /* convert to res.charset() == utf8, then quote */
7909
    set_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
7910 7911
    append_unescaped(&res, set_item.ptr(), set_item.length());
    flag= 1;
unknown's avatar
unknown committed
7912 7913 7914 7915 7916 7917 7918 7919
  }
  res.append(')');
}

/* returns 1 if the fields are equally defined */

bool Field::eq_def(Field *field)
{
7920
  if (real_type() != field->real_type() || charset() != field->charset() ||
unknown's avatar
unknown committed
7921 7922 7923 7924 7925 7926 7927 7928 7929 7930
      pack_length() != field->pack_length())
    return 0;
  return 1;
}

bool Field_enum::eq_def(Field *field)
{
  if (!Field::eq_def(field))
    return 0;
  TYPELIB *from_lib=((Field_enum*) field)->typelib;
unknown's avatar
unknown committed
7931

unknown's avatar
unknown committed
7932 7933 7934
  if (typelib->count < from_lib->count)
    return 0;
  for (uint i=0 ; i < from_lib->count ; i++)
7935 7936
    if (my_strnncoll(field_charset,
                     (const uchar*)typelib->type_names[i],
7937
                     (uint) strlen(typelib->type_names[i]),
7938
                     (const uchar*)from_lib->type_names[i],
7939
                     (uint) strlen(from_lib->type_names[i])))
unknown's avatar
unknown committed
7940 7941 7942 7943 7944
      return 0;
  return 1;
}

bool Field_num::eq_def(Field *field)
unknown's avatar
unknown committed
7945
{
unknown's avatar
unknown committed
7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957
  if (!Field::eq_def(field))
    return 0;
  Field_num *from_num= (Field_num*) field;

  if (unsigned_flag != from_num->unsigned_flag ||
      zerofill && !from_num->zerofill && !zero_pack() ||
      dec != from_num->dec)
    return 0;
  return 1;
}


unknown's avatar
unknown committed
7958 7959
uint Field_num::is_equal(create_field *new_field)
{
7960
  return ((new_field->sql_type == real_type()) &&
unknown's avatar
unknown committed
7961 7962 7963 7964
	  ((new_field->flags & UNSIGNED_FLAG) == (uint) (flags &
							 UNSIGNED_FLAG)) &&
	  ((new_field->flags & AUTO_INCREMENT_FLAG) ==
	   (uint) (flags & AUTO_INCREMENT_FLAG)) &&
7965
	  (new_field->length <= max_length()));
unknown's avatar
unknown committed
7966 7967 7968
}


unknown's avatar
unknown committed
7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997
/*
  Bit field.

  We store the first 0 - 6 uneven bits among the null bits 
  at the start of the record. The rest bytes are stored in 
  the record itself.

  For example:

  CREATE TABLE t1 (a int, b bit(17), c bit(21) not null, d bit(8));
  We would store data  as follows in the record:

  Byte        Bit
  1           7 - reserve for delete
              6 - null bit for 'a'
              5 - null bit for 'b'
              4 - first (high) bit of 'b'
              3 - first (high) bit of 'c'
              2 - second bit of 'c'
              1 - third bit of 'c'
              0 - forth bit of 'c'
  2           7 - firth bit of 'c'
              6 - null bit for 'd'
  3 - 6       four bytes for 'a'
  7 - 8       two bytes for 'b'
  9 - 10      two bytes for 'c'
  11          one byte for 'd'
*/

unknown's avatar
unknown committed
7998 7999
Field_bit::Field_bit(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
                     uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg,
unknown's avatar
unknown committed
8000
                     enum utype unireg_check_arg, const char *field_name_arg)
unknown's avatar
unknown committed
8001
  : Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
unknown's avatar
unknown committed
8002
          unireg_check_arg, field_name_arg),
unknown's avatar
unknown committed
8003 8004
    bit_ptr(bit_ptr_arg), bit_ofs(bit_ofs_arg), bit_len(len_arg & 7),
    bytes_in_rec(len_arg / 8)
unknown's avatar
unknown committed
8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034
{
  /*
    Ensure that Field::eq() can distinguish between two different bit fields.
    (two bit fields that are not null, may have same ptr and null_ptr)
  */
  if (!null_ptr_arg)
    null_bit= bit_ofs_arg;
}


Field *Field_bit::new_key_field(MEM_ROOT *root,
                                struct st_table *new_table,
                                char *new_ptr, uchar *new_null_ptr,
                                uint new_null_bit)
{
  Field_bit *res;
  if ((res= (Field_bit*) Field::new_key_field(root, new_table,
                                              new_ptr, new_null_ptr,
                                              new_null_bit)))
  {
    /* Move bits normally stored in null_pointer to new_ptr */
    res->bit_ptr= (uchar*) new_ptr;
    res->bit_ofs= 0;
    if (bit_len)
      res->ptr++;                               // Store rest of data here
  }
  return res;
}


unknown's avatar
unknown committed
8035 8036 8037 8038
int Field_bit::store(const char *from, uint length, CHARSET_INFO *cs)
{
  int delta;

8039
  for (; length && !*from; from++, length--);          // skip left 0's
unknown's avatar
unknown committed
8040
  delta= bytes_in_rec - length;
unknown's avatar
unknown committed
8041 8042 8043 8044 8045 8046

  if (delta < -1 ||
      (delta == -1 && (uchar) *from > ((1 << bit_len) - 1)) ||
      (!bit_len && delta < 0))
  {
    set_rec_bits(0xff, bit_ptr, bit_ofs, bit_len);
unknown's avatar
unknown committed
8047
    memset(ptr, 0xff, bytes_in_rec);
8048 8049 8050 8051
    if (table->in_use->really_abort_on_warning())
      set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
    else
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
8052 8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074
    return 1;
  }
  /* delta is >= -1 here */
  if (delta > 0)
  {
    if (bit_len)
      clr_rec_bits(bit_ptr, bit_ofs, bit_len);
    bzero(ptr, delta);
    memcpy(ptr + delta, from, length);
  }
  else if (delta == 0)
  {
    if (bit_len)
      clr_rec_bits(bit_ptr, bit_ofs, bit_len);
    memcpy(ptr, from, length);
  }
  else
  {
    if (bit_len)
    {
      set_rec_bits((uchar) *from, bit_ptr, bit_ofs, bit_len);
      from++;
    }
unknown's avatar
unknown committed
8075
    memcpy(ptr, from, bytes_in_rec);
unknown's avatar
unknown committed
8076 8077 8078 8079 8080 8081 8082
  }
  return 0;
}


int Field_bit::store(double nr)
{
8083
  return store((longlong) nr, FALSE);
unknown's avatar
unknown committed
8084 8085 8086
}


8087
int Field_bit::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
8088 8089 8090 8091 8092 8093 8094 8095
{
  char buf[8];

  mi_int8store(buf, nr);
  return store(buf, 8, NULL);
}


unknown's avatar
unknown committed
8096 8097 8098 8099 8100 8101 8102 8103
int Field_bit::store_decimal(const my_decimal *val)
{
  int err= 0;
  longlong i= convert_decimal2longlong(val, 1, &err);
  return test(err | store(i));
}


unknown's avatar
unknown committed
8104 8105 8106 8107 8108 8109 8110 8111 8112 8113
double Field_bit::val_real(void)
{
  return (double) Field_bit::val_int();
}


longlong Field_bit::val_int(void)
{
  ulonglong bits= 0;
  if (bit_len)
8114
  {
unknown's avatar
unknown committed
8115
    bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
unknown's avatar
unknown committed
8116
    bits<<= (bytes_in_rec * 8);
8117
  }
unknown's avatar
unknown committed
8118

unknown's avatar
unknown committed
8119
  switch (bytes_in_rec) {
unknown's avatar
unknown committed
8120 8121 8122 8123 8124 8125 8126 8127
  case 0: return bits;
  case 1: return bits | (ulonglong) (uchar) ptr[0];
  case 2: return bits | mi_uint2korr(ptr);
  case 3: return bits | mi_uint3korr(ptr);
  case 4: return bits | mi_uint4korr(ptr);
  case 5: return bits | mi_uint5korr(ptr);
  case 6: return bits | mi_uint6korr(ptr);
  case 7: return bits | mi_uint7korr(ptr);
unknown's avatar
unknown committed
8128
  default: return mi_uint8korr(ptr + bytes_in_rec - sizeof(longlong));
unknown's avatar
unknown committed
8129 8130 8131 8132 8133 8134 8135
  }
}  


String *Field_bit::val_str(String *val_buffer,
                           String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
8136
  char buff[sizeof(longlong)];
unknown's avatar
unknown committed
8137 8138
  uint length= min(pack_length(), sizeof(longlong));
  ulonglong bits= val_int();
unknown's avatar
unknown committed
8139
  mi_int8store(buff,bits);
unknown's avatar
unknown committed
8140 8141

  val_buffer->alloc(length);
unknown's avatar
unknown committed
8142
  memcpy_fixed((char*) val_buffer->ptr(), buff+8-length, length);
unknown's avatar
unknown committed
8143 8144 8145 8146 8147 8148
  val_buffer->length(length);
  val_buffer->set_charset(&my_charset_bin);
  return val_buffer;
}


unknown's avatar
unknown committed
8149 8150 8151 8152 8153 8154 8155
my_decimal *Field_bit::val_decimal(my_decimal *deciaml_value)
{
  int2my_decimal(E_DEC_FATAL_ERROR, val_int(), 1, deciaml_value);
  return deciaml_value;
}


8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170 8171 8172 8173 8174 8175 8176 8177 8178 8179 8180 8181 8182 8183 8184
/*
  Compare two bit fields using pointers within the record.
  SYNOPSIS
    cmp_max()
    a                 Pointer to field->ptr in first record
    b                 Pointer to field->ptr in second record
    max_len           Maximum length used in index
  DESCRIPTION
    This method is used from key_rec_cmp used by merge sorts used
    by partitioned index read and later other similar places.
    The a and b pointer must be pointers to the field in a record
    (not the table->record[0] necessarily)
*/
int Field_bit::cmp_max(const char *a, const char *b, uint max_len)
{
  my_ptrdiff_t a_diff= a - ptr;
  my_ptrdiff_t b_diff= b - ptr;
  if (bit_len)
  {
    int flag;
    uchar bits_a= get_rec_bits(bit_ptr+a_diff, bit_ofs, bit_len);
    uchar bits_b= get_rec_bits(bit_ptr+b_diff, bit_ofs, bit_len);
    if ((flag= (int) (bits_a - bits_b)))
      return flag;
  }
  return memcmp(a, b, field_length);
}


unknown's avatar
unknown committed
8185 8186 8187 8188 8189 8190
int Field_bit::key_cmp(const byte *str, uint length)
{
  if (bit_len)
  {
    int flag;
    uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
unknown's avatar
unknown committed
8191
    if ((flag= (int) (bits - *(uchar*) str)))
unknown's avatar
unknown committed
8192 8193 8194 8195
      return flag;
    str++;
    length--;
  }
unknown's avatar
unknown committed
8196
  return memcmp(ptr, str, length);
unknown's avatar
unknown committed
8197 8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209
}


int Field_bit::cmp_offset(uint row_offset)
{
  if (bit_len)
  {
    int flag;
    uchar bits_a= get_rec_bits(bit_ptr, bit_ofs, bit_len);
    uchar bits_b= get_rec_bits(bit_ptr + row_offset, bit_ofs, bit_len);
    if ((flag= (int) (bits_a - bits_b)))
      return flag;
  }
unknown's avatar
unknown committed
8210
  return memcmp(ptr, ptr + row_offset, bytes_in_rec);
unknown's avatar
unknown committed
8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221
}


void Field_bit::get_key_image(char *buff, uint length, imagetype type)
{
  if (bit_len)
  {
    uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
    *buff++= bits;
    length--;
  }
unknown's avatar
unknown committed
8222
  memcpy(buff, ptr, min(length, bytes_in_rec));
unknown's avatar
unknown committed
8223 8224 8225 8226 8227 8228 8229
}


void Field_bit::sql_type(String &res) const
{
  CHARSET_INFO *cs= res.charset();
  ulong length= cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
unknown's avatar
unknown committed
8230
                                   "bit(%d)", (int) field_length);
unknown's avatar
unknown committed
8231 8232 8233 8234 8235 8236
  res.length((uint) length);
}


char *Field_bit::pack(char *to, const char *from, uint max_length)
{
unknown's avatar
unknown committed
8237 8238
  DBUG_ASSERT(max_length);
  uint length;
unknown's avatar
unknown committed
8239 8240 8241 8242 8243
  if (bit_len)
  {
    uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
    *to++= bits;
  }
unknown's avatar
unknown committed
8244 8245
  length= min(bytes_in_rec, max_length - (bit_len > 0));
  memcpy(to, from, length);
unknown's avatar
unknown committed
8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256
  return to + length;
}


const char *Field_bit::unpack(char *to, const char *from)
{
  if (bit_len)
  {
    set_rec_bits(*from, bit_ptr, bit_ofs, bit_len);
    from++;
  }
unknown's avatar
unknown committed
8257 8258
  memcpy(to, from, bytes_in_rec);
  return from + bytes_in_rec;
unknown's avatar
unknown committed
8259 8260 8261
}


8262 8263 8264 8265 8266
/*
  Bit field support for non-MyISAM tables.
*/

Field_bit_as_char::Field_bit_as_char(char *ptr_arg, uint32 len_arg,
8267 8268
                                     uchar *null_ptr_arg, uchar null_bit_arg,
                                     enum utype unireg_check_arg,
unknown's avatar
unknown committed
8269
                                     const char *field_name_arg)
8270
  :Field_bit(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, 0, 0,
unknown's avatar
unknown committed
8271
             unireg_check_arg, field_name_arg)
8272 8273
{
  bit_len= 0;
unknown's avatar
unknown committed
8274
  bytes_in_rec= (len_arg + 7) / 8;
8275 8276 8277 8278 8279 8280
}


int Field_bit_as_char::store(const char *from, uint length, CHARSET_INFO *cs)
{
  int delta;
unknown's avatar
unknown committed
8281
  uchar bits= field_length & 7;
8282

8283
  for (; length && !*from; from++, length--);          // skip left 0's
unknown's avatar
unknown committed
8284
  delta= bytes_in_rec - length;
8285 8286 8287 8288

  if (delta < 0 ||
      (delta == 0 && bits && (uint) (uchar) *from >= (uint) (1 << bits)))
  {
unknown's avatar
unknown committed
8289
    memset(ptr, 0xff, bytes_in_rec);
8290 8291
    if (bits)
      *ptr&= ((1 << bits) - 1); /* set first byte */
8292 8293 8294 8295
    if (table->in_use->really_abort_on_warning())
      set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
    else
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
8296 8297 8298 8299 8300 8301 8302 8303 8304 8305 8306 8307
    return 1;
  }
  bzero(ptr, delta);
  memcpy(ptr + delta, from, length);
  return 0;
}


void Field_bit_as_char::sql_type(String &res) const
{
  CHARSET_INFO *cs= res.charset();
  ulong length= cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
unknown's avatar
unknown committed
8308
                                   "bit(%d)", (int) field_length);
8309 8310 8311 8312
  res.length((uint) length);
}


unknown's avatar
unknown committed
8313
/*****************************************************************************
8314
  Handling of field and create_field
unknown's avatar
unknown committed
8315 8316
*****************************************************************************/

8317 8318 8319 8320 8321 8322 8323
/*
  Convert create_field::length from number of characters to number of bytes

  SYNOPSIS
    create_field::create_length_to_internal_length()
  
  DESCRIPTION
8324
    Convert create_field::length from number of characters to number of bytes.
8325 8326
*/

8327 8328
void create_field::create_length_to_internal_length(void)
{
unknown's avatar
unknown committed
8329 8330 8331 8332 8333 8334 8335
  switch (sql_type) {
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
  case MYSQL_TYPE_BLOB:
  case MYSQL_TYPE_VAR_STRING:
  case MYSQL_TYPE_STRING:
8336
  case MYSQL_TYPE_VARCHAR:
unknown's avatar
unknown committed
8337
    length*= charset->mbmaxlen;
8338
    key_length= length;
8339
    pack_length= calc_pack_length(sql_type, length);
unknown's avatar
unknown committed
8340 8341 8342
    break;
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_SET:
8343
    /* Pack_length already calculated in sql_parse.cc */
unknown's avatar
unknown committed
8344
    length*= charset->mbmaxlen;
8345
    key_length= pack_length;
unknown's avatar
unknown committed
8346
    break;
unknown's avatar
unknown committed
8347
  case MYSQL_TYPE_BIT:
8348 8349 8350 8351 8352 8353 8354 8355 8356 8357
    if (f_bit_as_char(pack_flag))
    {
      key_length= pack_length= ((length + 7) & ~7) / 8;
    }
    else
    {
      pack_length= length / 8;
      /* We need one extra byte to store the bits we save among the null bits */
      key_length= pack_length + test(length & 7);
    }
unknown's avatar
unknown committed
8358
    break;
unknown's avatar
unknown committed
8359
  case MYSQL_TYPE_NEWDECIMAL:
unknown's avatar
unknown committed
8360 8361 8362 8363 8364 8365
    key_length= pack_length=
      my_decimal_get_binary_size(my_decimal_length_to_precision(length,
								decimals,
								flags &
								UNSIGNED_FLAG),
				 decimals);
unknown's avatar
unknown committed
8366
    break;
unknown's avatar
unknown committed
8367
  default:
8368
    key_length= pack_length= calc_pack_length(sql_type, length);
unknown's avatar
unknown committed
8369
    break;
8370 8371 8372
  }
}

8373

8374 8375 8376 8377 8378 8379
void create_field::init_for_tmp_table(enum_field_types sql_type_arg,
                                      uint32 length_arg, uint32 decimals,
                                      bool maybe_null, bool is_unsigned)
{
  field_name= "";
  sql_type= sql_type_arg;
unknown's avatar
unknown committed
8380
  char_length= length= length_arg;;
8381 8382 8383 8384 8385 8386 8387 8388 8389 8390 8391
  unireg_check= Field::NONE;
  interval= 0;
  charset= &my_charset_bin;
  geom_type= Field::GEOM_GEOMETRY;
  pack_flag= (FIELDFLAG_NUMBER |
              ((decimals & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
              (maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
              (is_unsigned ? 0 : FIELDFLAG_DECIMAL));
}


8392 8393 8394 8395 8396 8397 8398 8399 8400 8401 8402 8403 8404 8405 8406 8407 8408 8409 8410 8411 8412 8413 8414 8415 8416 8417 8418 8419 8420 8421 8422 8423 8424 8425 8426 8427 8428 8429 8430 8431 8432 8433 8434 8435 8436 8437 8438 8439 8440 8441 8442 8443 8444 8445 8446 8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473 8474 8475 8476 8477 8478 8479 8480 8481 8482 8483 8484 8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 8496 8497 8498 8499 8500 8501 8502 8503 8504 8505 8506 8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517 8518 8519 8520 8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531 8532 8533 8534 8535 8536 8537 8538 8539 8540 8541 8542 8543 8544 8545 8546 8547 8548 8549 8550 8551 8552 8553 8554 8555 8556 8557 8558 8559 8560 8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586 8587 8588 8589 8590 8591 8592 8593 8594 8595 8596 8597 8598 8599 8600 8601 8602 8603 8604 8605 8606 8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628 8629 8630 8631 8632 8633 8634 8635 8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646 8647 8648 8649 8650 8651 8652 8653 8654 8655 8656 8657 8658 8659 8660 8661 8662 8663 8664 8665 8666 8667 8668 8669 8670 8671 8672 8673 8674 8675 8676 8677 8678 8679 8680 8681 8682 8683 8684 8685 8686 8687 8688 8689 8690 8691 8692 8693 8694 8695 8696 8697 8698 8699 8700 8701 8702 8703 8704 8705 8706 8707
/*
  Initialize field definition for create

  SYNOPSIS
    thd                   Thread handle
    fld_name              Field name
    fld_type              Field type
    fld_length            Field length
    fld_decimals          Decimal (if any)
    fld_type_modifier     Additional type information
    fld_default_value     Field default value (if any)
    fld_on_update_value   The value of ON UPDATE clause
    fld_comment           Field comment
    fld_change            Field change
    fld_interval_list     Interval list (if any)
    fld_charset           Field charset
    fld_geom_type         Field geometry type (if any)

  RETURN
    FALSE on success
    TRUE  on error
*/

bool create_field::init(THD *thd, char *fld_name, enum_field_types fld_type,
                        char *fld_length, char *fld_decimals,
                        uint fld_type_modifier, Item *fld_default_value,
                        Item *fld_on_update_value, LEX_STRING *fld_comment,
                        char *fld_change, List<String> *fld_interval_list,
                        CHARSET_INFO *fld_charset, uint fld_geom_type)
{
  uint sign_len, allowed_type_modifier= 0;
  ulong max_field_charlength= MAX_FIELD_CHARLENGTH;

  DBUG_ENTER("create_field::init()");
  
  field= 0;
  field_name= fld_name;
  def= fld_default_value;
  flags= fld_type_modifier;
  unireg_check= (fld_type_modifier & AUTO_INCREMENT_FLAG ?
                 Field::NEXT_NUMBER : Field::NONE);
  decimals= fld_decimals ? (uint)atoi(fld_decimals) : 0;
  if (decimals >= NOT_FIXED_DEC)
  {
    my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
             NOT_FIXED_DEC-1);
    DBUG_RETURN(TRUE);
  }

  sql_type= fld_type;
  length= 0;
  change= fld_change;
  interval= 0;
  pack_length= key_length= 0;
  charset= fld_charset;
  geom_type= (Field::geometry_type) fld_geom_type;
  interval_list.empty();

  comment= *fld_comment;
  /*
    Set flag if this field doesn't have a default value
  */
  if (!fld_default_value && !(fld_type_modifier & AUTO_INCREMENT_FLAG) &&
      (fld_type_modifier & NOT_NULL_FLAG) && fld_type != FIELD_TYPE_TIMESTAMP)
    flags|= NO_DEFAULT_VALUE_FLAG;

  if (fld_length && !(length= (uint) atoi(fld_length)))
    fld_length= 0; /* purecov: inspected */
  sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1;

  switch (fld_type) {
  case FIELD_TYPE_TINY:
    if (!fld_length)
      length= MAX_TINYINT_WIDTH+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_SHORT:
    if (!fld_length)
      length= MAX_SMALLINT_WIDTH+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_INT24:
    if (!fld_length)
      length= MAX_MEDIUMINT_WIDTH+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONG:
    if (!fld_length)
      length= MAX_INT_WIDTH+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONGLONG:
    if (!fld_length)
      length= MAX_BIGINT_WIDTH;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_NULL:
    break;
  case FIELD_TYPE_NEWDECIMAL:
    if (!fld_length && !decimals)
      length= 10;
    if (length > DECIMAL_MAX_PRECISION)
    {
      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, fld_name,
               DECIMAL_MAX_PRECISION);
      DBUG_RETURN(TRUE);
    }
    if (length < decimals)
    {
      my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
      DBUG_RETURN(TRUE);
    }
    length=
      my_decimal_precision_to_length(length, decimals,
                                     fld_type_modifier & UNSIGNED_FLAG);
    pack_length=
      my_decimal_get_binary_size(length, decimals);
    break;
  case MYSQL_TYPE_VARCHAR:
    /*
      Long VARCHAR's are automaticly converted to blobs in mysql_prepare_table
      if they don't have a default value
    */
    max_field_charlength= MAX_FIELD_VARCHARLENGTH;
    break;
  case MYSQL_TYPE_STRING:
    break;
  case FIELD_TYPE_BLOB:
  case FIELD_TYPE_TINY_BLOB:
  case FIELD_TYPE_LONG_BLOB:
  case FIELD_TYPE_MEDIUM_BLOB:
  case FIELD_TYPE_GEOMETRY:
    if (fld_default_value)
    {
      /* Allow empty as default value. */
      String str,*res;
      res= fld_default_value->val_str(&str);
      if (res->length())
      {
        my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
                 fld_name); /* purecov: inspected */
        DBUG_RETURN(TRUE);
      }
      def= 0;
    }
    flags|= BLOB_FLAG;
    break;
  case FIELD_TYPE_YEAR:
    if (!fld_length || length != 2)
      length= 4; /* Default length */
    flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
    break;
  case FIELD_TYPE_FLOAT:
    /* change FLOAT(precision) to FLOAT or DOUBLE */
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    if (fld_length && !fld_decimals)
    {
      uint tmp_length= length;
      if (tmp_length > PRECISION_FOR_DOUBLE)
      {
        my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
        DBUG_RETURN(TRUE);
      }
      else if (tmp_length > PRECISION_FOR_FLOAT)
      {
        sql_type= FIELD_TYPE_DOUBLE;
        length= DBL_DIG+7; /* -[digits].E+### */
      }
      else
        length= FLT_DIG+6; /* -[digits].E+## */
      decimals= NOT_FIXED_DEC;
      break;
    }
    if (!fld_length && !fld_decimals)
    {
      length=  FLT_DIG+6;
      decimals= NOT_FIXED_DEC;
    }
    if (length < decimals &&
        decimals != NOT_FIXED_DEC)
    {
      my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
      DBUG_RETURN(TRUE);
    }
    break;
  case FIELD_TYPE_DOUBLE:
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    if (!fld_length && !fld_decimals)
    {
      length= DBL_DIG+7;
      decimals= NOT_FIXED_DEC;
    }
    if (length < decimals &&
        decimals != NOT_FIXED_DEC)
    {
      my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
      DBUG_RETURN(TRUE);
    }
    break;
  case FIELD_TYPE_TIMESTAMP:
    if (!fld_length)
      length= 14;  /* Full date YYYYMMDDHHMMSS */
    else if (length != 19)
    {
      /*
        We support only even TIMESTAMP lengths less or equal than 14
        and 19 as length of 4.1 compatible representation.
      */
      length= ((length+1)/2)*2; /* purecov: inspected */
      length= min(length,14); /* purecov: inspected */
    }
    flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
    if (fld_default_value)
    {
      /* Grammar allows only NOW() value for ON UPDATE clause */
      if (fld_default_value->type() == Item::FUNC_ITEM && 
          ((Item_func*)fld_default_value)->functype() == Item_func::NOW_FUNC)
      {
        unireg_check= (fld_on_update_value ? Field::TIMESTAMP_DNUN_FIELD:
                                             Field::TIMESTAMP_DN_FIELD);
        /*
          We don't need default value any longer moreover it is dangerous.
          Everything handled by unireg_check further.
        */
        def= 0;
      }
      else
        unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD:
                                             Field::NONE);
    }
    else
    {
      /*
        If we have default TIMESTAMP NOT NULL column without explicit DEFAULT
        or ON UPDATE values then for the sake of compatiblity we should treat
        this column as having DEFAULT NOW() ON UPDATE NOW() (when we don't
        have another TIMESTAMP column with auto-set option before this one)
        or DEFAULT 0 (in other cases).
        So here we are setting TIMESTAMP_OLD_FIELD only temporary, and will
        replace this value by TIMESTAMP_DNUN_FIELD or NONE later when
        information about all TIMESTAMP fields in table will be availiable.

        If we have TIMESTAMP NULL column without explicit DEFAULT value
        we treat it as having DEFAULT NULL attribute.
      */
      unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD :
                     (flags & NOT_NULL_FLAG ? Field::TIMESTAMP_OLD_FIELD :
                                              Field::NONE));
    }
    break;
  case FIELD_TYPE_DATE:
    /* Old date type. */
    if (protocol_version != PROTOCOL_VERSION-1)
      sql_type= FIELD_TYPE_NEWDATE;
    /* fall trough */
  case FIELD_TYPE_NEWDATE:
    length= 10;
    break;
  case FIELD_TYPE_TIME:
    length= 10;
    break;
  case FIELD_TYPE_DATETIME:
    length= 19;
    break;
  case FIELD_TYPE_SET:
    {
      if (fld_interval_list->elements > sizeof(longlong)*8)
      {
        my_error(ER_TOO_BIG_SET, MYF(0), fld_name); /* purecov: inspected */
        DBUG_RETURN(TRUE);
      }
      pack_length= get_set_pack_length(fld_interval_list->elements);

      List_iterator<String> it(*fld_interval_list);
      String *tmp;
      while ((tmp= it++))
        interval_list.push_back(tmp);
      /*
        Set fake length to 1 to pass the below conditions.
        Real length will be set in mysql_prepare_table()
        when we know the character set of the column
      */
      length= 1;
      break;
    }
  case FIELD_TYPE_ENUM:
    {
      /* Should be safe. */
      pack_length= get_enum_pack_length(fld_interval_list->elements);

      List_iterator<String> it(*fld_interval_list);
      String *tmp;
      while ((tmp= it++))
        interval_list.push_back(tmp);
      length= 1; /* See comment for FIELD_TYPE_SET above. */
      break;
   }
  case MYSQL_TYPE_VAR_STRING:
    DBUG_ASSERT(0);  /* Impossible. */
    break;
  case MYSQL_TYPE_BIT:
    {
      if (!fld_length)
        length= 1;
      if (length > MAX_BIT_FIELD_LENGTH)
      {
        my_error(ER_TOO_BIG_DISPLAYWIDTH, MYF(0), fld_name,
                 MAX_BIT_FIELD_LENGTH);
        DBUG_RETURN(TRUE);
      }
      pack_length= (length + 7) / 8;
      break;
    }
  case FIELD_TYPE_DECIMAL:
    DBUG_ASSERT(0); /* Was obsolete */
  }
unknown's avatar
unknown committed
8708 8709
  /* Remember the value of length */
  char_length= length;
8710 8711 8712 8713 8714 8715 8716 8717 8718 8719 8720 8721 8722 8723 8724 8725 8726 8727 8728 8729 8730 8731 8732 8733 8734 8735 8736 8737

  if (!(flags & BLOB_FLAG) &&
      ((length > max_field_charlength && fld_type != FIELD_TYPE_SET &&
        fld_type != FIELD_TYPE_ENUM &&
        (fld_type != MYSQL_TYPE_VARCHAR || fld_default_value)) ||
       (!length &&
        fld_type != MYSQL_TYPE_STRING &&
        fld_type != MYSQL_TYPE_VARCHAR && fld_type != FIELD_TYPE_GEOMETRY)))
  {
    my_error((fld_type == MYSQL_TYPE_VAR_STRING ||
              fld_type == MYSQL_TYPE_VARCHAR ||
              fld_type == MYSQL_TYPE_STRING) ?  ER_TOO_BIG_FIELDLENGTH :
                                                ER_TOO_BIG_DISPLAYWIDTH,
              MYF(0),
              fld_name, max_field_charlength); /* purecov: inspected */
    DBUG_RETURN(TRUE);
  }
  fld_type_modifier&= AUTO_INCREMENT_FLAG;
  if ((~allowed_type_modifier) & fld_type_modifier)
  {
    my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
    DBUG_RETURN(TRUE);
  }

  DBUG_RETURN(FALSE); /* success */
}


8738 8739 8740 8741 8742 8743 8744 8745 8746 8747 8748 8749 8750 8751 8752
enum_field_types get_blob_type_from_length(ulong length)
{
  enum_field_types type;
  if (length < 256)
    type= FIELD_TYPE_TINY_BLOB;
  else if (length < 65536)
    type= FIELD_TYPE_BLOB;
  else if (length < 256L*256L*256L)
    type= FIELD_TYPE_MEDIUM_BLOB;
  else
    type= FIELD_TYPE_LONG_BLOB;
  return type;
}


unknown's avatar
unknown committed
8753
/*
unknown's avatar
unknown committed
8754
  Make a field from the .frm file info
unknown's avatar
unknown committed
8755 8756 8757 8758 8759
*/

uint32 calc_pack_length(enum_field_types type,uint32 length)
{
  switch (type) {
8760
  case MYSQL_TYPE_VAR_STRING:
8761
  case MYSQL_TYPE_STRING:
8762
  case FIELD_TYPE_DECIMAL:     return (length);
8763
  case MYSQL_TYPE_VARCHAR:     return (length + (length < 256 ? 1: 2));
unknown's avatar
unknown committed
8764 8765 8766 8767 8768 8769 8770 8771 8772 8773 8774 8775 8776 8777 8778
  case FIELD_TYPE_YEAR:
  case FIELD_TYPE_TINY	: return 1;
  case FIELD_TYPE_SHORT : return 2;
  case FIELD_TYPE_INT24:
  case FIELD_TYPE_NEWDATE:
  case FIELD_TYPE_TIME:   return 3;
  case FIELD_TYPE_TIMESTAMP:
  case FIELD_TYPE_DATE:
  case FIELD_TYPE_LONG	: return 4;
  case FIELD_TYPE_FLOAT : return sizeof(float);
  case FIELD_TYPE_DOUBLE: return sizeof(double);
  case FIELD_TYPE_DATETIME:
  case FIELD_TYPE_LONGLONG: return 8;	/* Don't crash if no longlong */
  case FIELD_TYPE_NULL	: return 0;
  case FIELD_TYPE_TINY_BLOB:	return 1+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
8779
  case FIELD_TYPE_BLOB:		return 2+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
8780 8781
  case FIELD_TYPE_MEDIUM_BLOB:	return 3+portable_sizeof_char_ptr;
  case FIELD_TYPE_LONG_BLOB:	return 4+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
8782
  case FIELD_TYPE_GEOMETRY:	return 4+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
8783
  case FIELD_TYPE_SET:
unknown's avatar
unknown committed
8784
  case FIELD_TYPE_ENUM:
8785 8786
  case FIELD_TYPE_NEWDECIMAL:
    abort(); return 0;                          // This shouldn't happen
unknown's avatar
unknown committed
8787
  case FIELD_TYPE_BIT: return length / 8;
8788 8789
  default:
    return 0;
unknown's avatar
unknown committed
8790 8791 8792 8793 8794 8795 8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806
  }
}


uint pack_length_to_packflag(uint type)
{
  switch (type) {
    case 1: return f_settype((uint) FIELD_TYPE_TINY);
    case 2: return f_settype((uint) FIELD_TYPE_SHORT);
    case 3: return f_settype((uint) FIELD_TYPE_INT24);
    case 4: return f_settype((uint) FIELD_TYPE_LONG);
    case 8: return f_settype((uint) FIELD_TYPE_LONGLONG);
  }
  return 0;					// This shouldn't happen
}


unknown's avatar
unknown committed
8807
Field *make_field(TABLE_SHARE *share, char *ptr, uint32 field_length,
unknown's avatar
unknown committed
8808
		  uchar *null_pos, uchar null_bit,
unknown's avatar
unknown committed
8809
		  uint pack_flag,
8810
		  enum_field_types field_type,
8811
		  CHARSET_INFO *field_charset,
unknown's avatar
unknown committed
8812
		  Field::geometry_type geom_type,
unknown's avatar
unknown committed
8813 8814
		  Field::utype unireg_check,
		  TYPELIB *interval,
unknown's avatar
unknown committed
8815
		  const char *field_name)
unknown's avatar
unknown committed
8816
{
unknown's avatar
unknown committed
8817 8818 8819 8820
  uchar *bit_ptr;
  uchar bit_offset;
  LINT_INIT(bit_ptr);
  LINT_INIT(bit_offset);
8821
  if (field_type == FIELD_TYPE_BIT && !f_bit_as_char(pack_flag))
unknown's avatar
unknown committed
8822 8823 8824 8825 8826 8827 8828 8829 8830 8831
  {
    bit_ptr= null_pos;
    bit_offset= null_bit;
    if (f_maybe_null(pack_flag))         // if null field
    {
       bit_ptr+= (null_bit == 7);        // shift bit_ptr and bit_offset
       bit_offset= (bit_offset + 1) & 7;
    }
  }

unknown's avatar
unknown committed
8832 8833 8834 8835 8836
  if (!f_maybe_null(pack_flag))
  {
    null_pos=0;
    null_bit=0;
  }
unknown's avatar
unknown committed
8837 8838 8839 8840
  else
  {
    null_bit= ((uchar) 1) << null_bit;
  }
unknown's avatar
unknown committed
8841 8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852

  switch (field_type)
  {
    case FIELD_TYPE_DATE:
    case FIELD_TYPE_NEWDATE:
    case FIELD_TYPE_TIME:
    case FIELD_TYPE_DATETIME:
    case FIELD_TYPE_TIMESTAMP:
      field_charset= &my_charset_bin;
    default: break;
  }

unknown's avatar
unknown committed
8853 8854 8855
  if (f_is_alpha(pack_flag))
  {
    if (!f_is_packed(pack_flag))
unknown's avatar
unknown committed
8856
    {
8857
      if (field_type == MYSQL_TYPE_STRING ||
8858
          field_type == FIELD_TYPE_DECIMAL ||   // 3.23 or 4.0 string
8859
          field_type == MYSQL_TYPE_VAR_STRING)
unknown's avatar
unknown committed
8860
        return new Field_string(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8861
                                unireg_check, field_name,
unknown's avatar
unknown committed
8862
                                field_charset);
8863
      if (field_type == MYSQL_TYPE_VARCHAR)
8864 8865 8866
        return new Field_varstring(ptr,field_length,
                                   HA_VARCHAR_PACKLENGTH(field_length),
                                   null_pos,null_bit,
unknown's avatar
unknown committed
8867 8868
                                   unireg_check, field_name,
                                   share,
8869
                                   field_charset);
unknown's avatar
unknown committed
8870 8871
      return 0;                                 // Error
    }
unknown's avatar
unknown committed
8872 8873 8874 8875 8876

    uint pack_length=calc_pack_length((enum_field_types)
				      f_packtype(pack_flag),
				      field_length);

unknown's avatar
unknown committed
8877
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
8878 8879
    if (f_is_geom(pack_flag))
      return new Field_geom(ptr,null_pos,null_bit,
unknown's avatar
unknown committed
8880
			    unireg_check, field_name, share,
unknown's avatar
unknown committed
8881
			    pack_length, geom_type);
unknown's avatar
unknown committed
8882
#endif
unknown's avatar
unknown committed
8883 8884
    if (f_is_blob(pack_flag))
      return new Field_blob(ptr,null_pos,null_bit,
unknown's avatar
unknown committed
8885
			    unireg_check, field_name, share,
unknown's avatar
unknown committed
8886
			    pack_length, field_charset);
unknown's avatar
unknown committed
8887 8888 8889 8890
    if (interval)
    {
      if (f_is_enum(pack_flag))
	return new Field_enum(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8891
				  unireg_check, field_name,
8892
				  pack_length, interval, field_charset);
unknown's avatar
unknown committed
8893 8894
      else
	return new Field_set(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8895
			     unireg_check, field_name,
8896
			     pack_length, interval, field_charset);
unknown's avatar
unknown committed
8897 8898 8899
    }
  }

8900
  switch (field_type) {
unknown's avatar
unknown committed
8901 8902
  case FIELD_TYPE_DECIMAL:
    return new Field_decimal(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8903
			     unireg_check, field_name,
unknown's avatar
unknown committed
8904 8905 8906
			     f_decimals(pack_flag),
			     f_is_zerofill(pack_flag) != 0,
			     f_is_dec(pack_flag) == 0);
unknown's avatar
unknown committed
8907 8908
  case FIELD_TYPE_NEWDECIMAL:
    return new Field_new_decimal(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8909
                                 unireg_check, field_name,
unknown's avatar
unknown committed
8910 8911 8912
                                 f_decimals(pack_flag),
                                 f_is_zerofill(pack_flag) != 0,
                                 f_is_dec(pack_flag) == 0);
unknown's avatar
unknown committed
8913 8914
  case FIELD_TYPE_FLOAT:
    return new Field_float(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8915
			   unireg_check, field_name,
unknown's avatar
unknown committed
8916 8917 8918 8919 8920
			   f_decimals(pack_flag),
			   f_is_zerofill(pack_flag) != 0,
			   f_is_dec(pack_flag)== 0);
  case FIELD_TYPE_DOUBLE:
    return new Field_double(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8921
			    unireg_check, field_name,
unknown's avatar
unknown committed
8922 8923 8924 8925 8926
			    f_decimals(pack_flag),
			    f_is_zerofill(pack_flag) != 0,
			    f_is_dec(pack_flag)== 0);
  case FIELD_TYPE_TINY:
    return new Field_tiny(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8927
			  unireg_check, field_name,
unknown's avatar
unknown committed
8928 8929 8930 8931
			  f_is_zerofill(pack_flag) != 0,
			  f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_SHORT:
    return new Field_short(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8932
			   unireg_check, field_name,
unknown's avatar
unknown committed
8933 8934 8935 8936
			   f_is_zerofill(pack_flag) != 0,
			   f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_INT24:
    return new Field_medium(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8937
			    unireg_check, field_name,
unknown's avatar
unknown committed
8938 8939 8940 8941
			    f_is_zerofill(pack_flag) != 0,
			    f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_LONG:
    return new Field_long(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8942
			   unireg_check, field_name,
unknown's avatar
unknown committed
8943 8944 8945 8946
			   f_is_zerofill(pack_flag) != 0,
			   f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_LONGLONG:
    return new Field_longlong(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8947
			      unireg_check, field_name,
unknown's avatar
unknown committed
8948 8949 8950
			      f_is_zerofill(pack_flag) != 0,
			      f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_TIMESTAMP:
8951
    return new Field_timestamp(ptr,field_length, null_pos, null_bit,
unknown's avatar
unknown committed
8952
                               unireg_check, field_name, share,
8953
                               field_charset);
unknown's avatar
unknown committed
8954 8955
  case FIELD_TYPE_YEAR:
    return new Field_year(ptr,field_length,null_pos,null_bit,
unknown's avatar
unknown committed
8956
			  unireg_check, field_name);
unknown's avatar
unknown committed
8957 8958
  case FIELD_TYPE_DATE:
    return new Field_date(ptr,null_pos,null_bit,
unknown's avatar
unknown committed
8959
			  unireg_check, field_name, field_charset);
unknown's avatar
unknown committed
8960 8961
  case FIELD_TYPE_NEWDATE:
    return new Field_newdate(ptr,null_pos,null_bit,
unknown's avatar
unknown committed
8962
			     unireg_check, field_name, field_charset);
unknown's avatar
unknown committed
8963 8964
  case FIELD_TYPE_TIME:
    return new Field_time(ptr,null_pos,null_bit,
unknown's avatar
unknown committed
8965
			  unireg_check, field_name, field_charset);
unknown's avatar
unknown committed
8966 8967
  case FIELD_TYPE_DATETIME:
    return new Field_datetime(ptr,null_pos,null_bit,
unknown's avatar
unknown committed
8968
			      unireg_check, field_name, field_charset);
unknown's avatar
unknown committed
8969
  case FIELD_TYPE_NULL:
unknown's avatar
unknown committed
8970 8971
    return new Field_null(ptr, field_length, unireg_check, field_name,
                          field_charset);
unknown's avatar
unknown committed
8972
  case FIELD_TYPE_BIT:
8973
    return f_bit_as_char(pack_flag) ?
8974
           new Field_bit_as_char(ptr, field_length, null_pos, null_bit,
8975
                                 unireg_check, field_name) :
8976
           new Field_bit(ptr, field_length, null_pos, null_bit, bit_ptr,
8977
                         bit_offset, unireg_check, field_name);
unknown's avatar
unknown committed
8978

8979 8980
  default:					// Impossible (Wrong version)
    break;
unknown's avatar
unknown committed
8981
  }
unknown's avatar
unknown committed
8982
  return 0;
unknown's avatar
unknown committed
8983 8984 8985 8986 8987
}


/* Create a field suitable for create of table */

8988
create_field::create_field(Field *old_field,Field *orig_field)
unknown's avatar
unknown committed
8989 8990 8991 8992 8993 8994 8995
{
  field=      old_field;
  field_name=change=old_field->field_name;
  length=     old_field->field_length;
  flags=      old_field->flags;
  unireg_check=old_field->unireg_check;
  pack_length=old_field->pack_length();
8996
  key_length= old_field->key_length();
unknown's avatar
unknown committed
8997
  sql_type=   old_field->real_type();
unknown's avatar
unknown committed
8998 8999
  charset=    old_field->charset();		// May be NULL ptr
  comment=    old_field->comment;
9000
  decimals=   old_field->decimals();
unknown's avatar
unknown committed
9001 9002 9003

  /* Fix if the original table had 4 byte pointer blobs */
  if (flags & BLOB_FLAG)
9004
    pack_length= (pack_length- old_field->table->s->blob_ptr_size +
unknown's avatar
unknown committed
9005
		  portable_sizeof_char_ptr);
9006

9007 9008 9009 9010 9011 9012 9013 9014 9015 9016 9017
  switch (sql_type) {
  case FIELD_TYPE_BLOB:
    switch (pack_length - portable_sizeof_char_ptr) {
    case  1: sql_type= FIELD_TYPE_TINY_BLOB; break;
    case  2: sql_type= FIELD_TYPE_BLOB; break;
    case  3: sql_type= FIELD_TYPE_MEDIUM_BLOB; break;
    default: sql_type= FIELD_TYPE_LONG_BLOB; break;
    }
    length=(length+charset->mbmaxlen-1) / charset->mbmaxlen;
    key_length/= charset->mbmaxlen;
    break;
9018
  case MYSQL_TYPE_STRING:
unknown's avatar
unknown committed
9019
    /* Change CHAR -> VARCHAR if dynamic record length */
9020 9021 9022 9023 9024 9025 9026 9027
    if (old_field->type() == MYSQL_TYPE_VAR_STRING)
      sql_type= MYSQL_TYPE_VARCHAR;
    /* fall through */

  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_SET:
  case MYSQL_TYPE_VARCHAR:
  case MYSQL_TYPE_VAR_STRING:
9028
    /* This is corrected in create_length_to_internal_length */
9029 9030 9031 9032 9033 9034 9035 9036 9037
    length= (length+charset->mbmaxlen-1) / charset->mbmaxlen;
    break;
#ifdef HAVE_SPATIAL
  case FIELD_TYPE_GEOMETRY:
    geom_type= ((Field_geom*)old_field)->geom_type;
    break;
#endif
  default:
    break;
unknown's avatar
unknown committed
9038
  }
9039

unknown's avatar
unknown committed
9040 9041 9042 9043
  if (flags & (ENUM_FLAG | SET_FLAG))
    interval= ((Field_enum*) old_field)->typelib;
  else
    interval=0;
9044
  def=0;
9045
  char_length= length;
9046

9047
  if (!(flags & (NO_DEFAULT_VALUE_FLAG | BLOB_FLAG)) &&
9048 9049 9050 9051
      old_field->ptr && orig_field &&
      (sql_type != FIELD_TYPE_TIMESTAMP ||                /* set def only if */
       old_field->table->timestamp_field != old_field ||  /* timestamp field */ 
       unireg_check == Field::TIMESTAMP_UN_FIELD))        /* has default val */
unknown's avatar
unknown committed
9052 9053
  {
    char buff[MAX_FIELD_WIDTH],*pos;
9054 9055
    String tmp(buff,sizeof(buff), charset), *res;
    my_ptrdiff_t diff;
unknown's avatar
unknown committed
9056
    bool is_null;
9057

unknown's avatar
unknown committed
9058
    /* Get the value from default_values */
9059 9060
    diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
                          orig_field->table->record[0]);
unknown's avatar
unknown committed
9061 9062
    orig_field->move_field_offset(diff);	// Points now at default_values
    is_null= orig_field->is_real_null();
9063
    res= orig_field->val_str(&tmp);
unknown's avatar
unknown committed
9064
    orig_field->move_field_offset(-diff);	// Back to record[0]
9065
    if (!is_null)
9066
    {
9067 9068
      pos= (char*) sql_strmake(res->ptr(), res->length());
      def= new Item_string(pos, res->length(), charset);
9069
    }
unknown's avatar
unknown committed
9070 9071
  }
}
9072 9073


9074 9075 9076 9077 9078 9079 9080 9081 9082 9083 9084 9085 9086 9087
/*
  maximum possible display length for blob

  SYNOPSIS
    Field_blob::max_length()

  RETURN
    length
*/
uint32 Field_blob::max_length()
{
  switch (packlength)
  {
  case 1:
9088
    return 255 * field_charset->mbmaxlen;
9089
  case 2:
9090
    return 65535 * field_charset->mbmaxlen;
9091
  case 3:
9092
    return 16777215 * field_charset->mbmaxlen;
9093 9094 9095 9096 9097 9098 9099 9100 9101 9102 9103 9104
  case 4:
    return (uint32) 4294967295U;
  default:
    DBUG_ASSERT(0); // we should never go here
    return 0;
  }
}


/*****************************************************************************
 Warning handling
*****************************************************************************/
9105 9106 9107 9108

/*
  Produce warning or note about data saved into field

unknown's avatar
unknown committed
9109
  SYNOPSIS
9110 9111 9112 9113 9114 9115 9116 9117 9118 9119
    set_warning()
      level            - level of message (Note/Warning/Error)
      code             - error code of message to be produced
      cuted_increment  - whenever we should increase cut fields count or not

  NOTE
    This function won't produce warning and increase cut fields counter
    if count_cuted_fields == FIELD_CHECK_IGNORE for current thread.

  RETURN VALUE
9120 9121
    1 if count_cuted_fields == FIELD_CHECK_IGNORE
    0 otherwise
9122
*/
9123

9124
bool 
9125 9126
Field::set_warning(MYSQL_ERROR::enum_warning_level level, uint code,
                   int cuted_increment)
9127
{
9128
  THD *thd= table->in_use;
unknown's avatar
unknown committed
9129 9130
  if (thd->count_cuted_fields)
  {
9131
    thd->cuted_fields+= cuted_increment;
9132 9133
    push_warning_printf(thd, level, code, ER(code), field_name,
                        thd->row_count);
9134 9135 9136 9137 9138 9139 9140 9141 9142
    return 0;
  }
  return 1;
}


/*
  Produce warning or note about datetime string data saved into field

unknown's avatar
unknown committed
9143
  SYNOPSIS
unknown's avatar
unknown committed
9144
    set_datime_warning()
9145 9146 9147 9148 9149 9150 9151 9152 9153 9154 9155 9156
      level            - level of message (Note/Warning/Error)
      code             - error code of message to be produced
      str              - string value which we tried to save
      str_len          - length of string which we tried to save
      ts_type          - type of datetime value (datetime/date/time)
      cuted_increment  - whenever we should increase cut fields count or not
  
  NOTE
    This function will always produce some warning but won't increase cut 
    fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current 
    thread.
*/
9157

9158
void 
9159
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
9160 9161 9162
                            const char *str, uint str_length, 
                            timestamp_type ts_type, int cuted_increment)
{
unknown's avatar
unknown committed
9163 9164 9165 9166
  if (table->in_use->really_abort_on_warning() ||
      set_warning(level, code, cuted_increment))
    make_truncated_value_warning(table->in_use, str, str_length, ts_type,
                                 field_name);
9167 9168 9169 9170 9171 9172
}


/*
  Produce warning or note about integer datetime value saved into field

unknown's avatar
unknown committed
9173
  SYNOPSIS
9174 9175 9176 9177 9178 9179 9180 9181 9182 9183 9184 9185
    set_warning()
      level            - level of message (Note/Warning/Error)
      code             - error code of message to be produced
      nr               - numeric value which we tried to save
      ts_type          - type of datetime value (datetime/date/time)
      cuted_increment  - whenever we should increase cut fields count or not
  
  NOTE
    This function will always produce some warning but won't increase cut 
    fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current 
    thread.
*/
9186

9187
void 
9188
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
9189 9190 9191
                            longlong nr, timestamp_type ts_type,
                            int cuted_increment)
{
unknown's avatar
unknown committed
9192 9193
  if (table->in_use->really_abort_on_warning() ||
      set_warning(level, code, cuted_increment))
9194 9195 9196
  {
    char str_nr[22];
    char *str_end= longlong10_to_str(nr, str_nr, -10);
9197 9198
    make_truncated_value_warning(table->in_use, str_nr, 
                                 (uint) (str_end - str_nr), 
unknown's avatar
unknown committed
9199
                                 ts_type, field_name);
9200 9201 9202 9203 9204 9205 9206
  }
}


/*
  Produce warning or note about double datetime data saved into field

unknown's avatar
unknown committed
9207
  SYNOPSIS
9208 9209 9210 9211 9212 9213 9214 9215 9216 9217 9218
    set_warning()
      level            - level of message (Note/Warning/Error)
      code             - error code of message to be produced
      nr               - double value which we tried to save
      ts_type          - type of datetime value (datetime/date/time)
  
  NOTE
    This function will always produce some warning but won't increase cut 
    fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current 
    thread.
*/
9219

9220
void 
9221
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
9222 9223
                            double nr, timestamp_type ts_type)
{
unknown's avatar
unknown committed
9224 9225
  if (table->in_use->really_abort_on_warning() ||
      set_warning(level, code, 1))
9226 9227 9228 9229
  {
    /* DBL_DIG is enough to print '-[digits].E+###' */
    char str_nr[DBL_DIG + 8];
    uint str_len= my_sprintf(str_nr, (str_nr, "%g", nr));
unknown's avatar
unknown committed
9230 9231
    make_truncated_value_warning(table->in_use, str_nr, str_len, ts_type,
                                 field_name);
unknown's avatar
unknown committed
9232
  }
9233
}