field.cc 233 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 70 71 72 73 74
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);
}

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

/*
  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
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
/*
  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,
                     struct st_table *table_arg,
                     uint8 dec_arg, bool zero_arg, bool unsigned_arg)
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
         unireg_check_arg, field_name_arg, table_arg),
  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;
}


1218 1219
/* This is used as a table name when the table structure is not set up */
const char *unknown_table_name= 0;
unknown's avatar
unknown committed
1220 1221

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

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
1249 1250
    *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) |
			null_ptr[row_offset] & (uchar) null_bit);
unknown's avatar
unknown committed
1251 1252 1253 1254
  }
}


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


unknown's avatar
unknown committed
1264 1265 1266 1267 1268 1269 1270 1271
my_decimal *Field::val_decimal(my_decimal *decimal)
{
  /* This never have to be called */
  DBUG_ASSERT(0);
  return 0;
}


unknown's avatar
unknown committed
1272 1273
void Field_num::add_zerofill_and_unsigned(String &res) const
{
1274
  if (unsigned_flag)
1275
    res.append(STRING_WITH_LEN(" unsigned"));
1276
  if (zerofill)
1277
    res.append(STRING_WITH_LEN(" zerofill"));
unknown's avatar
unknown committed
1278 1279
}

unknown's avatar
unknown committed
1280

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


unknown's avatar
unknown committed
1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
/*
  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
1325
    else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
unknown's avatar
unknown committed
1326 1327 1328 1329 1330 1331 1332
                                           ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
                                           val, TRUE, &i)))
    {
      i= ~(longlong) 0;
      *err= 1;
    }
  }
unknown's avatar
unknown committed
1333
  else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
unknown's avatar
unknown committed
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 1359 1360 1361 1362
                                         ~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);
1363
  return test(err | store(i, unsigned_flag));
unknown's avatar
unknown committed
1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
}


/*
  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();
1387
  int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
unknown's avatar
unknown committed
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
  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,
                     const char *field_name_arg,
                     struct st_table *table_arg,CHARSET_INFO *charset)
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
         unireg_check_arg, field_name_arg, table_arg)
{
  field_charset=charset;
  if (charset->state & MY_CS_BINSORT)
    flags|=BINARY_FLAG;
}


1405
void Field_num::make_field(Send_field *field)
unknown's avatar
unknown committed
1406
{
1407 1408
  Field::make_field(field);
  field->decimals= dec;
unknown's avatar
unknown committed
1409 1410
}

unknown's avatar
unknown committed
1411 1412 1413 1414 1415 1416 1417 1418
/*
  Decimal representation of Field_str

  SYNOPSIS
    Field_str::store_decimal()
    d         value for storing

  NOTE
1419
    Field_str is the base class for fields like Field_enum, Field_date and some
unknown's avatar
unknown committed
1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
    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
1433
  int err= warn_if_overflow(my_decimal2double(E_DEC_FATAL_ERROR &
unknown's avatar
unknown committed
1434 1435 1436 1437 1438 1439 1440 1441
                                            ~E_DEC_OVERFLOW, d, &val));
  return err | store(val);
}


my_decimal *Field_str::val_decimal(my_decimal *decimal_value)
{
  longlong nr= val_int();
1442
  int2my_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value);
unknown's avatar
unknown committed
1443 1444 1445
  return decimal_value;
}

1446

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

1475 1476

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

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

1497 1498 1499 1500 1501 1502
/*
  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
1503

1504
int Field::store_time(TIME *ltime, timestamp_type type)
unknown's avatar
unknown committed
1505
{
1506 1507
  char buff[MAX_DATE_STRING_REP_LENGTH];
  uint length= (uint) my_TIME_to_str(ltime, buff);
1508
  return store(buff, length, &my_charset_bin);
unknown's avatar
unknown committed
1509 1510 1511
}


1512
bool Field::optimize_range(uint idx, uint part)
unknown's avatar
unknown committed
1513
{
1514
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
unknown's avatar
unknown committed
1515 1516
}

1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536

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);
  tmp->unireg_check=Field::NONE;
  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
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551

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;
}

1552

1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568
/* 
  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

*/
1569

1570 1571 1572 1573 1574
bool Field::quote_data(String *unquoted_string)
{
  char escaped_string[IO_SIZE];
  char *unquoted_string_buffer= (char *)(unquoted_string->ptr());
  DBUG_ENTER("Field::quote_data");
1575

unknown's avatar
unknown committed
1576
  if (!needs_quotes())
1577
    DBUG_RETURN(0);
1578

unknown's avatar
unknown committed
1579 1580 1581 1582 1583 1584
  // 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);

1585 1586
  // reset string, then re-append with quotes and escaped values
  unquoted_string->length(0);
unknown's avatar
unknown committed
1587 1588 1589
  if (unquoted_string->append('\'') ||
      unquoted_string->append((char *)escaped_string) ||
      unquoted_string->append('\''))
1590
    DBUG_RETURN(1);
1591 1592 1593
  DBUG_RETURN(0);
}

1594

1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609
/*
  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
*/
1610

1611 1612 1613 1614
bool Field::needs_quotes(void)
{
  DBUG_ENTER("Field::type_quote");

1615
  switch (type()) {
1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
    //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
1631
  case FIELD_TYPE_BIT:
1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
    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);
1646 1647
  default:
    DBUG_RETURN(0);
1648 1649
  }
}
unknown's avatar
unknown committed
1650

1651

1652
/****************************************************************************
1653
  Field_null, a field that always return NULL
1654 1655 1656 1657
****************************************************************************/

void Field_null::sql_type(String &res) const
{
1658
  res.set_ascii(STRING_WITH_LEN("null"));
1659 1660 1661
}


unknown's avatar
unknown committed
1662
/****************************************************************************
unknown's avatar
unknown committed
1663 1664
  Functions for the Field_decimal class
  This is an number stored as a pre-space (or pre-zero) string
unknown's avatar
unknown committed
1665 1666 1667 1668 1669
****************************************************************************/

void
Field_decimal::reset(void)
{
1670
  Field_decimal::store(STRING_WITH_LEN("0"),&my_charset_bin);
unknown's avatar
unknown committed
1671 1672 1673 1674 1675
}

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

1678
  set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1679
  if (negative)
unknown's avatar
unknown committed
1680
  {
1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
    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
1704
  }
1705
  bfill(to, len, filler);
unknown's avatar
unknown committed
1706 1707 1708 1709 1710 1711
  if (dec)
    ptr[field_length-dec-1]='.';
  return;
}


unknown's avatar
unknown committed
1712
int Field_decimal::store(const char *from, uint len, CHARSET_INFO *cs)
unknown's avatar
unknown committed
1713
{
unknown's avatar
unknown committed
1714
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
1715
  String tmp(buff,sizeof(buff), &my_charset_bin);
1716

1717 1718 1719
  /* Convert character set if the old one is multi byte */
  if (cs->mbmaxlen > 1)
  { 
1720 1721
    uint dummy_errors;
    tmp.copy(from, len, cs, &my_charset_bin, &dummy_errors);
1722 1723 1724
    from= tmp.ptr();
    len=  tmp.length();
  }
1725

1726 1727 1728 1729 1730 1731 1732 1733 1734
  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
1735
  /* The pointers where prezeros start and stop */
1736
  const char *pre_zeros_from, *pre_zeros_end;
unknown's avatar
unknown committed
1737
  /* The pointers where digits at the left of '.' start and stop */
1738
  const char *int_digits_from, *int_digits_end;
unknown's avatar
unknown committed
1739
  /* The pointers where digits at the right of '.' start and stop */
1740
  const char *frac_digits_from, *frac_digits_end;
unknown's avatar
unknown committed
1741
  /* The sign of the exponent : will be 0 (means no exponent), '+' or '-' */
1742
  char expo_sign_char=0;
unknown's avatar
unknown committed
1743
  uint exponent=0;                                // value of the exponent
1744 1745 1746 1747 1748 1749 1750
  /*
    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
1751 1752 1753 1754
  /*
    Pointer used when digits move from the right of the '.' to the left
    of the '.'
  */
1755
  const char *frac_digits_head_end;
unknown's avatar
unknown committed
1756
  /* Number of 0 that need to be added at the right of the '.' (for 1E-3) */
1757 1758 1759 1760 1761
  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
1762
  /*
1763
    To remember if table->in_use->cuted_fields has already been incremented,
unknown's avatar
unknown committed
1764 1765
    to do that only once
  */
1766 1767 1768 1769 1770 1771 1772 1773 1774
  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
1775 1776
    - parse the input string
    - modify the position of digits around the decimal dot '.' 
1777
      according to the exponent value (if specified)
unknown's avatar
unknown committed
1778
    - write the formatted number
1779 1780 1781 1782 1783
  */

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

unknown's avatar
unknown committed
1784
  /* skip pre-space */
unknown's avatar
unknown committed
1785
  while (from != end && my_isspace(&my_charset_bin,*from))
unknown's avatar
unknown committed
1786
    from++;
1787
  if (from == end)
unknown's avatar
unknown committed
1788
  {
1789
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
1790
    is_cuted_fields_incr=1;
unknown's avatar
unknown committed
1791
  }
1792
  else if (*from == '+' || *from == '-')	// Found some sign ?
unknown's avatar
unknown committed
1793
  {
1794
    sign_char= *from++;
unknown's avatar
unknown committed
1795
    /*
1796 1797 1798
      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
1799 1800 1801 1802
    */ 
    if (unsigned_flag)  
    { 
      if (sign_char=='-')
1803
      {
1804
        Field_decimal::overflow(1);
unknown's avatar
unknown committed
1805
        return 1;
1806
      }
1807
      /* 
unknown's avatar
unknown committed
1808 1809
	 Defining this will not store "+" for unsigned decimal type even if
	 it is passed in numeric string. This will make some tests to fail
1810 1811
      */	 
#ifdef DONT_ALLOW_UNSIGNED_PLUS      
1812 1813
      else 
        sign_char=0;
1814
#endif 	
unknown's avatar
unknown committed
1815
    }
1816
  }
unknown's avatar
unknown committed
1817

1818 1819 1820 1821
  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
1822
  for (; from != end && my_isdigit(&my_charset_bin, *from) ; from++) ;
1823 1824 1825 1826 1827
  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
1828
  for (;from!=end && my_isdigit(&my_charset_bin, *from); from++) ;
1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
  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= '+';
    /*
1839 1840 1841 1842
      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).
1843
    */
unknown's avatar
unknown committed
1844
    for (;from!=end && my_isdigit(&my_charset_bin, *from); from++)
1845
    {
1846
      exponent=10*exponent+(*from-'0');
unknown's avatar
unknown committed
1847
      if (exponent>MAX_EXPONENT)
1848 1849
        break;
    }
unknown's avatar
unknown committed
1850
  }
1851
  
unknown's avatar
unknown committed
1852
  /*
1853 1854
    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
1855
    Even if this flag is not set, it's OK to increment warnings, if
1856
    it makes the code easer to read.
unknown's avatar
unknown committed
1857
  */
1858

1859
  if (table->in_use->count_cuted_fields)
unknown's avatar
unknown committed
1860
  {
1861
    // Skip end spaces
unknown's avatar
unknown committed
1862
    for (;from != end && my_isspace(&my_charset_bin, *from); from++) ;
1863
    if (from != end)                     // If still something left, warn
unknown's avatar
unknown committed
1864
    {
1865
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
1866
      is_cuted_fields_incr=1;
unknown's avatar
unknown committed
1867
    }
1868 1869 1870 1871 1872 1873
  }
  
  /*
    Now "move" digits around the decimal dot according to the exponent value,
    and add necessary zeros.
    Examples :
unknown's avatar
unknown committed
1874 1875 1876
    - 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'
1877
    - 1234.5E-3 : '234' moves at the right of '.'
unknown's avatar
unknown committed
1878 1879
    These moves are implemented with pointers which point at the begin
    and end of each moved segment. Examples :
1880
    - 1234.5E-3 : before the code below is executed, the int_digits part is
unknown's avatar
unknown committed
1881 1882 1883
    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'.
1884
    - 1234.5E3 : before the code below is executed, the int_digits part is
unknown's avatar
unknown committed
1885 1886 1887 1888
    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).
1889 1890
  */
  
1891
  /* 
unknown's avatar
unknown committed
1892
     Below tmp_uint cannot overflow with small enough MAX_EXPONENT setting,
1893
     as int_digits_added_zeros<=exponent<4G and 
1894 1895
     (int_digits_end-int_digits_from)<=max_allowed_packet<=2G and
     (frac_digits_from-int_digits_tail_from)<=max_allowed_packet<=2G
1896 1897
  */

1898 1899 1900 1901 1902 1903 1904 1905
  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
1906
    tmp_uint=tmp_dec+(uint)(int_digits_end-int_digits_from);     
1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931
  }
  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
1932
    }
1933
    tmp_uint= (uint) (tmp_dec+(int_digits_end-int_digits_from)+
1934 1935
               (uint)(frac_digits_from-int_digits_tail_from)+
               int_digits_added_zeros);
1936 1937 1938 1939 1940 1941 1942 1943 1944 1945
  }
  
  /*
    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
  */

1946
  if (field_length < tmp_uint + (int) (sign_char == '-')) 
1947
  {
unknown's avatar
unknown committed
1948
    // too big number, change to max or min number
1949
    Field_decimal::overflow(sign_char == '-');
1950
    return 1;
unknown's avatar
unknown committed
1951
  }
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968
 
  /*
    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
1969
  }
1970 1971 1972 1973 1974 1975
  /*
    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
1976 1977

  /*
1978 1979
    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
1980
  */
1981 1982 1983 1984
  pos=tmp_left_pos-1;
  if (zerofill)
  {
    left_wall=to-1;
1985
    while (pos > left_wall)			// Fill with zeros
1986 1987 1988 1989
      *pos--='0';
  }
  else
  {
unknown's avatar
unknown committed
1990
    left_wall=to+(sign_char != 0)-1;
1991 1992
    if (!expo_sign_char)	// If exponent was specified, ignore prezeros
    {
1993
      for (;pos > left_wall && pre_zeros_from !=pre_zeros_end;
1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008
	   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
  }
  
2009 2010
  /*
    Write digits of the frac_% parts ;
2011
    Depending on table->in_use->count_cutted_fields, we may also want
2012 2013 2014 2015 2016
    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)
  */
2017
      
2018 2019 2020
  pos=to+(uint)(field_length-tmp_dec);	// Calculate post to '.'
  right_wall=to+field_length;
  if (pos != right_wall) 
2021 2022
    *pos++='.';

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

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


unknown's avatar
unknown committed
2081
int Field_decimal::store(double nr)
unknown's avatar
unknown committed
2082 2083 2084 2085
{
  if (unsigned_flag && nr < 0)
  {
    overflow(1);
2086
    return 1;
unknown's avatar
unknown committed
2087
  }
2088
  
2089 2090
#ifdef HAVE_FINITE
  if (!finite(nr)) // Handle infinity as special case
2091 2092
  {
    overflow(nr < 0.0);
unknown's avatar
unknown committed
2093
    return 1;
2094
  }
2095
#endif
unknown's avatar
unknown committed
2096

unknown's avatar
unknown committed
2097 2098
  reg4 uint i,length;
  char fyllchar,*to;
2099
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
unknown's avatar
unknown committed
2100 2101

  fyllchar = zerofill ? (char) '0' : (char) ' ';
unknown's avatar
unknown committed
2102
#ifdef HAVE_SNPRINTF
unknown's avatar
unknown committed
2103 2104
  buff[sizeof(buff)-1]=0;			// Safety
  snprintf(buff,sizeof(buff)-1, "%.*f",(int) dec,nr);
2105
  length=(uint) strlen(buff);
unknown's avatar
unknown committed
2106
#else
2107
  length=(uint) my_sprintf(buff,(buff,"%.*f",dec,nr));
unknown's avatar
unknown committed
2108
#endif
unknown's avatar
unknown committed
2109 2110 2111 2112

  if (length > field_length)
  {
    overflow(nr < 0.0);
2113
    return 1;
unknown's avatar
unknown committed
2114 2115 2116 2117 2118 2119 2120
  }
  else
  {
    to=ptr;
    for (i=field_length-length ; i-- > 0 ;)
      *to++ = fyllchar;
    memcpy(to,buff,length);
2121
    return 0;
unknown's avatar
unknown committed
2122 2123 2124 2125
  }
}


2126
int Field_decimal::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
2127
{
2128 2129 2130 2131 2132
  char buff[22];
  uint length, int_part;
  char fyllchar, *to;

  if (nr < 0 && unsigned_flag && !unsigned_val)
unknown's avatar
unknown committed
2133 2134
  {
    overflow(1);
2135
    return 1;
unknown's avatar
unknown committed
2136
  }
2137 2138
  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
2139 2140 2141

  if (length > int_part)
  {
2142
    overflow(!unsigned_val && nr < 0L);		/* purecov: inspected */
2143
    return 1;
unknown's avatar
unknown committed
2144
  }
2145 2146 2147 2148 2149 2150 2151

  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
2152
  {
2153 2154
    to[length]='.';
    bfill(to+length+1,dec,'0');
unknown's avatar
unknown committed
2155
  }
2156
  return 0;
unknown's avatar
unknown committed
2157 2158 2159 2160 2161
}


double Field_decimal::val_real(void)
{
2162
  int not_used;
2163 2164 2165
  char *end_not_used;
  return my_strntod(&my_charset_bin, ptr, field_length, &end_not_used,
                    &not_used);
unknown's avatar
unknown committed
2166 2167 2168 2169
}

longlong Field_decimal::val_int(void)
{
2170
  int not_used;
unknown's avatar
unknown committed
2171
  if (unsigned_flag)
unknown's avatar
unknown committed
2172
    return my_strntoull(&my_charset_bin, ptr, field_length, 10, NULL,
2173
			&not_used);
unknown's avatar
unknown committed
2174
  else
unknown's avatar
unknown committed
2175
    return my_strntoll(&my_charset_bin, ptr, field_length, 10, NULL,
2176
			&not_used);
unknown's avatar
unknown committed
2177 2178
}

2179

unknown's avatar
unknown committed
2180 2181 2182 2183 2184 2185
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
2186
  val_ptr->set_charset(&my_charset_bin);
unknown's avatar
unknown committed
2187 2188 2189
  if (field_length < tmp_length)		// Error in data
    val_ptr->length(0);
  else
2190
    val_ptr->set_ascii((const char*) str, field_length-tmp_length);
unknown's avatar
unknown committed
2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
  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;
2202
  int swap=0;
unknown's avatar
unknown committed
2203 2204 2205 2206
  /* First remove prefixes '0', ' ', and '-' */
  for (end=a_ptr+field_length;
       a_ptr != end &&
	 (*a_ptr == *b_ptr ||
unknown's avatar
unknown committed
2207
	  ((my_isspace(&my_charset_bin,*a_ptr)  || *a_ptr == '+' || 
2208
            *a_ptr == '0') &&
unknown's avatar
unknown committed
2209
	   (my_isspace(&my_charset_bin,*b_ptr) || *b_ptr == '+' || 
2210
            *b_ptr == '0')));
2211 2212 2213 2214 2215
       a_ptr++,b_ptr++)
  {
    if (*a_ptr == '-')				// If both numbers are negative
      swap= -1 ^ 1;				// Swap result      
  }
unknown's avatar
unknown committed
2216 2217 2218
  if (a_ptr == end)
    return 0;
  if (*a_ptr == '-')
2219
    return -1;
2220
  if (*b_ptr == '-')
unknown's avatar
unknown committed
2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236
    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
2237
	 ((my_isspace(&my_charset_bin,*str) || *str == '+' ||
unknown's avatar
unknown committed
2238
	   *str == '0')) ;
unknown's avatar
unknown committed
2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
       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
2249
      if (my_isdigit(&my_charset_bin,*str))
unknown's avatar
unknown committed
2250 2251 2252 2253 2254 2255 2256
	*to++= (char) ('9' - *str++);
      else
	*to++= *str++;
  }
  else memcpy(to,str,(uint) (end-str));
}

unknown's avatar
unknown committed
2257

unknown's avatar
unknown committed
2258 2259
void Field_decimal::sql_type(String &res) const
{
unknown's avatar
unknown committed
2260
  CHARSET_INFO *cs=res.charset();
unknown's avatar
unknown committed
2261 2262 2263 2264 2265
  uint tmp=field_length;
  if (!unsigned_flag)
    tmp--;
  if (dec)
    tmp--;
2266
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2267
			  "decimal(%d,%d)",tmp,dec));
unknown's avatar
unknown committed
2268 2269 2270 2271
  add_zerofill_and_unsigned(res);
}


unknown's avatar
unknown committed
2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283
/****************************************************************************
** 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,
                                     struct st_table *table_arg,
                                     uint8 dec_arg,bool zero_arg,
                                     bool unsigned_arg)
unknown's avatar
unknown committed
2284
  :Field_num(ptr_arg, len_arg,
unknown's avatar
unknown committed
2285 2286
             null_ptr_arg, null_bit_arg,
             unireg_check_arg, field_name_arg, table_arg,
unknown's avatar
unknown committed
2287
             dec_arg, zero_arg, unsigned_arg)
unknown's avatar
unknown committed
2288
{
unknown's avatar
unknown committed
2289 2290 2291 2292
  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
2293 2294 2295 2296 2297 2298 2299
}


Field_new_decimal::Field_new_decimal(uint32 len_arg,
                                     bool maybe_null,
                                     const char *name,
                                     struct st_table *t_arg,
unknown's avatar
unknown committed
2300 2301 2302
                                     uint8 dec_arg,
                                     bool unsigned_arg)
  :Field_num((char*) 0, len_arg,
unknown's avatar
unknown committed
2303 2304
             maybe_null ? (uchar*) "": 0, 0,
             NONE, name, t_arg,
unknown's avatar
unknown committed
2305 2306
             dec_arg,
             0, unsigned_arg)
unknown's avatar
unknown committed
2307
{
unknown's avatar
unknown committed
2308 2309 2310 2311
  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
2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333
}


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
2334
  max_my_decimal(decimal_value, precision, decimals());
unknown's avatar
unknown committed
2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356
  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
2357 2358 2359 2360

  RETURN
   0 ok
   1 error
unknown's avatar
unknown committed
2361 2362 2363 2364
*/

bool Field_new_decimal::store_value(const my_decimal *decimal_value)
{
unknown's avatar
unknown committed
2365 2366
  int error= 0;
  DBUG_ENTER("Field_new_decimal::store_value");
unknown's avatar
unknown committed
2367 2368 2369 2370 2371 2372
#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
2373 2374 2375 2376 2377 2378

  /* 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
2379
    error= 1;
unknown's avatar
unknown committed
2380 2381 2382 2383 2384 2385 2386 2387
    decimal_value= &decimal_zero;
  }
#ifndef DBUG_OFF
  {
    char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
    DBUG_PRINT("info", ("saving with precision %d, scale: %d, value %s",
                        (int)precision, (int)dec,
                        dbug_decimal_as_string(dbug_buff, decimal_value)));
unknown's avatar
unknown committed
2388
  }
unknown's avatar
unknown committed
2389
#endif
unknown's avatar
unknown committed
2390

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


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

2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425
  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
2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442
  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
2443 2444 2445 2446 2447
#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
2448 2449 2450 2451 2452 2453 2454 2455
  store_value(&decimal_value);
  DBUG_RETURN(err);
}


int Field_new_decimal::store(double nr)
{
  my_decimal decimal_value;
unknown's avatar
unknown committed
2456 2457 2458 2459 2460
  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
2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
  /*
    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
2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483
  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
2484 2485 2486
}


2487
int Field_new_decimal::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
2488 2489 2490
{
  my_decimal decimal_value;
  int err;
unknown's avatar
unknown committed
2491 2492

  if ((err= int2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
2493
                           nr, unsigned_val, &decimal_value)))
unknown's avatar
unknown committed
2494 2495 2496 2497 2498 2499 2500 2501 2502 2503
  {
    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
2504 2505 2506 2507 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
  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
2537
                    precision, dec);
2538 2539
  DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (byte *) ptr,
                                          bin_size););
unknown's avatar
unknown committed
2540 2541 2542 2543 2544
  DBUG_RETURN(decimal_value);
}


String *Field_new_decimal::val_str(String *val_buffer,
unknown's avatar
unknown committed
2545
                                   String *val_ptr __attribute__((unused)))
unknown's avatar
unknown committed
2546 2547
{
  my_decimal decimal_value;
unknown's avatar
unknown committed
2548
  uint fixed_precision= zerofill ? precision : 0;
unknown's avatar
unknown committed
2549
  my_decimal2string(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
unknown's avatar
unknown committed
2550
                    fixed_precision, dec, '0', val_buffer);
unknown's avatar
unknown committed
2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571
  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
2572
                                "decimal(%d,%d)", precision, (int)dec));
unknown's avatar
unknown committed
2573 2574 2575
  add_zerofill_and_unsigned(str);
}

unknown's avatar
unknown committed
2576

unknown's avatar
unknown committed
2577 2578 2579 2580
/****************************************************************************
** tiny int
****************************************************************************/

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

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


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

2668 2669

int Field_tiny::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
2670
{
unknown's avatar
unknown committed
2671
  int error= 0;
2672

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


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

2720

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

2728

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

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

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

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
2775
  CHARSET_INFO *cs=res.charset();
2776
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2777
			  "tinyint(%d)",(int) field_length));
unknown's avatar
unknown committed
2778 2779 2780 2781
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
2782
 Field type short int (2 byte)
unknown's avatar
unknown committed
2783 2784
****************************************************************************/

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

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


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

2888 2889

int Field_short::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
2890
{
unknown's avatar
unknown committed
2891
  int error= 0;
unknown's avatar
unknown committed
2892
  int16 res;
2893

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

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


double Field_short::val_real(void)
{
  short j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
2947
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958
    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
2959
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
2960 2961 2962 2963 2964 2965 2966
    j=sint2korr(ptr);
  else
#endif
    shortget(j,ptr);
  return unsigned_flag ? (longlong) (unsigned short) j : (longlong) j;
}

2967

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

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


2996 2997 2998 2999 3000 3001
bool Field_short::send_binary(Protocol *protocol)
{
  return protocol->store_short(Field_short::val_int());
}


unknown's avatar
unknown committed
3002 3003 3004 3005
int Field_short::cmp(const char *a_ptr, const char *b_ptr)
{
  short a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3006
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026
  {
    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
3027
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
3028 3029 3030 3031
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
unknown's avatar
unknown committed
3032
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3033 3034 3035 3036 3037 3038 3039 3040
    to[1]   = ptr[1];
  }
  else
#endif
  {
    if (unsigned_flag)
      to[0] = ptr[1];
    else
unknown's avatar
unknown committed
3041
      to[0] = (char) (ptr[1] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3042 3043 3044 3045 3046 3047
    to[1]   = ptr[0];
  }
}

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


/****************************************************************************
3056
  Field type medium int (3 byte)
unknown's avatar
unknown committed
3057 3058
****************************************************************************/

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

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

  int3store(ptr,tmp);
3102
  return error;
unknown's avatar
unknown committed
3103 3104 3105
}


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

3150 3151

int Field_medium::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
3152
{
unknown's avatar
unknown committed
3153
  int error= 0;
3154

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

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


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

3205

unknown's avatar
unknown committed
3206 3207 3208 3209 3210 3211
longlong Field_medium::val_int(void)
{
  long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
  return (longlong) j;
}

3212

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

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


3231 3232 3233 3234 3235 3236
bool Field_medium::send_binary(Protocol *protocol)
{
  return protocol->store_long(Field_medium::val_int());
}


unknown's avatar
unknown committed
3237 3238 3239 3240 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
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
3266
  CHARSET_INFO *cs=res.charset();
3267
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(), 
3268
			  "mediumint(%d)",(int) field_length));
unknown's avatar
unknown committed
3269 3270 3271 3272 3273 3274 3275
  add_zerofill_and_unsigned(res);
}

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

unknown's avatar
unknown committed
3276 3277 3278 3279 3280
/*
  A helper function to check whether the next character
  in the string "s" is MINUS SIGN. 
*/
#ifdef HAVE_CHARSET_ucs2
3281 3282 3283 3284 3285 3286
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
3287 3288 3289 3290 3291 3292
#else
/*
  If not UCS2 support is compiled then it is easier
*/
#define test_if_minus(cs, s, e)  (*s == '-')
#endif
3293

unknown's avatar
unknown committed
3294

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

3303 3304 3305
  tmp_scan= cs->cset->scan(cs, from, from+len, MY_SEQ_SPACES);
  len-= tmp_scan;
  from+= tmp_scan;
unknown's avatar
unknown committed
3306

unknown's avatar
unknown committed
3307
  end= (char*) from+len;
unknown's avatar
unknown committed
3308
  tmp= cs->cset->strtoll10(cs, from, &end, &error);
unknown's avatar
unknown committed
3309 3310

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


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

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


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

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


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

longlong Field_long::val_int(void)
{
  int32 j;
3486 3487
  /* See the comment in Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
unknown's avatar
unknown committed
3488
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3489
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3490 3491 3492 3493 3494 3495 3496 3497 3498 3499
    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
3500
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
3501
  uint length;
3502 3503
  uint mlength=max(field_length+1,12*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
3504 3505 3506
  char *to=(char*) val_buffer->ptr();
  int32 j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3507
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3508 3509 3510 3511 3512
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);

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


3524 3525 3526 3527 3528
bool Field_long::send_binary(Protocol *protocol)
{
  return protocol->store_long(Field_long::val_int());
}

unknown's avatar
unknown committed
3529 3530 3531 3532
int Field_long::cmp(const char *a_ptr, const char *b_ptr)
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3533
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544
  {
    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
3545
    return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
unknown's avatar
unknown committed
3546 3547 3548 3549 3550 3551
  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
3552
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
3553 3554 3555 3556
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
unknown's avatar
unknown committed
3557
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3558 3559 3560 3561 3562 3563 3564 3565 3566 3567
    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
3568
      to[0] = (char) (ptr[3] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3569 3570 3571 3572 3573 3574 3575 3576 3577
    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
3578
  CHARSET_INFO *cs=res.charset();
3579
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3580
			  "int(%d)",(int) field_length));
unknown's avatar
unknown committed
3581 3582 3583 3584
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
3585
 Field type longlong int (8 bytes)
unknown's avatar
unknown committed
3586 3587
****************************************************************************/

unknown's avatar
unknown committed
3588
int Field_longlong::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3589
{
3590 3591
  longlong tmp;
  int error= 0;
3592
  char *end;
3593

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


unknown's avatar
unknown committed
3629
int Field_longlong::store(double nr)
unknown's avatar
unknown committed
3630
{
unknown's avatar
unknown committed
3631
  int error= 0;
unknown's avatar
unknown committed
3632
  longlong res;
unknown's avatar
unknown committed
3633 3634

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

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


3680
int Field_longlong::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
3681
{
3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697
  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
3698
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3699
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3700 3701 3702 3703 3704 3705
  {
    int8store(ptr,nr);
  }
  else
#endif
    longlongstore(ptr,nr);
3706
  return error;
unknown's avatar
unknown committed
3707 3708 3709 3710 3711 3712 3713
}


double Field_longlong::val_real(void)
{
  longlong j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3714
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3715 3716 3717 3718 3719 3720
  {
    j=sint8korr(ptr);
  }
  else
#endif
    longlongget(j,ptr);
3721 3722 3723 3724 3725 3726 3727
  /* 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
3728 3729
}

3730

unknown's avatar
unknown committed
3731 3732 3733 3734
longlong Field_longlong::val_int(void)
{
  longlong j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3735
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746
    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
3747
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
3748
  uint length;
3749 3750
  uint mlength=max(field_length+1,22*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
3751 3752 3753
  char *to=(char*) val_buffer->ptr();
  longlong j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3754
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3755 3756 3757 3758 3759
    j=sint8korr(ptr);
  else
#endif
    longlongget(j,ptr);

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


3769 3770 3771 3772 3773 3774
bool Field_longlong::send_binary(Protocol *protocol)
{
  return protocol->store_longlong(Field_longlong::val_int(), unsigned_flag);
}


unknown's avatar
unknown committed
3775 3776 3777 3778
int Field_longlong::cmp(const char *a_ptr, const char *b_ptr)
{
  longlong a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3779
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798
  {
    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
3799
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
3800 3801 3802 3803
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
unknown's avatar
unknown committed
3804
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818
    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
3819
      to[0] = (char) (ptr[7] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832
    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
3833
  CHARSET_INFO *cs=res.charset();
3834
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3835
			  "bigint(%d)",(int) field_length));
unknown's avatar
unknown committed
3836 3837 3838
  add_zerofill_and_unsigned(res);
}

unknown's avatar
unknown committed
3839

unknown's avatar
unknown committed
3840
/****************************************************************************
unknown's avatar
unknown committed
3841
  single precision float
unknown's avatar
unknown committed
3842 3843
****************************************************************************/

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


unknown's avatar
unknown committed
3861
int Field_float::store(double nr)
unknown's avatar
unknown committed
3862 3863
{
  float j;
unknown's avatar
unknown committed
3864
  int error= 0;
3865

3866
  if (isnan(nr))
unknown's avatar
unknown committed
3867
  {
3868 3869
    j= 0;
    set_null();
3870
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3871
    error= 1;
unknown's avatar
unknown committed
3872
  }
3873
  else if (unsigned_flag && nr < 0)
unknown's avatar
unknown committed
3874
  {
3875
    j= 0;
3876
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
3877
    error= 1;
unknown's avatar
unknown committed
3878
  }
3879
  else
unknown's avatar
unknown committed
3880
  {
3881 3882 3883 3884 3885 3886 3887
    double max_value;
    if (dec >= NOT_FIXED_DEC)
    {
      max_value= FLT_MAX;
    }
    else
    {
unknown's avatar
unknown committed
3888 3889
      uint tmp=min(field_length,array_elements(log_10)-1);
      max_value= (log_10[tmp]-1)/log_10[dec];
3890 3891 3892 3893 3894 3895
      /*
	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];
3896 3897 3898 3899
    }
    if (nr < -max_value)
    {
      j= (float)-max_value;
3900
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3901 3902 3903 3904 3905
      error= 1;
    }
    else if (nr > max_value)
    {
      j= (float)max_value;
3906
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3907 3908 3909 3910
      error= 1;
    }
    else
      j= (float) nr;
unknown's avatar
unknown committed
3911
  }
3912
  
unknown's avatar
unknown committed
3913
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3914
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3915 3916 3917 3918 3919 3920
  {
    float4store(ptr,j);
  }
  else
#endif
    memcpy_fixed(ptr,(byte*) &j,sizeof(j));
3921
  return error;
unknown's avatar
unknown committed
3922 3923 3924
}


3925
int Field_float::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
3926
{
3927
  return store(unsigned_val ? ulonglong2double((ulonglong) nr) : (double) nr);
unknown's avatar
unknown committed
3928 3929
}

3930

unknown's avatar
unknown committed
3931 3932 3933 3934
double Field_float::val_real(void)
{
  float j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
3935
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948
  {
    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
3949
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
3950 3951 3952 3953 3954 3955
  {
    float4get(j,ptr);
  }
  else
#endif
    memcpy_fixed((byte*) &j,ptr,sizeof(j));
3956
  return (longlong) rint(j);
unknown's avatar
unknown committed
3957 3958 3959 3960 3961 3962 3963 3964
}


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

3973 3974
  uint to_length=max(field_length,70);
  val_buffer->alloc(to_length);
unknown's avatar
unknown committed
3975 3976 3977 3978 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
  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
4023
#else
4024 4025 4026
#ifdef HAVE_SNPRINTF
    to[to_length-1]=0;			// Safety
    snprintf(to,to_length-1,"%.*f",dec,nr);
4027
    to=strend(to);
unknown's avatar
unknown committed
4028
#else
4029
    to+= my_sprintf(to,(to,"%.*f",dec,nr));
unknown's avatar
unknown committed
4030
#endif
unknown's avatar
unknown committed
4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046
#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
4047
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066
  {
    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
4067
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091
  {
    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
4092
	tmp[i]= (uchar) (tmp[i] ^ (uchar) 255);
unknown's avatar
unknown committed
4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105
    }
    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;
    }
  }
}


4106 4107 4108 4109 4110 4111
bool Field_float::send_binary(Protocol *protocol)
{
  return protocol->store((float) Field_float::val_real(), dec, (String*) 0);
}


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

unknown's avatar
unknown committed
4127

unknown's avatar
unknown committed
4128
/****************************************************************************
unknown's avatar
unknown committed
4129
  double precision floating point numbers
unknown's avatar
unknown committed
4130 4131
****************************************************************************/

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


unknown's avatar
unknown committed
4149
int Field_double::store(double nr)
unknown's avatar
unknown committed
4150
{
unknown's avatar
unknown committed
4151
  int error= 0;
4152

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

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


4206
int Field_double::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
4207
{
4208
  return store(unsigned_val ? ulonglong2double((ulonglong) nr) : (double) nr);
unknown's avatar
unknown committed
4209 4210
}

4211

unknown's avatar
unknown committed
4212 4213 4214 4215 4216 4217
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
4218 4219 4220 4221 4222

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

longlong Field_double::val_int(void)
{
  double j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4237
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4238 4239 4240 4241 4242 4243
  {
    float8get(j,ptr);
  }
  else
#endif
    doubleget(j,ptr);
4244
  return (longlong) rint(j);
unknown's avatar
unknown committed
4245 4246 4247
}


unknown's avatar
unknown committed
4248 4249 4250 4251 4252 4253 4254
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
4255 4256 4257 4258 4259
String *Field_double::val_str(String *val_buffer,
			      String *val_ptr __attribute__((unused)))
{
  double nr;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4260
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4261 4262 4263 4264 4265 4266 4267
  {
    float8get(nr,ptr);
  }
  else
#endif
    doubleget(nr,ptr);

4268
  uint to_length=max(field_length, DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE);
unknown's avatar
unknown committed
4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279
  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
4280
    char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
4281
    char *pos= buff;
unknown's avatar
unknown committed
4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319
    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
4320
    to[to_length-1]=0;			// Safety
unknown's avatar
unknown committed
4321
    snprintf(to,to_length-1,"%.*f",dec,nr);
4322
    to=strend(to);
unknown's avatar
unknown committed
4323
#else
4324
    to+= my_sprintf(to,(to,"%.*f",dec,nr));
unknown's avatar
unknown committed
4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337
#endif
#endif
  }
#ifdef HAVE_FCONVERT
 end:
#endif

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

4338 4339
bool Field_double::send_binary(Protocol *protocol)
{
unknown's avatar
unknown committed
4340
  return protocol->store((double) Field_double::val_real(), dec, (String*) 0);
4341 4342
}

unknown's avatar
unknown committed
4343 4344 4345 4346 4347

int Field_double::cmp(const char *a_ptr, const char *b_ptr)
{
  double a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4348
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4349 4350 4351 4352 4353 4354 4355
  {
    float8get(a,a_ptr);
    float8get(b,b_ptr);
  }
  else
#endif
  {
unknown's avatar
unknown committed
4356 4357
    doubleget(a, a_ptr);
    doubleget(b, b_ptr);
unknown's avatar
unknown committed
4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370
  }
  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
4371
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4372 4373 4374 4375 4376
  {
    float8get(nr,ptr);
  }
  else
#endif
unknown's avatar
unknown committed
4377
    doubleget(nr,ptr);
unknown's avatar
unknown committed
4378 4379 4380 4381 4382 4383
  change_double_for_sort(nr, (byte*) to);
}


void Field_double::sql_type(String &res) const
{
unknown's avatar
unknown committed
4384
  CHARSET_INFO *cs=res.charset();
unknown's avatar
unknown committed
4385
  if (dec == NOT_FIXED_DEC)
4386
  {
4387
    res.set_ascii(STRING_WITH_LEN("double"));
4388
  }
unknown's avatar
unknown committed
4389
  else
4390
  {
4391
    res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
4392
			    "double(%d,%d)",(int) field_length,dec));
4393
  }
unknown's avatar
unknown committed
4394 4395 4396 4397
  add_zerofill_and_unsigned(res);
}


4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421
/*
  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
4422
    field which has 0 as default value and is not automatically updated.
4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441
  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
4442 4443

Field_timestamp::Field_timestamp(char *ptr_arg, uint32 len_arg,
4444
                                 uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
4445 4446
				 enum utype unireg_check_arg,
				 const char *field_name_arg,
4447 4448
				 struct st_table *table_arg,
				 CHARSET_INFO *cs)
4449
  :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
4450
	     unireg_check_arg, field_name_arg, table_arg, cs)
unknown's avatar
unknown committed
4451
{
unknown's avatar
unknown committed
4452 4453
  /* For 4.0 MYD and 4.0 InnoDB compatibility */
  flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
4454 4455
  if (table && !table->timestamp_field && 
      unireg_check != NONE)
unknown's avatar
unknown committed
4456
  {
4457 4458
    /* This timestamp has auto-update */
    table->timestamp_field= this;
unknown's avatar
unknown committed
4459 4460 4461 4462 4463
    flags|=TIMESTAMP_FLAG;
  }
}


4464
/*
4465 4466
  Get auto-set type for TIMESTAMP field.

4467
  SYNOPSIS
4468 4469 4470 4471 4472
    get_auto_set_type()

  DESCRIPTION
    Returns value indicating during which operations this TIMESTAMP field
    should be auto-set to current timestamp.
4473
*/
4474
timestamp_auto_set_type Field_timestamp::get_auto_set_type() const
4475
{
4476 4477 4478 4479 4480 4481
  switch (unireg_check)
  {
  case TIMESTAMP_DN_FIELD:
    return TIMESTAMP_AUTO_SET_ON_INSERT;
  case TIMESTAMP_UN_FIELD:
    return TIMESTAMP_AUTO_SET_ON_UPDATE;
4482 4483
  case TIMESTAMP_OLD_FIELD:
    /*
unknown's avatar
unknown committed
4484
      Although we can have several such columns in legacy tables this
4485 4486 4487 4488 4489
      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 */
4490 4491 4492 4493 4494 4495 4496 4497 4498 4499
  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;
  }
4500 4501 4502
}


unknown's avatar
unknown committed
4503
int Field_timestamp::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4504
{
4505 4506 4507 4508
  TIME l_time;
  my_time_t tmp= 0;
  int error;
  bool have_smth_to_conv;
4509
  my_bool in_dst_time_gap;
4510 4511
  THD *thd= table->in_use;

4512
  /* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
unknown's avatar
unknown committed
4513
  have_smth_to_conv= (str_to_datetime(from, len, &l_time,
4514 4515 4516
                                      (table->in_use->variables.sql_mode &
                                       MODE_NO_ZERO_DATE) |
                                      MODE_NO_ZERO_IN_DATE, &error) >
4517
                      MYSQL_TIMESTAMP_ERROR);
4518

unknown's avatar
unknown committed
4519 4520 4521
  if (error || !have_smth_to_conv)
  {
    error= 1;
4522
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
4523
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
unknown's avatar
unknown committed
4524
  }
4525

unknown's avatar
unknown committed
4526 4527
  /* Only convert a correct date (not a zero date) */
  if (have_smth_to_conv && l_time.month)
4528 4529 4530
  {
    if (!(tmp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
    {
4531
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4532
                           ER_WARN_DATA_OUT_OF_RANGE,
4533
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
4534 4535 4536 4537 4538
      error= 1;
    }
    else if (in_dst_time_gap)
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4539
                           ER_WARN_INVALID_TIMESTAMP,
4540
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
4541 4542 4543
      error= 1;
    }
  }
unknown's avatar
unknown committed
4544 4545
  if (error > 1)
    error= 2;
4546

unknown's avatar
unknown committed
4547
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4548
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4549 4550 4551 4552 4553 4554
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
4555
  return error;
unknown's avatar
unknown committed
4556 4557
}

unknown's avatar
unknown committed
4558

unknown's avatar
unknown committed
4559
int Field_timestamp::store(double nr)
unknown's avatar
unknown committed
4560
{
unknown's avatar
unknown committed
4561
  int error= 0;
unknown's avatar
unknown committed
4562 4563
  if (nr < 0 || nr > 99991231235959.0)
  {
4564 4565
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                         ER_WARN_DATA_OUT_OF_RANGE,
4566
                         nr, MYSQL_TIMESTAMP_DATETIME);
unknown's avatar
unknown committed
4567 4568
    nr= 0;					// Avoid overflow on buff
    error= 1;
unknown's avatar
unknown committed
4569
  }
4570
  error|= Field_timestamp::store((longlong) rint(nr), FALSE);
4571
  return error;
unknown's avatar
unknown committed
4572 4573 4574
}


4575
int Field_timestamp::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
4576 4577
{
  TIME l_time;
4578 4579
  my_time_t timestamp= 0;
  int error;
4580
  my_bool in_dst_time_gap;
4581
  THD *thd= table->in_use;
unknown's avatar
unknown committed
4582

4583
  /* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
4584 4585 4586
  longlong tmp= number_to_datetime(nr, &l_time, (thd->variables.sql_mode &
                                                 MODE_NO_ZERO_DATE) |
                                   MODE_NO_ZERO_IN_DATE, &error);
4587
  if (tmp == LL(-1))
4588 4589 4590 4591 4592
  {
    error= 2;
  }

  if (!error && tmp)
unknown's avatar
unknown committed
4593
  {
4594 4595
    if (!(timestamp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
    {
4596 4597 4598
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                           ER_WARN_DATA_OUT_OF_RANGE,
                           nr, MYSQL_TIMESTAMP_DATETIME, 1);
4599 4600 4601 4602 4603
      error= 1;
    }
    if (in_dst_time_gap)
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4604 4605
                           ER_WARN_INVALID_TIMESTAMP,
                           nr, MYSQL_TIMESTAMP_DATETIME, 1);
4606 4607
      error= 1;
    }
4608 4609
  } else if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4610
                         WARN_DATA_TRUNCATED,
4611
                         nr, MYSQL_TIMESTAMP_DATETIME, 1);
4612

unknown's avatar
unknown committed
4613
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4614
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4615 4616 4617 4618 4619
  {
    int4store(ptr,timestamp);
  }
  else
#endif
unknown's avatar
unknown committed
4620
    longstore(ptr,(uint32) timestamp);
4621

unknown's avatar
unknown committed
4622
  return error;
unknown's avatar
unknown committed
4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633
}


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

longlong Field_timestamp::val_int(void)
{
  uint32 temp;
4634 4635
  TIME time_tmp;
  THD  *thd= table->in_use;
unknown's avatar
unknown committed
4636 4637

#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4638
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4639 4640 4641 4642 4643 4644 4645
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);

  if (temp == 0L)				// No time
    return(0);					/* purecov: inspected */
4646 4647 4648 4649 4650 4651 4652
  
  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
4653 4654 4655
}


unknown's avatar
unknown committed
4656
String *Field_timestamp::val_str(String *val_buffer, String *val_ptr)
unknown's avatar
unknown committed
4657
{
4658
  uint32 temp, temp2;
4659 4660
  TIME time_tmp;
  THD *thd= table->in_use;
unknown's avatar
unknown committed
4661
  char *to;
unknown's avatar
unknown committed
4662 4663

  val_buffer->alloc(field_length+1);
unknown's avatar
unknown committed
4664
  to= (char*) val_buffer->ptr();
4665
  val_buffer->length(field_length);
unknown's avatar
unknown committed
4666 4667

#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4668
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4669 4670 4671 4672 4673 4674 4675
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);

  if (temp == 0L)
  {				      /* Zero time is "000000" */
4676
    val_ptr->set(STRING_WITH_LEN("0000-00-00 00:00:00"), &my_charset_bin);
4677
    return val_ptr;
unknown's avatar
unknown committed
4678
  }
unknown's avatar
unknown committed
4679
  val_buffer->set_charset(&my_charset_bin);	// Safety
4680 4681 4682
  
  thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp,(my_time_t)temp);
  thd->time_zone_used= 1;
4683

4684
  temp= time_tmp.year % 100;
4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698
  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++= '-';
4699
  temp=time_tmp.month;
4700 4701 4702 4703
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= '-';
4704
  temp=time_tmp.day;
4705 4706 4707 4708
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ' ';
4709
  temp=time_tmp.hour;
4710 4711 4712 4713
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ':';
4714
  temp=time_tmp.minute;
4715 4716 4717 4718
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ':';
4719
  temp=time_tmp.second;
4720 4721 4722 4723
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to= 0;
unknown's avatar
unknown committed
4724 4725 4726
  return val_buffer;
}

4727

4728
bool Field_timestamp::get_date(TIME *ltime, uint fuzzydate)
unknown's avatar
unknown committed
4729 4730
{
  long temp;
4731
  THD *thd= table->in_use;
unknown's avatar
unknown committed
4732
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4733
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4734 4735 4736 4737 4738 4739
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);
  if (temp == 0L)
  {				      /* Zero time is "000000" */
unknown's avatar
unknown committed
4740
    if (fuzzydate & TIME_NO_ZERO_DATE)
unknown's avatar
unknown committed
4741
      return 1;
unknown's avatar
unknown committed
4742 4743 4744 4745
    bzero((char*) ltime,sizeof(*ltime));
  }
  else
  {
4746 4747
    thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)temp);
    thd->time_zone_used= 1;
unknown's avatar
unknown committed
4748 4749 4750 4751 4752 4753
  }
  return 0;
}

bool Field_timestamp::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
4754
  return Field_timestamp::get_date(ltime,0);
unknown's avatar
unknown committed
4755 4756
}

4757 4758 4759 4760

bool Field_timestamp::send_binary(Protocol *protocol)
{
  TIME tm;
unknown's avatar
unknown committed
4761
  Field_timestamp::get_date(&tm, 0);
4762 4763 4764 4765
  return protocol->store(&tm);
}


unknown's avatar
unknown committed
4766 4767 4768 4769
int Field_timestamp::cmp(const char *a_ptr, const char *b_ptr)
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4770
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783
  {
    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;
}

4784

unknown's avatar
unknown committed
4785 4786 4787
void Field_timestamp::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4788
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807
  {
    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
{
4808
  res.set_ascii(STRING_WITH_LEN("timestamp"));
unknown's avatar
unknown committed
4809 4810 4811 4812 4813
}


void Field_timestamp::set_time()
{
4814
  long tmp= (long) table->in_use->query_start();
4815
  set_notnull();
unknown's avatar
unknown committed
4816
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
4817
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832
  {
    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
4833
int Field_time::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4834 4835 4836
{
  TIME ltime;
  long tmp;
4837 4838 4839
  int error;

  if (str_to_time(from, len, &ltime, &error))
4840
  {
unknown's avatar
unknown committed
4841
    tmp=0L;
unknown's avatar
unknown committed
4842
    error= 2;
4843
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
4844
                         from, len, MYSQL_TIMESTAMP_TIME, 1);
4845
  }
unknown's avatar
unknown committed
4846 4847
  else
  {
4848 4849
    if (error)
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4850
                           WARN_DATA_TRUNCATED,
4851
                           from, len, MYSQL_TIMESTAMP_TIME, 1);
4852

unknown's avatar
unknown committed
4853 4854 4855 4856 4857 4858
    if (ltime.month)
      ltime.day=0;
    tmp=(ltime.day*24L+ltime.hour)*10000L+(ltime.minute*100+ltime.second);
    if (tmp > 8385959)
    {
      tmp=8385959;
4859 4860
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                           ER_WARN_DATA_OUT_OF_RANGE,
4861
                           from, len, MYSQL_TIMESTAMP_TIME, !error);
unknown's avatar
unknown committed
4862
      error= 1;
unknown's avatar
unknown committed
4863
    }
unknown's avatar
unknown committed
4864 4865
    if (error > 1)
      error= 2;
unknown's avatar
unknown committed
4866
  }
4867
  
unknown's avatar
unknown committed
4868 4869
  if (ltime.neg)
    tmp= -tmp;
4870
  error |= Field_time::store((longlong) tmp, FALSE);
4871
  return error;
unknown's avatar
unknown committed
4872 4873 4874
}


4875 4876 4877 4878 4879 4880 4881 4882 4883 4884
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
4885
int Field_time::store(double nr)
unknown's avatar
unknown committed
4886 4887
{
  long tmp;
unknown's avatar
unknown committed
4888
  int error= 0;
unknown's avatar
unknown committed
4889 4890 4891
  if (nr > 8385959.0)
  {
    tmp=8385959L;
4892
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4893
                         ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
4894
    error= 1;
unknown's avatar
unknown committed
4895 4896 4897 4898
  }
  else if (nr < -8385959.0)
  {
    tmp= -8385959L;
4899
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4900
                         ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
4901
    error= 1;
unknown's avatar
unknown committed
4902 4903 4904 4905 4906 4907 4908 4909 4910
  }
  else
  {
    tmp=(long) floor(fabs(nr));			// Remove fractions
    if (nr < 0)
      tmp= -tmp;
    if (tmp % 100 > 59 || tmp/100 % 100 > 59)
    {
      tmp=0;
4911
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4912 4913
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
4914
      error= 1;
unknown's avatar
unknown committed
4915 4916 4917
    }
  }
  int3store(ptr,tmp);
4918
  return error;
unknown's avatar
unknown committed
4919 4920 4921
}


4922
int Field_time::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
4923 4924
{
  long tmp;
unknown's avatar
unknown committed
4925
  int error= 0;
4926
  if (nr < (longlong) -8385959L && !unsigned_val)
unknown's avatar
unknown committed
4927
  {
4928
    tmp= -8385959L;
4929
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4930 4931
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
4932
    error= 1;
unknown's avatar
unknown committed
4933
  }
4934
  else if (nr > (longlong) 8385959 || nr < 0 && unsigned_val)
unknown's avatar
unknown committed
4935
  {
4936
    tmp=8385959L;
4937
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4938 4939
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
4940
    error= 1;
unknown's avatar
unknown committed
4941 4942 4943 4944 4945 4946 4947
  }
  else
  {
    tmp=(long) nr;
    if (tmp % 100 > 59 || tmp/100 % 100 > 59)
    {
      tmp=0;
4948
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
4949 4950
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
4951
      error= 1;
unknown's avatar
unknown committed
4952 4953 4954
    }
  }
  int3store(ptr,tmp);
4955
  return error;
unknown's avatar
unknown committed
4956 4957 4958 4959 4960
}


double Field_time::val_real(void)
{
unknown's avatar
unknown committed
4961
  uint32 j= (uint32) uint3korr(ptr);
unknown's avatar
unknown committed
4962 4963 4964 4965 4966 4967 4968 4969
  return (double) j;
}

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

4970 4971 4972 4973 4974 4975

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

unknown's avatar
unknown committed
4976 4977 4978
String *Field_time::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
4979
  TIME ltime;
4980
  val_buffer->alloc(19);
unknown's avatar
unknown committed
4981
  long tmp=(long) sint3korr(ptr);
4982
  ltime.neg= 0;
unknown's avatar
unknown committed
4983 4984 4985
  if (tmp < 0)
  {
    tmp= -tmp;
4986 4987 4988 4989 4990 4991
    ltime.neg= 1;
  }
  ltime.day= (uint) 0;
  ltime.hour= (uint) (tmp/10000);
  ltime.minute= (uint) (tmp/100 % 100);
  ltime.second= (uint) (tmp % 100);
4992
  make_time((DATE_TIME_FORMAT*) 0, &ltime, val_buffer);
unknown's avatar
unknown committed
4993 4994 4995
  return val_buffer;
}

4996

unknown's avatar
unknown committed
4997
/*
unknown's avatar
unknown committed
4998
  Normally we would not consider 'time' as a valid date, but we allow
unknown's avatar
unknown committed
4999 5000 5001 5002 5003
  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)
5004
{
unknown's avatar
unknown committed
5005
  long tmp;
unknown's avatar
unknown committed
5006
  if (!(fuzzydate & TIME_FUZZY_DATE))
unknown's avatar
unknown committed
5007
  {
5008 5009 5010 5011
    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
5012 5013 5014
    return 1;
  }
  tmp=(long) sint3korr(ptr);
5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028
  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
5029

unknown's avatar
unknown committed
5030 5031 5032 5033 5034 5035 5036 5037 5038
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
5039
  ltime->day= 0;
unknown's avatar
unknown committed
5040
  ltime->hour=   (int) (tmp/10000);
unknown's avatar
unknown committed
5041
  tmp-=ltime->hour*10000;
unknown's avatar
unknown committed
5042 5043
  ltime->minute= (int) tmp/100;
  ltime->second= (int) tmp % 100;
unknown's avatar
unknown committed
5044
  ltime->second_part=0;
5045
  ltime->time_type= MYSQL_TIMESTAMP_TIME;
unknown's avatar
unknown committed
5046 5047 5048
  return 0;
}

5049 5050 5051 5052 5053

bool Field_time::send_binary(Protocol *protocol)
{
  TIME tm;
  Field_time::get_time(&tm);
5054 5055
  tm.day= tm.hour/24;				// Move hours to days
  tm.hour-= tm.day*24;
unknown's avatar
unknown committed
5056
  return protocol->store_time(&tm);
5057 5058 5059
}


unknown's avatar
unknown committed
5060 5061
int Field_time::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
5062 5063 5064
  int32 a,b;
  a=(int32) sint3korr(a_ptr);
  b=(int32) sint3korr(b_ptr);
unknown's avatar
unknown committed
5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076
  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
{
5077
  res.set_ascii(STRING_WITH_LEN("time"));
unknown's avatar
unknown committed
5078 5079 5080 5081 5082 5083 5084 5085
}

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

unknown's avatar
unknown committed
5086
int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5087
{
5088
  char *end;
unknown's avatar
unknown committed
5089 5090
  int error;
  long nr= my_strntol(cs, from, len, 10, &end, &error);
unknown's avatar
unknown committed
5091

unknown's avatar
unknown committed
5092
  if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155 || error)
unknown's avatar
unknown committed
5093 5094
  {
    *ptr=0;
5095
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
5096
    return 1;
unknown's avatar
unknown committed
5097
  }
unknown's avatar
unknown committed
5098 5099 5100
  if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
    error= 1;

unknown's avatar
unknown committed
5101 5102 5103 5104 5105 5106 5107 5108
  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
5109
  return error;
unknown's avatar
unknown committed
5110 5111
}

unknown's avatar
unknown committed
5112

unknown's avatar
unknown committed
5113
int Field_year::store(double nr)
unknown's avatar
unknown committed
5114 5115
{
  if (nr < 0.0 || nr >= 2155.0)
5116
  {
5117
    (void) Field_year::store((longlong) -1, FALSE);
5118 5119
    return 1;
  }
5120
  return Field_year::store((longlong) nr, FALSE);
unknown's avatar
unknown committed
5121 5122
}

5123 5124

int Field_year::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
5125 5126 5127
{
  if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155)
  {
5128
    *ptr= 0;
5129
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
5130
    return 1;
unknown's avatar
unknown committed
5131 5132 5133 5134 5135 5136 5137 5138 5139
  }
  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;
5140
  return 0;
unknown's avatar
unknown committed
5141 5142
}

5143

unknown's avatar
unknown committed
5144 5145 5146
bool Field_year::send_binary(Protocol *protocol)
{
  ulonglong tmp= Field_year::val_int();
5147
  return protocol->store_short(tmp);
unknown's avatar
unknown committed
5148
}
unknown's avatar
unknown committed
5149

5150

unknown's avatar
unknown committed
5151 5152 5153 5154 5155
double Field_year::val_real(void)
{
  return (double) Field_year::val_int();
}

5156

unknown's avatar
unknown committed
5157 5158 5159 5160 5161 5162 5163 5164 5165 5166
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;
}

5167

unknown's avatar
unknown committed
5168 5169 5170 5171 5172 5173 5174 5175 5176 5177
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;
}

5178

unknown's avatar
unknown committed
5179 5180
void Field_year::sql_type(String &res) const
{
unknown's avatar
unknown committed
5181
  CHARSET_INFO *cs=res.charset();
5182
  res.length(cs->cset->snprintf(cs,(char*)res.ptr(),res.alloced_length(),
5183
			  "year(%d)",(int) field_length));
unknown's avatar
unknown committed
5184 5185 5186 5187 5188 5189 5190 5191 5192 5193
}


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

unknown's avatar
unknown committed
5194
int Field_date::store(const char *from, uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5195 5196
{
  TIME l_time;
unknown's avatar
unknown committed
5197
  uint32 tmp;
5198
  int error;
5199

unknown's avatar
unknown committed
5200 5201 5202 5203 5204
  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)
5205
  {
5206
    tmp= 0;
unknown's avatar
unknown committed
5207
    error= 2;
5208
  }
unknown's avatar
unknown committed
5209
  else
unknown's avatar
unknown committed
5210
    tmp=(uint32) l_time.year*10000L + (uint32) (l_time.month*100+l_time.day);
5211 5212

  if (error)
5213
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
5214
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
5215

unknown's avatar
unknown committed
5216
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5217
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5218 5219 5220 5221 5222 5223
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
5224
  return error;
unknown's avatar
unknown committed
5225 5226 5227
}


unknown's avatar
unknown committed
5228
int Field_date::store(double nr)
unknown's avatar
unknown committed
5229
{
5230
  longlong tmp;
unknown's avatar
unknown committed
5231
  int error= 0;
unknown's avatar
unknown committed
5232 5233 5234 5235
  if (nr >= 19000000000000.0 && nr <= 99991231235959.0)
    nr=floor(nr/1000000.0);			// Timestamp to date
  if (nr < 0.0 || nr > 99991231.0)
  {
5236
    tmp= LL(0);
5237 5238
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                         ER_WARN_DATA_OUT_OF_RANGE,
5239
                         nr, MYSQL_TIMESTAMP_DATE);
unknown's avatar
unknown committed
5240
    error= 1;
unknown's avatar
unknown committed
5241 5242
  }
  else
5243
    tmp= (longlong) rint(nr);
5244

5245
  return Field_date::store(tmp);
unknown's avatar
unknown committed
5246 5247 5248
}


5249
int Field_date::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
5250
{
5251 5252 5253 5254 5255 5256 5257 5258 5259 5260
  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);

5261
  if (nr == LL(-1))
unknown's avatar
unknown committed
5262
  {
5263 5264
    nr= 0;
    error= 2;
unknown's avatar
unknown committed
5265
  }
5266 5267 5268 5269 5270 5271

  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);
5272

unknown's avatar
unknown committed
5273
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5274
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5275
  {
5276
    int4store(ptr, nr);
unknown's avatar
unknown committed
5277 5278 5279
  }
  else
#endif
5280
    longstore(ptr, nr);
5281
  return error;
unknown's avatar
unknown committed
5282 5283 5284
}


unknown's avatar
unknown committed
5285 5286 5287 5288 5289 5290 5291 5292 5293 5294
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
5295 5296 5297 5298 5299

double Field_date::val_real(void)
{
  int32 j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5300
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5301 5302 5303 5304 5305 5306 5307
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return (double) (uint32) j;
}

5308

unknown's avatar
unknown committed
5309 5310 5311 5312
longlong Field_date::val_int(void)
{
  int32 j;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5313
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5314 5315 5316 5317 5318 5319 5320
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return (longlong) (uint32) j;
}

5321

unknown's avatar
unknown committed
5322 5323 5324
String *Field_date::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
5325
  TIME ltime;
unknown's avatar
unknown committed
5326 5327 5328
  val_buffer->alloc(field_length);
  int32 tmp;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5329
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5330 5331 5332 5333
    tmp=sint4korr(ptr);
  else
#endif
    longget(tmp,ptr);
5334 5335 5336 5337
  ltime.neg= 0;
  ltime.year= (int) ((uint32) tmp/10000L % 10000);
  ltime.month= (int) ((uint32) tmp/100 % 100);
  ltime.day= (int) ((uint32) tmp % 100);
5338
  make_date((DATE_TIME_FORMAT *) 0, &ltime, val_buffer);
unknown's avatar
unknown committed
5339 5340 5341
  return val_buffer;
}

5342

unknown's avatar
unknown committed
5343 5344 5345 5346
int Field_date::cmp(const char *a_ptr, const char *b_ptr)
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5347
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364
  {
    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
5365
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383
  {
    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
{
5384
  res.set_ascii(STRING_WITH_LEN("date"));
unknown's avatar
unknown committed
5385 5386
}

5387

unknown's avatar
unknown committed
5388 5389 5390 5391 5392 5393
/****************************************************************************
** 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
5394
int Field_newdate::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5395 5396 5397
{
  TIME l_time;
  long tmp;
5398
  int error;
unknown's avatar
unknown committed
5399 5400 5401 5402 5403 5404
  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)
5405
  {
5406
    tmp= 0L;
unknown's avatar
unknown committed
5407
    error= 2;
5408
  }
unknown's avatar
unknown committed
5409 5410
  else
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
5411 5412

  if (error)
5413
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
5414
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
5415

unknown's avatar
unknown committed
5416
  int3store(ptr,tmp);
5417
  return error;
unknown's avatar
unknown committed
5418 5419
}

5420

unknown's avatar
unknown committed
5421
int Field_newdate::store(double nr)
unknown's avatar
unknown committed
5422 5423
{
  if (nr < 0.0 || nr > 99991231235959.0)
5424
  {
5425
    int3store(ptr,(int32) 0);
5426
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
5427
                         WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATE);
5428 5429
    return 1;
  }
5430
  return Field_newdate::store((longlong) rint(nr), FALSE);
unknown's avatar
unknown committed
5431 5432 5433
}


5434
int Field_newdate::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
5435
{
5436
  TIME l_time;
5437
  longlong tmp;
5438
  int error;
5439 5440 5441 5442 5443 5444
  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))
5445 5446 5447
  {
    tmp= 0L;
    error= 2;
unknown's avatar
unknown committed
5448 5449
  }
  else
5450
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
5451

5452 5453 5454 5455 5456 5457
  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);
5458
  return error;
unknown's avatar
unknown committed
5459 5460
}

5461

5462
int Field_newdate::store_time(TIME *ltime,timestamp_type type)
unknown's avatar
unknown committed
5463 5464
{
  long tmp;
5465
  int error= 0;
5466
  if (type == MYSQL_TIMESTAMP_DATE || type == MYSQL_TIMESTAMP_DATETIME)
unknown's avatar
unknown committed
5467 5468 5469 5470
    tmp=ltime->year*16*32+ltime->month*32+ltime->day;
  else
  {
    tmp=0;
5471
    error= 1;
5472
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5473 5474
  }
  int3store(ptr,tmp);
5475
  return error;
unknown's avatar
unknown committed
5476 5477
}

5478

unknown's avatar
unknown committed
5479 5480 5481 5482 5483 5484
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
5485

5486

unknown's avatar
unknown committed
5487 5488 5489 5490 5491
double Field_newdate::val_real(void)
{
  return (double) Field_newdate::val_int();
}

5492

unknown's avatar
unknown committed
5493 5494
longlong Field_newdate::val_int(void)
{
unknown's avatar
unknown committed
5495
  ulong j= uint3korr(ptr);
unknown's avatar
unknown committed
5496 5497 5498 5499
  j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
  return (longlong) j;
}

5500

unknown's avatar
unknown committed
5501 5502 5503 5504 5505
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
5506
  uint32 tmp=(uint32) uint3korr(ptr);
unknown's avatar
unknown committed
5507 5508 5509 5510
  int part;
  char *pos=(char*) val_buffer->ptr()+10;

  /* Open coded to get more speed */
unknown's avatar
unknown committed
5511
  *pos--=0;					// End NULL
unknown's avatar
unknown committed
5512
  part=(int) (tmp & 31);
unknown's avatar
unknown committed
5513 5514 5515
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
unknown's avatar
unknown committed
5516
  part=(int) (tmp >> 5 & 15);
unknown's avatar
unknown committed
5517 5518 5519
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
unknown's avatar
unknown committed
5520
  part=(int) (tmp >> 9);
unknown's avatar
unknown committed
5521 5522 5523 5524
  *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
5525 5526 5527
  return val_buffer;
}

5528

5529
bool Field_newdate::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
5530
{
unknown's avatar
unknown committed
5531
  uint32 tmp=(uint32) uint3korr(ptr);
unknown's avatar
unknown committed
5532 5533 5534
  ltime->day=   tmp & 31;
  ltime->month= (tmp >> 5) & 15;
  ltime->year=  (tmp >> 9);
5535
  ltime->time_type= MYSQL_TIMESTAMP_DATE;
5536
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
unknown's avatar
unknown committed
5537 5538
  return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
          1 : 0);
unknown's avatar
unknown committed
5539 5540
}

5541

unknown's avatar
unknown committed
5542 5543
bool Field_newdate::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
5544
  return Field_newdate::get_date(ltime,0);
unknown's avatar
unknown committed
5545 5546
}

5547

unknown's avatar
unknown committed
5548 5549
int Field_newdate::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
5550 5551 5552
  uint32 a,b;
  a=(uint32) uint3korr(a_ptr);
  b=(uint32) uint3korr(b_ptr);
unknown's avatar
unknown committed
5553 5554 5555
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

5556

unknown's avatar
unknown committed
5557 5558 5559 5560 5561 5562 5563
void Field_newdate::sort_string(char *to,uint length __attribute__((unused)))
{
  to[0] = ptr[2];
  to[1] = ptr[1];
  to[2] = ptr[0];
}

5564

unknown's avatar
unknown committed
5565 5566
void Field_newdate::sql_type(String &res) const
{
5567
  res.set_ascii(STRING_WITH_LEN("date"));
unknown's avatar
unknown committed
5568 5569 5570 5571 5572 5573 5574 5575 5576 5577
}


/****************************************************************************
** 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
5578
int Field_datetime::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5579
{
5580 5581 5582
  TIME time_tmp;
  int error;
  ulonglong tmp= 0;
5583
  enum enum_mysql_timestamp_type func_res;
5584

5585 5586 5587 5588 5589 5590 5591
  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)
5592
    tmp= TIME_to_ulonglong_datetime(&time_tmp);
5593 5594 5595
  else
    error= 1;                                 // Fix if invalid zero date

5596
  if (error)
5597
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
5598
                         ER_WARN_DATA_OUT_OF_RANGE,
5599
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
5600

unknown's avatar
unknown committed
5601
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5602
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5603 5604 5605 5606 5607 5608
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
5609
  return error;
unknown's avatar
unknown committed
5610 5611 5612
}


unknown's avatar
unknown committed
5613
int Field_datetime::store(double nr)
unknown's avatar
unknown committed
5614
{
unknown's avatar
unknown committed
5615
  int error= 0;
unknown's avatar
unknown committed
5616 5617
  if (nr < 0.0 || nr > 99991231235959.0)
  {
5618 5619
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE,
5620
                         nr, MYSQL_TIMESTAMP_DATETIME);
5621
    nr= 0.0;
unknown's avatar
unknown committed
5622
    error= 1;
unknown's avatar
unknown committed
5623
  }
5624
  error|= Field_datetime::store((longlong) rint(nr), FALSE);
5625
  return error;
unknown's avatar
unknown committed
5626 5627 5628
}


5629
int Field_datetime::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
5630
{
5631
  TIME not_used;
5632 5633 5634
  int error;
  longlong initial_nr= nr;

5635 5636 5637 5638 5639 5640
  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);

5641
  if (nr == LL(-1))
5642
  {
5643 5644
    nr= 0;
    error= 2;
5645
  }
5646

5647 5648 5649 5650 5651 5652
  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
5653
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5654
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5655 5656 5657 5658 5659 5660
  {
    int8store(ptr,nr);
  }
  else
#endif
    longlongstore(ptr,nr);
5661
  return error;
unknown's avatar
unknown committed
5662 5663
}

unknown's avatar
unknown committed
5664

5665
int Field_datetime::store_time(TIME *ltime,timestamp_type type)
unknown's avatar
unknown committed
5666 5667
{
  longlong tmp;
5668
  int error= 0;
5669 5670 5671 5672
  /*
    We don't perform range checking here since values stored in TIME
    structure always fit into DATETIME range.
  */
5673
  if (type == MYSQL_TIMESTAMP_DATE || type == MYSQL_TIMESTAMP_DATETIME)
unknown's avatar
unknown committed
5674 5675 5676 5677 5678
    tmp=((ltime->year*10000L+ltime->month*100+ltime->day)*LL(1000000)+
	 (ltime->hour*10000L+ltime->minute*100+ltime->second));
  else
  {
    tmp=0;
5679
    error= 1;
5680
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5681 5682
  }
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5683
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5684 5685 5686 5687 5688 5689
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
5690
  return error;
unknown's avatar
unknown committed
5691 5692
}

unknown's avatar
unknown committed
5693 5694 5695
bool Field_datetime::send_binary(Protocol *protocol)
{
  TIME tm;
5696
  Field_datetime::get_date(&tm, TIME_FUZZY_DATE);
unknown's avatar
unknown committed
5697 5698 5699
  return protocol->store(&tm);
}

unknown's avatar
unknown committed
5700 5701 5702 5703 5704 5705 5706 5707 5708 5709

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
5710
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729
    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
5730
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5731 5732 5733 5734 5735 5736
    tmp=sint8korr(ptr);
  else
#endif
    longlongget(tmp,ptr);

  /*
unknown's avatar
unknown committed
5737
    Avoid problem with slow longlong arithmetic and sprintf
unknown's avatar
unknown committed
5738 5739 5740 5741 5742 5743 5744
  */

  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
5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763
  *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
5764 5765 5766
  return val_buffer;
}

5767
bool Field_datetime::get_date(TIME *ltime, uint fuzzydate)
unknown's avatar
unknown committed
5768 5769
{
  longlong tmp=Field_datetime::val_int();
unknown's avatar
unknown committed
5770 5771 5772
  uint32 part1,part2;
  part1=(uint32) (tmp/LL(1000000));
  part2=(uint32) (tmp - (ulonglong) part1*LL(1000000));
unknown's avatar
unknown committed
5773

5774
  ltime->time_type=	MYSQL_TIMESTAMP_DATETIME;
unknown's avatar
unknown committed
5775 5776 5777 5778 5779 5780 5781 5782
  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
5783
  return (!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ? 1 : 0;
unknown's avatar
unknown committed
5784 5785 5786 5787
}

bool Field_datetime::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
5788
  return Field_datetime::get_date(ltime,0);
unknown's avatar
unknown committed
5789 5790 5791 5792 5793 5794
}

int Field_datetime::cmp(const char *a_ptr, const char *b_ptr)
{
  longlong a,b;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
5795
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812
  {
    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
5813
  if (!table->s->db_low_byte_first)
unknown's avatar
unknown committed
5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840
  {
    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
{
5841
  res.set_ascii(STRING_WITH_LEN("datetime"));
unknown's avatar
unknown committed
5842 5843 5844 5845 5846 5847 5848 5849 5850
}

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

	/* Copy a string and fill with space */

unknown's avatar
unknown committed
5851
int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5852
{
5853
  int error= 0, well_formed_error;
unknown's avatar
unknown committed
5854
  uint32 not_used;
unknown's avatar
unknown committed
5855
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
5856
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
5857
  uint copy_length;
5858 5859 5860 5861
  
  /* See the comment for Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
  
unknown's avatar
unknown committed
5862
  /* Convert character set if necessary */
unknown's avatar
unknown committed
5863
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
5864
  { 
5865 5866
    uint conv_errors;
    tmpstr.copy(from, length, cs, field_charset, &conv_errors);
unknown's avatar
unknown committed
5867 5868
    from= tmpstr.ptr();
    length=  tmpstr.length();
5869
    if (conv_errors)
unknown's avatar
unknown committed
5870
      error= 2;
unknown's avatar
unknown committed
5871
  }
unknown's avatar
unknown committed
5872 5873

  /* 
5874
    Make sure we don't break a multibyte sequence
unknown's avatar
unknown committed
5875 5876
    as well as don't copy a malformed data.
  */
5877
  copy_length= field_charset->cset->well_formed_len(field_charset,
5878 5879 5880
                                                    from,from+length,
                                                    field_length/
                                                    field_charset->mbmaxlen,
5881
                                                    &well_formed_error);
unknown's avatar
unknown committed
5882 5883 5884
  memcpy(ptr,from,copy_length);
  if (copy_length < field_length)	// Append spaces if shorter
    field_charset->cset->fill(field_charset,ptr+copy_length,
5885 5886
			      field_length-copy_length,
                              field_charset->pad_char);
unknown's avatar
unknown committed
5887
  
5888
  if ((copy_length < length) && table->in_use->count_cuted_fields)
unknown's avatar
unknown committed
5889 5890 5891 5892 5893 5894
  {					// Check if we loosed some info
    const char *end=from+length;
    from+= copy_length;
    from+= field_charset->cset->scan(field_charset, from, end,
				     MY_SEQ_SPACES);
    if (from != end)
unknown's avatar
unknown committed
5895
      error= 2;
unknown's avatar
unknown committed
5896
  }
5897
  if (error)
5898 5899 5900 5901
  {
    if (table->in_use->abort_on_warning)
      set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
    else
5902
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
5903
  }
5904
  return error;
unknown's avatar
unknown committed
5905 5906 5907
}


5908 5909 5910 5911
/*
  Store double value in Field_string or Field_varstring.

  SYNOPSIS
unknown's avatar
unknown committed
5912
    store(double nr)
5913 5914 5915 5916 5917 5918
    nr            number

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

unknown's avatar
unknown committed
5919
int Field_str::store(double nr)
unknown's avatar
unknown committed
5920
{
5921
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
5922
  uint length;
unknown's avatar
unknown committed
5923
  bool use_scientific_notation= TRUE;
5924
  uint char_length= field_length / charset()->mbmaxlen;
5925 5926 5927 5928 5929 5930
  /*
    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;
5931
  if (char_length > 4 && char_length < 32 &&
unknown's avatar
Merge  
unknown committed
5932
      (anr < 1.0 ? anr > 1/(log_10[max(0,(int) char_length-neg-2)]) /* -2 for "0." */
5933
                 : anr < log_10[char_length-neg]-1))
unknown's avatar
unknown committed
5934
    use_scientific_notation= FALSE;
unknown's avatar
unknown committed
5935

unknown's avatar
unknown committed
5936 5937
  length= (uint) my_sprintf(buff, (buff, "%-.*g",
                                   (use_scientific_notation ?
5938 5939
                                    max(0, (int)char_length-neg-5) :
                                    char_length),
unknown's avatar
unknown committed
5940
                                   nr));
5941 5942 5943 5944 5945
  /*
    +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)
5946
    the test for char_length < 5 is for extreme cases,
5947
    like inserting 500.0 in char(1)
5948
  */
5949
  DBUG_ASSERT(char_length < 5 || length <= char_length+1);
5950
  return store((const char *) buff, length, charset());
5951 5952
}

unknown's avatar
unknown committed
5953

5954
int Field_string::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
5955
{
unknown's avatar
unknown committed
5956 5957 5958
  char buff[64];
  int  l;
  CHARSET_INFO *cs=charset();
5959 5960
  l= (cs->cset->longlong10_to_str)(cs,buff,sizeof(buff),
                                   unsigned_val ? 10 : -10, nr);
unknown's avatar
unknown committed
5961
  return Field_string::store(buff,(uint)l,cs);
unknown's avatar
unknown committed
5962 5963
}

5964

unknown's avatar
unknown committed
5965 5966
int Field_longstr::store_decimal(const my_decimal *d)
{
5967 5968
  char buff[DECIMAL_MAX_STR_LENGTH+1];
  String str(buff, sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
5969
  my_decimal2string(E_DEC_FATAL_ERROR, d, 0, 0, 0, &str);
5970
  return store(str.ptr(), str.length(), str.charset());
unknown's avatar
unknown committed
5971
}
unknown's avatar
unknown committed
5972

5973

unknown's avatar
unknown committed
5974 5975
double Field_string::val_real(void)
{
5976
  int not_used;
5977 5978 5979
  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
5980 5981 5982 5983 5984
}


longlong Field_string::val_int(void)
{
5985
  int not_used;
5986
  char *end_not_used;
5987
  CHARSET_INFO *cs=charset();
5988
  return my_strntoll(cs,ptr,field_length,10,&end_not_used,&not_used);
unknown's avatar
unknown committed
5989 5990 5991 5992 5993 5994
}


String *Field_string::val_str(String *val_buffer __attribute__((unused)),
			      String *val_ptr)
{
unknown's avatar
unknown committed
5995
  uint length= field_charset->cset->lengthsp(field_charset, ptr, field_length);
5996 5997
  /* See the comment for Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
unknown's avatar
unknown committed
5998
  val_ptr->set((const char*) ptr, length, field_charset);
unknown's avatar
unknown committed
5999 6000 6001 6002
  return val_ptr;
}


unknown's avatar
unknown committed
6003 6004 6005 6006 6007 6008 6009 6010
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
6011 6012
int Field_string::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
6013 6014
  uint a_len, b_len;

unknown's avatar
unknown committed
6015
  if (field_charset->strxfrm_multiply > 1)
6016 6017 6018 6019 6020
  {
    /*
      We have to remove end space to be able to compare multi-byte-characters
      like in latin_de 'ae' and 0xe4
    */
6021
    return field_charset->coll->strnncollsp(field_charset,
unknown's avatar
unknown committed
6022 6023
                                            (const uchar*) a_ptr, field_length,
                                            (const uchar*) b_ptr,
6024
                                            field_length, 0);
6025
  }
unknown's avatar
unknown committed
6026 6027 6028 6029 6030 6031 6032 6033
  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;
6034 6035
  return my_strnncoll(field_charset,(const uchar*) a_ptr, a_len,
                                    (const uchar*) b_ptr, b_len);
unknown's avatar
unknown committed
6036 6037
}

6038

unknown's avatar
unknown committed
6039 6040
void Field_string::sort_string(char *to,uint length)
{
6041
  uint tmp=my_strnxfrm(field_charset,
6042 6043
		       (unsigned char *) to, length,
		       (unsigned char *) ptr, field_length);
6044
  DBUG_ASSERT(tmp == length);
unknown's avatar
unknown committed
6045 6046 6047 6048 6049
}


void Field_string::sql_type(String &res) const
{
6050
  THD *thd= table->in_use;
unknown's avatar
unknown committed
6051
  CHARSET_INFO *cs=res.charset();
6052 6053 6054 6055 6056 6057 6058
  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") :
6059
			      (has_charset() ? "char" : "binary")),
6060
                             (int) field_length / charset()->mbmaxlen);
6061
  res.length(length);
6062 6063
  if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
      has_charset() && (charset()->state & MY_CS_BINSORT))
6064
    res.append(STRING_WITH_LEN(" binary"));
unknown's avatar
unknown committed
6065 6066
}

6067

unknown's avatar
unknown committed
6068
char *Field_string::pack(char *to, const char *from, uint max_length)
6069
{
unknown's avatar
unknown committed
6070 6071
  uint length=      min(field_length,max_length);
  uint char_length= max_length/field_charset->mbmaxlen;
6072
  if (length > char_length)
unknown's avatar
unknown committed
6073
    char_length= my_charpos(field_charset, from, from+length, char_length);
6074
  set_if_smaller(length, char_length);
unknown's avatar
unknown committed
6075 6076
  while (length && from[length-1] == ' ')
    length--;
6077
  *to++= (char) (uchar) length;
6078
  if (field_length > 255)
6079
    *to++= (char) (uchar) (length >> 8);
6080 6081
  memcpy(to, from, length);
  return to+length;
6082 6083 6084
}


unknown's avatar
unknown committed
6085 6086
const char *Field_string::unpack(char *to, const char *from)
{
6087 6088 6089 6090 6091 6092 6093 6094
  uint length;
  if (field_length > 255)
  {
    length= uint2korr(from);
    from+= 2;
  }
  else
    length= (uint) (uchar) *from++;
unknown's avatar
unknown committed
6095 6096 6097 6098 6099 6100
  memcpy(to, from, (int) length);
  bfill(to+length, field_length - length, ' ');
  return from+length;
}


6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118
/*
  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
6119
{
6120
  uint a_length, b_length;
6121
  if (length > 255)
6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132
  {
    a_length= uint2korr(a);
    b_length= uint2korr(b);
    a+= 2;
    b+= 2;
  }
  else
  {
    a_length= (uint) (uchar) *a++;
    b_length= (uint) (uchar) *b++;
  }
6133 6134 6135 6136
  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
6137 6138 6139
}


6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156
/*
  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)
6157
{
6158 6159 6160
  uint row_length, key_length;
  char *end;
  if (length > 255)
6161
  {
6162 6163
    key_length= uint2korr(key);
    key+= 2;
6164 6165
  }
  else
6166 6167 6168 6169
    key_length= (uint) (uchar) *key++;
  
  /* Only use 'length' of key, not field_length */
  end= ptr + length;
6170 6171
  while (end > ptr && end[-1] == ' ')
    end--;
6172 6173 6174 6175 6176 6177
  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);
6178 6179 6180
}


6181
uint Field_string::packed_col_length(const char *data_ptr, uint length)
unknown's avatar
unknown committed
6182
{
6183
  if (length > 255)
6184
    return uint2korr(data_ptr)+2;
6185
  return (uint) ((uchar) *data_ptr)+1;
unknown's avatar
unknown committed
6186 6187
}

6188

unknown's avatar
unknown committed
6189 6190
uint Field_string::max_packed_col_length(uint max_length)
{
6191
  return (max_length > 255 ? 2 : 1)+max_length;
unknown's avatar
unknown committed
6192 6193 6194
}


6195 6196
Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table)
{
6197 6198
  Field *new_field;

6199 6200 6201 6202 6203 6204 6205 6206
  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.
  */
6207 6208 6209 6210 6211 6212 6213 6214 6215 6216
  if (new_field= new Field_varstring(field_length, maybe_null(),
                                     field_name, new_table, charset()))
  {
    /*
      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.
    */
    new_field->ptr= ptr;
  }
6217
  return new_field;
6218 6219
}

unknown's avatar
unknown committed
6220
/****************************************************************************
6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233
  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
6234 6235 6236
****************************************************************************/


unknown's avatar
unknown committed
6237
int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
6238
{
6239
  uint32 not_used, copy_length;
unknown's avatar
unknown committed
6240
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
6241
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
6242
  int error_code= 0, well_formed_error;
unknown's avatar
unknown committed
6243
  enum MYSQL_ERROR::enum_warning_level level= MYSQL_ERROR::WARN_LEVEL_WARN;
unknown's avatar
unknown committed
6244

unknown's avatar
unknown committed
6245
  /* Convert character set if necessary */
unknown's avatar
unknown committed
6246
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
6247
  { 
6248 6249
    uint conv_errors;
    tmpstr.copy(from, length, cs, field_charset, &conv_errors);
unknown's avatar
unknown committed
6250 6251
    from= tmpstr.ptr();
    length=  tmpstr.length();
6252
    if (conv_errors)
unknown's avatar
unknown committed
6253
      error_code= WARN_DATA_TRUNCATED;
unknown's avatar
unknown committed
6254
  }
6255 6256 6257 6258 6259 6260 6261
  /* 
    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
6262 6263
						    field_charset->mbmaxlen,
                                                    &well_formed_error);
6264 6265 6266 6267 6268
  memcpy(ptr + length_bytes, from, copy_length);
  if (length_bytes == 1)
    *ptr= (uchar) copy_length;
  else
    int2store(ptr, copy_length);
6269 6270

  // Check if we lost something other than just trailing spaces
unknown's avatar
unknown committed
6271 6272
  if ((copy_length < length) && table->in_use->count_cuted_fields &&
      !error_code)
6273 6274 6275 6276
  {
    const char *end= from + length;
    from+= copy_length;
    from+= field_charset->cset->scan(field_charset, from, end, MY_SEQ_SPACES);
unknown's avatar
unknown committed
6277 6278 6279 6280
    /* If we lost only spaces then produce a NOTE, not a WARNING */
    if (from == end)
      level= MYSQL_ERROR::WARN_LEVEL_NOTE;
    error_code= WARN_DATA_TRUNCATED;
6281
  }
unknown's avatar
unknown committed
6282
  if (error_code)
6283
  {
unknown's avatar
unknown committed
6284 6285 6286 6287
    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
6288
    return 2;
6289
  }
unknown's avatar
unknown committed
6290
  return 0;
unknown's avatar
unknown committed
6291 6292 6293
}


6294
int Field_varstring::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
6295
{
unknown's avatar
unknown committed
6296
  char buff[64];
6297 6298 6299 6300
  uint  length;
  length= (uint) (field_charset->cset->longlong10_to_str)(field_charset,
                                                          buff,
                                                          sizeof(buff),
6301 6302 6303
                                                          (unsigned_val ? 10:
                                                           -10),
                                                           nr);
6304
  return Field_varstring::store(buff, length, field_charset);
unknown's avatar
unknown committed
6305 6306 6307 6308 6309
}


double Field_varstring::val_real(void)
{
6310
  int not_used;
6311
  char *end_not_used;
6312
  uint length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
6313
  return my_strntod(field_charset, ptr+length_bytes, length, &end_not_used,
6314
                    &not_used);
unknown's avatar
unknown committed
6315 6316 6317 6318 6319
}


longlong Field_varstring::val_int(void)
{
6320
  int not_used;
6321
  char *end_not_used;
6322
  uint length= length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
6323 6324
  return my_strntoll(field_charset, ptr+length_bytes, length, 10,
                     &end_not_used, &not_used);
unknown's avatar
unknown committed
6325 6326 6327 6328 6329
}

String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
				 String *val_ptr)
{
6330 6331
  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
6332 6333 6334 6335
  return val_ptr;
}


unknown's avatar
unknown committed
6336 6337 6338 6339 6340 6341 6342 6343 6344
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;
}


unknown's avatar
unknown committed
6345 6346
int Field_varstring::cmp(const char *a_ptr, const char *b_ptr)
{
6347
  uint a_length, b_length;
unknown's avatar
unknown committed
6348
  int diff;
6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359

  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);
  }
6360 6361
  diff= field_charset->coll->strnncollsp(field_charset,
                                         (const uchar*) a_ptr+
6362
                                         length_bytes,
6363 6364
                                         a_length,
                                         (const uchar*) b_ptr+
6365
                                         length_bytes,
6366 6367
                                         b_length,0);
  return diff;
unknown's avatar
unknown committed
6368 6369
}

6370

6371 6372 6373 6374
/*
  NOTE: varstring and blob keys are ALWAYS stored with a 2 byte length prefix
*/

6375 6376
int Field_varstring::key_cmp(const byte *key_ptr, uint max_key_length)
{
6377 6378
  uint length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
  uint char_length= max_key_length / field_charset->mbmaxlen;
6379

6380 6381
  char_length= my_charpos(field_charset, ptr + length_bytes,
                          ptr + length_bytes + length, char_length);
6382
  set_if_smaller(length, char_length);
6383 6384 6385 6386 6387 6388
  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
6389 6390
}

6391

6392 6393 6394 6395 6396 6397 6398 6399
/*
  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)
*/

6400 6401
int Field_varstring::key_cmp(const byte *a,const byte *b)
{
6402 6403 6404 6405 6406 6407 6408 6409
  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);
6410 6411 6412
}


unknown's avatar
unknown committed
6413 6414
void Field_varstring::sort_string(char *to,uint length)
{
6415
  uint tot_length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426

  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;
  }
 
6427 6428
  tot_length= my_strnxfrm(field_charset,
			  (uchar*) to, length,
6429
			  (uchar*) ptr + length_bytes,
6430
			  tot_length);
unknown's avatar
unknown committed
6431
  DBUG_ASSERT(tot_length == length);
unknown's avatar
unknown committed
6432 6433 6434
}


6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446
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
6447 6448
void Field_varstring::sql_type(String &res) const
{
6449
  THD *thd= table->in_use;
unknown's avatar
unknown committed
6450
  CHARSET_INFO *cs=res.charset();
6451 6452 6453 6454 6455 6456
  ulong length;

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

6463

6464 6465 6466 6467 6468
/*
  Functions to create a packed row.
  Here the number of length bytes are depending on the given max_length
*/

unknown's avatar
unknown committed
6469 6470
char *Field_varstring::pack(char *to, const char *from, uint max_length)
{
6471
  uint length= length_bytes == 1 ? (uint) (uchar) *from : uint2korr(from);
6472
  set_if_smaller(max_length, field_length);
unknown's avatar
unknown committed
6473 6474
  if (length > max_length)
    length=max_length;
unknown's avatar
unknown committed
6475
  *to++= (char) (length & 255);
unknown's avatar
unknown committed
6476
  if (max_length > 255)
unknown's avatar
unknown committed
6477
    *to++= (char) (length >> 8);
unknown's avatar
unknown committed
6478
  if (length)
6479
    memcpy(to, from+length_bytes, length);
unknown's avatar
unknown committed
6480 6481 6482 6483
  return to+length;
}


6484
char *Field_varstring::pack_key(char *to, const char *key, uint max_length)
6485
{
6486
  uint length=  length_bytes == 1 ? (uint) (uchar) *key : uint2korr(key);
6487 6488
  uint char_length= ((field_charset->mbmaxlen > 1) ?
                     max_length/field_charset->mbmaxlen : max_length);
6489
  key+= length_bytes;
6490
  if (length > char_length)
6491
  {
6492
    char_length= my_charpos(field_charset, key, key+length, char_length);
6493 6494
    set_if_smaller(length, char_length);
  }
6495 6496 6497 6498
  *to++= (char) (length & 255);
  if (max_length > 255)
    *to++= (char) (length >> 8);
  if (length)
6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563
    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);
6564 6565 6566 6567
  return to+length;
}


6568 6569 6570 6571
/*
  unpack field packed with Field_varstring::pack()
*/

unknown's avatar
unknown committed
6572 6573 6574
const char *Field_varstring::unpack(char *to, const char *from)
{
  uint length;
6575
  if (length_bytes == 1)
unknown's avatar
unknown committed
6576 6577 6578
    length= (uint) (uchar) (*to= *from++);
  else
  {
6579 6580 6581
    length= uint2korr(from);
    to[0]= *from++;
    to[1]= *from++;
unknown's avatar
unknown committed
6582 6583
  }
  if (length)
6584
    memcpy(to+ length_bytes, from, length);
unknown's avatar
unknown committed
6585 6586 6587 6588
  return from+length;
}


6589 6590
int Field_varstring::pack_cmp(const char *a, const char *b, uint key_length,
                              my_bool insert_or_update)
unknown's avatar
unknown committed
6591
{
6592
  uint a_length, b_length;
unknown's avatar
unknown committed
6593 6594
  if (key_length > 255)
  {
6595 6596
    a_length=uint2korr(a); a+= 2;
    b_length=uint2korr(b); b+= 2;
unknown's avatar
unknown committed
6597 6598 6599 6600 6601 6602
  }
  else
  {
    a_length= (uint) (uchar) *a++;
    b_length= (uint) (uchar) *b++;
  }
6603 6604 6605 6606
  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
6607 6608
}

6609 6610 6611

int Field_varstring::pack_cmp(const char *b, uint key_length,
                              my_bool insert_or_update)
6612
{
6613 6614
  char *a= ptr+ length_bytes;
  uint a_length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
6615
  uint b_length;
6616 6617 6618
  uint char_length= ((field_charset->mbmaxlen > 1) ?
                     key_length / field_charset->mbmaxlen : key_length);

6619 6620
  if (key_length > 255)
  {
6621
    b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
6622 6623 6624
  }
  else
    b_length= (uint) (uchar) *b++;
6625 6626 6627 6628 6629

  if (a_length > char_length)
  {
    char_length= my_charpos(field_charset, a, a+a_length, char_length);
    set_if_smaller(a_length, char_length);
6630
  }
6631 6632 6633 6634 6635 6636

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

6639

6640
uint Field_varstring::packed_col_length(const char *data_ptr, uint length)
unknown's avatar
unknown committed
6641
{
6642
  if (length > 255)
6643
    return uint2korr(data_ptr)+2;
6644
  return (uint) ((uchar) *data_ptr)+1;
unknown's avatar
unknown committed
6645 6646
}

6647

unknown's avatar
unknown committed
6648 6649
uint Field_varstring::max_packed_col_length(uint max_length)
{
6650
  return (max_length > 255 ? 2 : 1)+max_length;
unknown's avatar
unknown committed
6651 6652
}

6653 6654

void Field_varstring::get_key_image(char *buff, uint length, imagetype type)
6655
{
6656
  uint f_length=  length_bytes == 1 ? (uint) (uchar) *ptr : uint2korr(ptr);
6657
  uint char_length= length / field_charset->mbmaxlen;
6658 6659
  char *pos= ptr+length_bytes;
  char_length= my_charpos(field_charset, pos, pos + f_length, char_length);
6660
  set_if_smaller(f_length, char_length);
6661
  /* Key is always stored with 2 bytes */
6662
  int2store(buff,f_length);
6663
  memcpy(buff+HA_KEY_BLOB_LENGTH, pos, f_length);
6664
  if (f_length < length)
6665 6666 6667 6668 6669
  {
    /*
      Must clear this as we do a memcmp in opt_range.cc to detect
      identical keys
    */
6670
    bzero(buff+HA_KEY_BLOB_LENGTH+f_length, (length-f_length));
6671
  }
6672 6673
}

6674 6675

void Field_varstring::set_key_image(char *buff,uint length)
6676
{
6677
  length= uint2korr(buff);			// Real length is here
6678 6679
  (void) Field_varstring::store(buff+HA_KEY_BLOB_LENGTH, length,
                                field_charset);
6680 6681 6682
}


6683 6684 6685 6686 6687
int Field_varstring::cmp_binary(const char *a_ptr, const char *b_ptr,
                                uint32 max_length)
{
  uint32 a_length,b_length;

6688 6689 6690 6691 6692 6693 6694 6695 6696 6697
  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);
  }
6698 6699 6700 6701
  set_if_smaller(a_length, max_length);
  set_if_smaller(b_length, max_length);
  if (a_length != b_length)
    return 1;
6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715
  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
6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727
                                      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 */
6728
    res->length_bytes= 2;
unknown's avatar
unknown committed
6729
  }
6730
  return res;
6731 6732
}

6733

unknown's avatar
unknown committed
6734 6735 6736 6737 6738 6739
/****************************************************************************
** 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
6740
Field_blob::Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
6741 6742
		       enum utype unireg_check_arg, const char *field_name_arg,
		       struct st_table *table_arg,uint blob_pack_length,
6743
		       CHARSET_INFO *cs)
6744
  :Field_longstr(ptr_arg, BLOB_PACK_LENGTH_TO_MAX_LENGH(blob_pack_length),
unknown's avatar
unknown committed
6745
	     null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
6746
	     table_arg, cs),
unknown's avatar
unknown committed
6747
   packlength(blob_pack_length)
unknown's avatar
unknown committed
6748 6749 6750
{
  flags|= BLOB_FLAG;
  if (table)
6751
    table->s->blob_fields++;
unknown's avatar
unknown committed
6752 6753 6754
}


unknown's avatar
unknown committed
6755
void Field_blob::store_length(uint32 number)
unknown's avatar
unknown committed
6756 6757 6758 6759 6760 6761 6762
{
  switch (packlength) {
  case 1:
    ptr[0]= (uchar) number;
    break;
  case 2:
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
6763
    if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775
    {
      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
6776
    if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
6777 6778 6779 6780 6781 6782 6783 6784 6785 6786
    {
      int4store(ptr,number);
    }
    else
#endif
      longstore(ptr,number);
  }
}


unknown's avatar
unknown committed
6787
uint32 Field_blob::get_length(const char *pos)
unknown's avatar
unknown committed
6788 6789 6790
{
  switch (packlength) {
  case 1:
unknown's avatar
unknown committed
6791
    return (uint32) (uchar) pos[0];
unknown's avatar
unknown committed
6792 6793 6794 6795
  case 2:
    {
      uint16 tmp;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
6796
      if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
6797 6798 6799 6800
	tmp=sint2korr(pos);
      else
#endif
	shortget(tmp,pos);
unknown's avatar
unknown committed
6801
      return (uint32) tmp;
unknown's avatar
unknown committed
6802 6803
    }
  case 3:
unknown's avatar
unknown committed
6804
    return (uint32) uint3korr(pos);
unknown's avatar
unknown committed
6805 6806 6807 6808
  case 4:
    {
      uint32 tmp;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
6809
      if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
6810 6811 6812 6813
	tmp=uint4korr(pos);
      else
#endif
	longget(tmp,pos);
unknown's avatar
unknown committed
6814
      return (uint32) tmp;
unknown's avatar
unknown committed
6815 6816 6817 6818 6819 6820
    }
  }
  return 0;					// Impossible
}


6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856
/*
  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
6857
int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
6858
{
6859
  int error= 0, well_formed_error;
unknown's avatar
unknown committed
6860
  if (!length)
unknown's avatar
unknown committed
6861 6862 6863 6864 6865
  {
    bzero(ptr,Field_blob::pack_length());
  }
  else
  {
unknown's avatar
unknown committed
6866
    bool was_conversion;
unknown's avatar
unknown committed
6867
    char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
6868
    String tmpstr(buff,sizeof(buff), &my_charset_bin);
6869
    uint copy_length;
unknown's avatar
unknown committed
6870
    uint32 not_used;
unknown's avatar
unknown committed
6871

unknown's avatar
unknown committed
6872
    /* Convert character set if necessary */
unknown's avatar
unknown committed
6873 6874
    if ((was_conversion= String::needs_conversion(length, cs, field_charset,
						  &not_used)))
unknown's avatar
unknown committed
6875
    { 
6876
      uint conv_errors;
unknown's avatar
unknown committed
6877 6878 6879 6880 6881 6882
      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
6883 6884
      from= tmpstr.ptr();
      length=  tmpstr.length();
6885
      if (conv_errors)
unknown's avatar
unknown committed
6886
        error= 2;
unknown's avatar
unknown committed
6887
    }
6888 6889
    
    copy_length= max_data_length();
6890
    /*
unknown's avatar
unknown committed
6891
      copy_length is OK as last argument to well_formed_len as this is never
6892 6893 6894 6895
      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,
6896 6897 6898
                                                      from,from +
                                                      min(length, copy_length),
                                                      copy_length,
6899
                                                      &well_formed_error);
6900
    if (copy_length < length)
unknown's avatar
unknown committed
6901
      error= 2;
6902 6903
    Field_blob::store_length(copy_length);
    if (was_conversion || table->copy_blobs || copy_length <= MAX_FIELD_WIDTH)
unknown's avatar
unknown committed
6904
    {						// Must make a copy
unknown's avatar
unknown committed
6905 6906
      if (from != value.ptr())			// For valgrind
      {
6907
	value.copy(from,copy_length,charset());
unknown's avatar
unknown committed
6908
	from=value.ptr();
unknown's avatar
unknown committed
6909
      }
unknown's avatar
unknown committed
6910 6911 6912
    }
    bmove(ptr+packlength,(char*) &from,sizeof(char*));
  }
6913
  if (error)
6914 6915 6916 6917 6918 6919
  {
    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);
  }
6920
  return 0;
unknown's avatar
unknown committed
6921 6922 6923
}


unknown's avatar
unknown committed
6924
int Field_blob::store(double nr)
unknown's avatar
unknown committed
6925
{
6926 6927 6928
  CHARSET_INFO *cs=charset();
  value.set(nr, 2, cs);
  return Field_blob::store(value.ptr(),(uint) value.length(), cs);
unknown's avatar
unknown committed
6929 6930 6931
}


6932
int Field_blob::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
6933
{
6934
  CHARSET_INFO *cs=charset();
6935 6936 6937 6938
  if (unsigned_val)
    value.set((ulonglong) nr, cs);
  else
    value.set(nr, cs);
6939
  return Field_blob::store(value.ptr(), (uint) value.length(), cs);
unknown's avatar
unknown committed
6940 6941
}

6942

unknown's avatar
unknown committed
6943 6944
double Field_blob::val_real(void)
{
6945
  int not_used;
6946 6947 6948 6949
  char *end_not_used, *blob;
  uint32 length;
  CHARSET_INFO *cs;

unknown's avatar
unknown committed
6950 6951 6952
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
    return 0.0;
6953 6954
  length= get_length(ptr);
  cs= charset();
unknown's avatar
unknown committed
6955
  return my_strntod(cs, blob, length, &end_not_used, &not_used);
unknown's avatar
unknown committed
6956 6957 6958 6959 6960
}


longlong Field_blob::val_int(void)
{
6961
  int not_used;
unknown's avatar
unknown committed
6962 6963 6964 6965
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
    return 0;
unknown's avatar
unknown committed
6966
  uint32 length=get_length(ptr);
6967
  return my_strntoll(charset(),blob,length,10,NULL,&not_used);
unknown's avatar
unknown committed
6968 6969 6970 6971 6972 6973 6974 6975
}

String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
			    String *val_ptr)
{
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
6976
    val_ptr->set("",0,charset());	// A bit safer than ->length(0)
unknown's avatar
unknown committed
6977
  else
6978
    val_ptr->set((const char*) blob,get_length(ptr),charset());
unknown's avatar
unknown committed
6979 6980 6981 6982
  return val_ptr;
}


unknown's avatar
unknown committed
6983 6984
my_decimal *Field_blob::val_decimal(my_decimal *decimal_value)
{
6985 6986
  const char *blob;
  memcpy_fixed(&blob, ptr+packlength, sizeof(const char*));
unknown's avatar
unknown committed
6987 6988 6989 6990 6991 6992 6993 6994
  if (!blob)
    blob= "";
  str2my_decimal(E_DEC_FATAL_ERROR, blob, get_length(ptr), charset(),
                 decimal_value);
  return decimal_value;
}


unknown's avatar
unknown committed
6995 6996
int Field_blob::cmp(const char *a,uint32 a_length, const char *b,
		    uint32 b_length)
unknown's avatar
unknown committed
6997
{
6998 6999 7000 7001
  return field_charset->coll->strnncollsp(field_charset, 
                                          (const uchar*)a, a_length,
                                          (const uchar*)b, b_length,
                                          0);
unknown's avatar
unknown committed
7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015
}


int Field_blob::cmp(const char *a_ptr, const char *b_ptr)
{
  char *blob1,*blob2;
  memcpy_fixed(&blob1,a_ptr+packlength,sizeof(char*));
  memcpy_fixed(&blob2,b_ptr+packlength,sizeof(char*));
  return Field_blob::cmp(blob1,get_length(a_ptr),
			 blob2,get_length(b_ptr));
}


int Field_blob::cmp_binary(const char *a_ptr, const char *b_ptr,
unknown's avatar
unknown committed
7016
			   uint32 max_length)
unknown's avatar
unknown committed
7017 7018 7019
{
  char *a,*b;
  uint diff;
unknown's avatar
unknown committed
7020
  uint32 a_length,b_length;
unknown's avatar
unknown committed
7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035
  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 */

7036
void Field_blob::get_key_image(char *buff, uint length, imagetype type)
unknown's avatar
unknown committed
7037
{
unknown's avatar
unknown committed
7038
  uint32 blob_length= get_length(ptr);
unknown's avatar
unknown committed
7039
  char *blob;
unknown's avatar
unknown committed
7040

unknown's avatar
unknown committed
7041
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
7042
  if (type == itMBR)
unknown's avatar
unknown committed
7043
  {
unknown's avatar
unknown committed
7044
    const char *dummy;
unknown's avatar
unknown committed
7045
    MBR mbr;
7046 7047
    Geometry_buffer buffer;
    Geometry *gobj;
unknown's avatar
unknown committed
7048 7049 7050 7051 7052 7053 7054

    if (blob_length < SRID_SIZE)
    {
      bzero(buff, SIZEOF_STORED_DOUBLE*4);
      return;
    }
    get_ptr(&blob);
unknown's avatar
unknown committed
7055
    gobj= Geometry::construct(&buffer, blob, blob_length);
7056
    if (gobj->get_mbr(&mbr, &dummy))
unknown's avatar
unknown committed
7057 7058 7059 7060 7061 7062 7063 7064
      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
7065 7066
    return;
  }
unknown's avatar
unknown committed
7067
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
7068

7069
  get_ptr(&blob);
7070 7071 7072
  uint char_length= length / field_charset->mbmaxlen;
  char_length= my_charpos(field_charset, blob, blob + blob_length,
                          char_length);
7073
  set_if_smaller(blob_length, char_length);
7074

unknown's avatar
unknown committed
7075
  if ((uint32) length > blob_length)
unknown's avatar
unknown committed
7076
  {
7077 7078 7079 7080
    /*
      Must clear this as we do a memcmp in opt_range.cc to detect
      identical keys
    */
7081
    bzero(buff+HA_KEY_BLOB_LENGTH+blob_length, (length-blob_length));
unknown's avatar
unknown committed
7082
    length=(uint) blob_length;
unknown's avatar
unknown committed
7083
  }
unknown's avatar
unknown committed
7084
  int2store(buff,length);
7085
  memcpy(buff+HA_KEY_BLOB_LENGTH, blob, length);
unknown's avatar
unknown committed
7086 7087
}

7088 7089

void Field_blob::set_key_image(char *buff,uint length)
unknown's avatar
unknown committed
7090
{
7091
  length= uint2korr(buff);
7092
  (void) Field_blob::store(buff+HA_KEY_BLOB_LENGTH, length, field_charset);
unknown's avatar
unknown committed
7093 7094
}

unknown's avatar
unknown committed
7095

unknown's avatar
unknown committed
7096 7097 7098 7099 7100
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*));
7101 7102 7103 7104
  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);
7105
  return Field_blob::cmp(blob1, blob_length,
7106 7107
			 (char*) key_ptr+HA_KEY_BLOB_LENGTH,
			 uint2korr(key_ptr));
unknown's avatar
unknown committed
7108 7109 7110 7111
}

int Field_blob::key_cmp(const byte *a,const byte *b)
{
7112 7113
  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
7114 7115 7116
}


7117 7118 7119 7120 7121 7122 7123
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
7124 7125 7126 7127
void Field_blob::sort_string(char *to,uint length)
{
  char *blob;
  uint blob_length=get_length();
unknown's avatar
unknown committed
7128

unknown's avatar
unknown committed
7129 7130 7131 7132
  if (!blob_length)
    bzero(to,length);
  else
  {
7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157
    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
7158
    memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
unknown's avatar
unknown committed
7159 7160
    
    blob_length=my_strnxfrm(field_charset,
7161 7162
                            (uchar*) to, length, 
                            (uchar*) blob, blob_length);
7163
    DBUG_ASSERT(blob_length == length);
unknown's avatar
unknown committed
7164 7165 7166 7167 7168 7169 7170
  }
}


void Field_blob::sql_type(String &res) const
{
  const char *str;
7171
  uint length;
unknown's avatar
unknown committed
7172
  switch (packlength) {
7173 7174 7175 7176 7177
  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;
  }
7178
  res.set_ascii(str,length);
7179
  if (charset() == &my_charset_bin)
7180
    res.append(STRING_WITH_LEN("blob"));
7181 7182
  else
  {
7183
    res.append(STRING_WITH_LEN("text"));
unknown's avatar
unknown committed
7184 7185 7186 7187
  }
}


7188 7189 7190 7191
char *Field_blob::pack(char *to, const char *from, uint max_length)
{
  char *save=ptr;
  ptr=(char*) from;
unknown's avatar
unknown committed
7192
  uint32 length=get_length();			// Length of from string
7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214
  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
7215
  uint32 length=get_length(from);
7216 7217 7218 7219 7220 7221 7222 7223
  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
7224 7225
/* Keys for blobs are like keys on varchars */

7226 7227
int Field_blob::pack_cmp(const char *a, const char *b, uint key_length,
                         my_bool insert_or_update)
unknown's avatar
unknown committed
7228
{
7229
  uint a_length, b_length;
unknown's avatar
unknown committed
7230 7231 7232 7233 7234 7235 7236 7237 7238 7239
  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++;
  }
7240 7241 7242 7243
  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
7244 7245
}

7246

7247 7248
int Field_blob::pack_cmp(const char *b, uint key_length,
                         my_bool insert_or_update)
7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259 7260 7261 7262
{
  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++;
7263 7264 7265 7266
  return field_charset->coll->strnncollsp(field_charset,
                                          (const uchar*) a, a_length,
                                          (const uchar*) b, b_length,
                                          insert_or_update);
7267 7268
}

7269
/* Create a packed key that will be used for storage from a MySQL row */
7270

unknown's avatar
unknown committed
7271 7272
char *Field_blob::pack_key(char *to, const char *from, uint max_length)
{
7273 7274
  char *save=ptr;
  ptr=(char*) from;
unknown's avatar
unknown committed
7275
  uint32 length=get_length();			// Length of from string
7276 7277
  uint char_length= ((field_charset->mbmaxlen > 1) ?
                     max_length/field_charset->mbmaxlen : max_length);
7278 7279 7280 7281 7282
  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);
7283 7284 7285
  *to++= (uchar) length;
  if (max_length > 255)				// 2 byte length
    *to++= (uchar) (length >> 8);
7286
  memcpy(to, from, length);
7287 7288 7289 7290
  ptr=save;					// Restore org row pointer
  return to+length;
}

7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326 7327 7328 7329 7330 7331 7332 7333 7334

/*
  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;
}

7335

7336 7337 7338 7339 7340 7341
/* 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
7342 7343
  if (length > max_length)
    length=max_length;
unknown's avatar
unknown committed
7344
  *to++= (char) (length & 255);
unknown's avatar
unknown committed
7345
  if (max_length > 255)
unknown's avatar
unknown committed
7346
    *to++= (char) (length >> 8);
unknown's avatar
unknown committed
7347
  if (length)
7348
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
unknown's avatar
unknown committed
7349 7350 7351
  return to+length;
}

7352

7353
uint Field_blob::packed_col_length(const char *data_ptr, uint length)
7354 7355
{
  if (length > 255)
7356
    return uint2korr(data_ptr)+2;
7357
  return (uint) ((uchar) *data_ptr)+1;
7358 7359
}

7360

7361 7362 7363 7364
uint Field_blob::max_packed_col_length(uint max_length)
{
  return (max_length > 255 ? 2 : 1)+max_length;
}
7365

unknown's avatar
unknown committed
7366

unknown's avatar
unknown committed
7367
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
7368

7369
void Field_geom::get_key_image(char *buff, uint length, imagetype type)
unknown's avatar
unknown committed
7370 7371
{
  char *blob;
unknown's avatar
unknown committed
7372
  const char *dummy;
unknown's avatar
unknown committed
7373
  MBR mbr;
7374 7375 7376
  ulong blob_length= get_length(ptr);
  Geometry_buffer buffer;
  Geometry *gobj;
unknown's avatar
unknown committed
7377 7378 7379 7380 7381 7382 7383

  if (blob_length < SRID_SIZE)
  {
    bzero(buff, SIZEOF_STORED_DOUBLE*4);
    return;
  }
  get_ptr(&blob);
7384
  gobj= Geometry::construct(&buffer, blob, blob_length);
7385
  if (gobj->get_mbr(&mbr, &dummy))
unknown's avatar
unknown committed
7386 7387 7388 7389 7390 7391 7392 7393
    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
7394 7395 7396 7397 7398
}


void Field_geom::sql_type(String &res) const
{
unknown's avatar
unknown committed
7399 7400 7401 7402
  CHARSET_INFO *cs= &my_charset_latin1;
  switch (geom_type)
  {
    case GEOM_POINT:
7403
     res.set(STRING_WITH_LEN("point"), cs);
unknown's avatar
unknown committed
7404 7405
     break;
    case GEOM_LINESTRING:
7406
     res.set(STRING_WITH_LEN("linestring"), cs);
unknown's avatar
unknown committed
7407 7408
     break;
    case GEOM_POLYGON:
7409
     res.set(STRING_WITH_LEN("polygon"), cs);
unknown's avatar
unknown committed
7410 7411
     break;
    case GEOM_MULTIPOINT:
7412
     res.set(STRING_WITH_LEN("multipoint"), cs);
unknown's avatar
unknown committed
7413 7414
     break;
    case GEOM_MULTILINESTRING:
7415
     res.set(STRING_WITH_LEN("multilinestring"), cs);
unknown's avatar
unknown committed
7416 7417
     break;
    case GEOM_MULTIPOLYGON:
7418
     res.set(STRING_WITH_LEN("multipolygon"), cs);
unknown's avatar
unknown committed
7419 7420
     break;
    case GEOM_GEOMETRYCOLLECTION:
7421
     res.set(STRING_WITH_LEN("geometrycollection"), cs);
unknown's avatar
unknown committed
7422 7423
     break;
    default:
7424
     res.set(STRING_WITH_LEN("geometry"), cs);
unknown's avatar
unknown committed
7425
  }
unknown's avatar
unknown committed
7426 7427 7428
}


7429 7430 7431 7432 7433 7434 7435 7436
int Field_geom::store(double nr)
{
  my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
             ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
  return -1;
}


7437
int Field_geom::store(longlong nr, bool unsigned_val)
7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452
{
  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
7453 7454 7455 7456 7457 7458
int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
{
  if (!length)
    bzero(ptr, Field_blob::pack_length());
  else
  {
7459 7460
    if (from == Geometry::bad_geometry_data.ptr())
      goto err;
unknown's avatar
unknown committed
7461 7462 7463 7464
    // Check given WKB
    uint32 wkb_type;
    if (length < SRID_SIZE + WKB_HEADER_SIZE + SIZEOF_STORED_DOUBLE*2)
      goto err;
7465
    wkb_type= uint4korr(from + SRID_SIZE + 1);
7466
    if (wkb_type < (uint32) Geometry::wkb_point ||
unknown's avatar
unknown committed
7467
	wkb_type > (uint32) Geometry::wkb_end)
7468
      goto err;
unknown's avatar
unknown committed
7469 7470 7471 7472 7473 7474 7475 7476 7477
    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
7478 7479 7480

err:
  bzero(ptr, Field_blob::pack_length());  
7481 7482
  my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
             ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
unknown's avatar
unknown committed
7483
  return -1;
unknown's avatar
unknown committed
7484 7485
}

unknown's avatar
unknown committed
7486
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
7487

unknown's avatar
unknown committed
7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510
/****************************************************************************
** 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
7511
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7512 7513 7514 7515 7516 7517 7518 7519 7520 7521
  {
    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
7522
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7523 7524 7525 7526 7527 7528 7529 7530 7531
  {
    int4store(ptr,value);
  }
  else
#endif
    longstore(ptr,(long) value);
  break;
  case 8:
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
7532
  if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547
  {
    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
7548
int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
7549
{
7550
  int err= 0;
unknown's avatar
unknown committed
7551
  uint32 not_used;
unknown's avatar
unknown committed
7552
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
7553
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
7554

unknown's avatar
unknown committed
7555
  /* Convert character set if necessary */
unknown's avatar
unknown committed
7556
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
7557
  { 
7558 7559
    uint dummy_errors;
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
unknown's avatar
unknown committed
7560 7561 7562
    from= tmpstr.ptr();
    length=  tmpstr.length();
  }
7563 7564

  /* Remove end space */
7565
  length= field_charset->cset->lengthsp(field_charset, from, length);
7566
  uint tmp=find_type2(typelib, from, length, field_charset);
unknown's avatar
unknown committed
7567
  if (!tmp)
unknown's avatar
unknown committed
7568
  {
7569
    if (length < 6) // Can't be more than 99999 enums
unknown's avatar
unknown committed
7570
    {
unknown's avatar
unknown committed
7571
      /* This is for reading numbers with LOAD DATA INFILE */
7572
      char *end;
7573 7574
      tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
      if (err || end != from+length || tmp > typelib->count)
unknown's avatar
unknown committed
7575 7576
      {
	tmp=0;
7577
	set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
7578
      }
unknown's avatar
unknown committed
7579 7580
    }
    else
7581
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
7582
  }
unknown's avatar
unknown committed
7583
  store_type((ulonglong) tmp);
7584
  return err;
unknown's avatar
unknown committed
7585 7586 7587
}


unknown's avatar
unknown committed
7588
int Field_enum::store(double nr)
unknown's avatar
unknown committed
7589
{
7590
  return Field_enum::store((longlong) nr, FALSE);
unknown's avatar
unknown committed
7591 7592 7593
}


7594
int Field_enum::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
7595
{
unknown's avatar
unknown committed
7596
  int error= 0;
7597
  if ((ulonglong) nr > typelib->count || nr == 0)
unknown's avatar
unknown committed
7598
  {
7599
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
7600
    nr=0;
7601
    error=1;
unknown's avatar
unknown committed
7602 7603
  }
  store_type((ulonglong) (uint) nr);
7604
  return error;
unknown's avatar
unknown committed
7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622
}


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
7623
      if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635
	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
7636
      if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7637 7638 7639 7640 7641 7642 7643 7644 7645 7646
	tmp=uint4korr(ptr);
      else
#endif
	longget(tmp,ptr);
      return (longlong) tmp;
    }
  case 8:
    {
      longlong tmp;
#ifdef WORDS_BIGENDIAN
unknown's avatar
unknown committed
7647
      if (table->s->db_low_byte_first)
unknown's avatar
unknown committed
7648 7649 7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661 7662 7663
	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
7664
    val_ptr->set("", 0, field_charset);
unknown's avatar
unknown committed
7665 7666
  else
    val_ptr->set((const char*) typelib->type_names[tmp-1],
7667
		 typelib->type_lengths[tmp-1],
7668
		 field_charset);
unknown's avatar
unknown committed
7669 7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696
  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
{
7697 7698 7699
  char buffer[255];
  String enum_item(buffer, sizeof(buffer), res.charset());

unknown's avatar
unknown committed
7700
  res.length(0);
7701
  res.append(STRING_WITH_LEN("enum("));
unknown's avatar
unknown committed
7702 7703

  bool flag=0;
7704 7705
  uint *len= typelib->type_lengths;
  for (const char **pos= typelib->type_names; *pos; pos++, len++)
unknown's avatar
unknown committed
7706
  {
7707
    uint dummy_errors;
unknown's avatar
unknown committed
7708 7709
    if (flag)
      res.append(',');
7710
    /* convert to res.charset() == utf8, then quote */
7711
    enum_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
7712 7713
    append_unescaped(&res, enum_item.ptr(), enum_item.length());
    flag= 1;
unknown's avatar
unknown committed
7714 7715 7716 7717 7718
  }
  res.append(')');
}


7719 7720 7721 7722 7723 7724 7725 7726
/*
   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
7727 7728


unknown's avatar
unknown committed
7729
int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
7730
{
unknown's avatar
unknown committed
7731
  bool got_warning= 0;
7732
  int err= 0;
7733 7734
  char *not_used;
  uint not_used2;
unknown's avatar
unknown committed
7735
  uint32 not_used_offset;
unknown's avatar
unknown committed
7736
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
7737
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
7738

unknown's avatar
unknown committed
7739
  /* Convert character set if necessary */
unknown's avatar
unknown committed
7740
  if (String::needs_conversion(length, cs, field_charset, &not_used_offset))
unknown's avatar
unknown committed
7741
  { 
7742 7743
    uint dummy_errors;
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
unknown's avatar
unknown committed
7744 7745 7746
    from= tmpstr.ptr();
    length=  tmpstr.length();
  }
7747 7748
  ulonglong tmp= find_set(typelib, from, length, field_charset,
                          &not_used, &not_used2, &got_warning);
unknown's avatar
unknown committed
7749 7750 7751
  if (!tmp && length && length < 22)
  {
    /* This is for reading numbers with LOAD DATA INFILE */
7752
    char *end;
7753 7754
    tmp=my_strntoull(cs,from,length,10,&end,&err);
    if (err || end != from+length ||
unknown's avatar
unknown committed
7755
	tmp > (ulonglong) (((longlong) 1 << typelib->count) - (longlong) 1))
7756
    {
7757
      tmp=0;      
7758
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
7759
    }
unknown's avatar
unknown committed
7760
  }
unknown's avatar
unknown committed
7761
  else if (got_warning)
7762
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
7763
  store_type(tmp);
7764
  return err;
unknown's avatar
unknown committed
7765 7766 7767
}


7768
int Field_set::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
7769
{
unknown's avatar
unknown committed
7770
  int error= 0;
unknown's avatar
unknown committed
7771 7772 7773
  if ((ulonglong) nr > (ulonglong) (((longlong) 1 << typelib->count) -
				    (longlong) 1))
  {
7774
    nr&= (longlong) (((longlong) 1 << typelib->count) - (longlong) 1);    
7775
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
7776
    error=1;
unknown's avatar
unknown committed
7777 7778
  }
  store_type((ulonglong) nr);
7779
  return error;
unknown's avatar
unknown committed
7780 7781 7782 7783 7784 7785 7786 7787 7788 7789
}


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);
7790
  val_buffer->set_charset(field_charset);
unknown's avatar
unknown committed
7791 7792 7793 7794 7795
  while (tmp && bitnr < (uint) typelib->count)
  {
    if (tmp & 1)
    {
      if (val_buffer->length())
7796
	val_buffer->append(&field_separator, 1, &my_charset_latin1);
unknown's avatar
unknown committed
7797
      String str(typelib->type_names[bitnr],
7798
		 typelib->type_lengths[bitnr],
7799
		 field_charset);
unknown's avatar
unknown committed
7800 7801 7802 7803 7804 7805 7806 7807 7808 7809 7810
      val_buffer->append(str);
    }
    tmp>>=1;
    bitnr++;
  }
  return val_buffer;
}


void Field_set::sql_type(String &res) const
{
7811 7812 7813
  char buffer[255];
  String set_item(buffer, sizeof(buffer), res.charset());

unknown's avatar
unknown committed
7814
  res.length(0);
7815
  res.append(STRING_WITH_LEN("set("));
unknown's avatar
unknown committed
7816 7817

  bool flag=0;
7818 7819
  uint *len= typelib->type_lengths;
  for (const char **pos= typelib->type_names; *pos; pos++, len++)
unknown's avatar
unknown committed
7820
  {
7821
    uint dummy_errors;
unknown's avatar
unknown committed
7822 7823
    if (flag)
      res.append(',');
7824
    /* convert to res.charset() == utf8, then quote */
7825
    set_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
7826 7827
    append_unescaped(&res, set_item.ptr(), set_item.length());
    flag= 1;
unknown's avatar
unknown committed
7828 7829 7830 7831 7832 7833 7834 7835
  }
  res.append(')');
}

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

bool Field::eq_def(Field *field)
{
7836
  if (real_type() != field->real_type() || charset() != field->charset() ||
unknown's avatar
unknown committed
7837 7838 7839 7840 7841 7842 7843 7844 7845 7846
      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
7847

unknown's avatar
unknown committed
7848 7849 7850
  if (typelib->count < from_lib->count)
    return 0;
  for (uint i=0 ; i < from_lib->count ; i++)
7851 7852
    if (my_strnncoll(field_charset,
                     (const uchar*)typelib->type_names[i],
7853
                     (uint) strlen(typelib->type_names[i]),
7854
                     (const uchar*)from_lib->type_names[i],
7855
                     (uint) strlen(from_lib->type_names[i])))
unknown's avatar
unknown committed
7856 7857 7858 7859 7860
      return 0;
  return 1;
}

bool Field_num::eq_def(Field *field)
unknown's avatar
unknown committed
7861
{
unknown's avatar
unknown committed
7862 7863 7864 7865 7866 7867 7868 7869 7870 7871 7872 7873
  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
7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901 7902
/*
  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
7903 7904 7905 7906 7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922 7923 7924 7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938 7939
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,
                     enum utype unireg_check_arg, const char *field_name_arg,
                     struct st_table *table_arg)
  : Field(ptr_arg, len_arg >> 3, null_ptr_arg, null_bit_arg,
          unireg_check_arg, field_name_arg, table_arg),
    bit_ptr(bit_ptr_arg), bit_ofs(bit_ofs_arg), bit_len(len_arg & 7)
{
  /*
    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
7940 7941 7942 7943
int Field_bit::store(const char *from, uint length, CHARSET_INFO *cs)
{
  int delta;

7944
  for (; length && !*from; from++, length--);          // skip left 0's
unknown's avatar
unknown committed
7945 7946 7947 7948 7949 7950 7951 7952
  delta= field_length - length;

  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);
    memset(ptr, 0xff, field_length);
7953 7954 7955 7956
    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
7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987
    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++;
    }
    memcpy(ptr, from, field_length);
  }
  return 0;
}


int Field_bit::store(double nr)
{
7988
  return store((longlong) nr, FALSE);
unknown's avatar
unknown committed
7989 7990 7991
}


7992
int Field_bit::store(longlong nr, bool unsigned_val)
unknown's avatar
unknown committed
7993 7994 7995 7996 7997 7998 7999 8000
{
  char buf[8];

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


unknown's avatar
unknown committed
8001 8002 8003 8004 8005 8006 8007 8008
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
8009 8010 8011 8012 8013 8014 8015 8016 8017 8018
double Field_bit::val_real(void)
{
  return (double) Field_bit::val_int();
}


longlong Field_bit::val_int(void)
{
  ulonglong bits= 0;
  if (bit_len)
8019
  {
unknown's avatar
unknown committed
8020
    bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
8021 8022
    bits<<= (field_length * 8);
  }
unknown's avatar
unknown committed
8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040

  switch (field_length) {
  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);
  default: return mi_uint8korr(ptr + field_length - sizeof(longlong));
  }
}  


String *Field_bit::val_str(String *val_buffer,
                           String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
8041
  char buff[sizeof(longlong)];
unknown's avatar
unknown committed
8042 8043
  uint length= min(pack_length(), sizeof(longlong));
  ulonglong bits= val_int();
unknown's avatar
unknown committed
8044
  mi_int8store(buff,bits);
unknown's avatar
unknown committed
8045 8046

  val_buffer->alloc(length);
unknown's avatar
unknown committed
8047
  memcpy_fixed((char*) val_buffer->ptr(), buff+8-length, length);
unknown's avatar
unknown committed
8048 8049 8050 8051 8052 8053
  val_buffer->length(length);
  val_buffer->set_charset(&my_charset_bin);
  return val_buffer;
}


unknown's avatar
unknown committed
8054 8055 8056 8057 8058 8059 8060
my_decimal *Field_bit::val_decimal(my_decimal *deciaml_value)
{
  int2my_decimal(E_DEC_FATAL_ERROR, val_int(), 1, deciaml_value);
  return deciaml_value;
}


unknown's avatar
unknown committed
8061 8062 8063 8064 8065 8066
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
8067
    if ((flag= (int) (bits - *(uchar*) str)))
unknown's avatar
unknown committed
8068 8069 8070 8071
      return flag;
    str++;
    length--;
  }
unknown's avatar
unknown committed
8072
  return memcmp(ptr, str, length);
unknown's avatar
unknown committed
8073 8074 8075 8076 8077 8078 8079 8080 8081 8082 8083 8084 8085
}


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
8086
  return memcmp(ptr, ptr + row_offset, field_length);
unknown's avatar
unknown committed
8087 8088 8089 8090 8091 8092 8093 8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135 8136 8137
}


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--;
  }
  memcpy(buff, ptr, min(length, field_length));
}


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(),
                                   "bit(%d)", 
                                   (int) field_length * 8 + bit_len);
  res.length((uint) length);
}


char *Field_bit::pack(char *to, const char *from, uint max_length)
{
  uint length= min(field_length + (bit_len > 0), max_length);
  if (bit_len)
  {
    uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
    *to++= bits;
    length--;
  }
  memcpy(to, from, length); 
  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++;
  }
  memcpy(to, from, field_length);
  return from + field_length;
}


8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163
/*
  Bit field support for non-MyISAM tables.
*/

Field_bit_as_char::Field_bit_as_char(char *ptr_arg, uint32 len_arg,
                                     uchar *null_ptr_arg, uchar null_bit_arg, 
                                     uchar *bit_ptr_arg, uchar bit_ofs_arg, 
                                     enum utype unireg_check_arg, 
                                     const char *field_name_arg,
                                     struct st_table *table_arg)
  : Field_bit(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, bit_ptr_arg,
              bit_ofs_arg, unireg_check_arg, field_name_arg, table_arg),
    create_length(len_arg)
{
  bit_ptr= 0;
  bit_ofs= 0;
  bit_len= 0;
  field_length= ((len_arg + 7) & ~7) / 8;
}


int Field_bit_as_char::store(const char *from, uint length, CHARSET_INFO *cs)
{
  int delta;
  uchar bits= create_length & 7;

8164
  for (; length && !*from; from++, length--);          // skip left 0's
8165 8166 8167 8168 8169 8170
  delta= field_length - length;

  if (delta < 0 ||
      (delta == 0 && bits && (uint) (uchar) *from >= (uint) (1 << bits)))
  {
    memset(ptr, 0xff, field_length);
8171 8172
    if (bits)
      *ptr&= ((1 << bits) - 1); /* set first byte */
8173 8174 8175 8176
    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);
8177 8178 8179 8180 8181 8182 8183 8184 8185 8186 8187 8188 8189 8190 8191 8192 8193
    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(),
                                   "bit(%d)", (int) create_length);
  res.length((uint) length);
}


unknown's avatar
unknown committed
8194
/*****************************************************************************
8195
  Handling of field and create_field
unknown's avatar
unknown committed
8196 8197
*****************************************************************************/

8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208
/*
  Convert create_field::length from number of characters to number of bytes

  SYNOPSIS
    create_field::create_length_to_internal_length()
  
  DESCRIPTION
    Convert create_field::length from number of characters to number of bytes,
    save original value in chars_length.
*/

8209 8210
void create_field::create_length_to_internal_length(void)
{
8211
  chars_length= length;
unknown's avatar
unknown committed
8212 8213 8214 8215 8216 8217 8218
  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:
8219
  case MYSQL_TYPE_VARCHAR:
unknown's avatar
unknown committed
8220
    length*= charset->mbmaxlen;
8221
    key_length= length;
8222
    pack_length= calc_pack_length(sql_type, length);
unknown's avatar
unknown committed
8223 8224 8225
    break;
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_SET:
8226
    /* Pack_length already calculated in sql_parse.cc */
unknown's avatar
unknown committed
8227
    length*= charset->mbmaxlen;
8228
    key_length= pack_length;
unknown's avatar
unknown committed
8229
    break;
unknown's avatar
unknown committed
8230
  case MYSQL_TYPE_BIT:
8231 8232 8233 8234 8235 8236 8237 8238 8239 8240
    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
8241
    break;
unknown's avatar
unknown committed
8242
  case MYSQL_TYPE_NEWDECIMAL:
unknown's avatar
unknown committed
8243 8244 8245 8246 8247 8248
    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
8249
    break;
unknown's avatar
unknown committed
8250
  default:
8251
    key_length= pack_length= calc_pack_length(sql_type, length);
unknown's avatar
unknown committed
8252
    break;
8253 8254 8255
  }
}

8256

8257 8258 8259 8260 8261 8262 8263 8264 8265 8266 8267 8268 8269 8270 8271 8272 8273 8274
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;
  length= length_arg;;
  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));
}


8275 8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288 8289
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
8290
/*
unknown's avatar
unknown committed
8291
  Make a field from the .frm file info
unknown's avatar
unknown committed
8292 8293 8294 8295 8296
*/

uint32 calc_pack_length(enum_field_types type,uint32 length)
{
  switch (type) {
8297
  case MYSQL_TYPE_VAR_STRING:
8298
  case MYSQL_TYPE_STRING:
8299
  case FIELD_TYPE_DECIMAL:     return (length);
8300
  case MYSQL_TYPE_VARCHAR:     return (length + (length < 256 ? 1: 2));
unknown's avatar
unknown committed
8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312 8313 8314 8315
  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
8316
  case FIELD_TYPE_BLOB:		return 2+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
8317 8318
  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
8319
  case FIELD_TYPE_GEOMETRY:	return 4+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
8320
  case FIELD_TYPE_SET:
unknown's avatar
unknown committed
8321
  case FIELD_TYPE_ENUM:
8322 8323
  case FIELD_TYPE_NEWDECIMAL:
    abort(); return 0;                          // This shouldn't happen
unknown's avatar
unknown committed
8324
  case FIELD_TYPE_BIT: return length / 8;
8325 8326
  default:
    return 0;
unknown's avatar
unknown committed
8327 8328 8329 8330 8331 8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343 8344
  }
}


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
}


Field *make_field(char *ptr, uint32 field_length,
unknown's avatar
unknown committed
8345
		  uchar *null_pos, uchar null_bit,
unknown's avatar
unknown committed
8346
		  uint pack_flag,
8347
		  enum_field_types field_type,
8348
		  CHARSET_INFO *field_charset,
unknown's avatar
unknown committed
8349
		  Field::geometry_type geom_type,
unknown's avatar
unknown committed
8350 8351 8352 8353 8354
		  Field::utype unireg_check,
		  TYPELIB *interval,
		  const char *field_name,
		  struct st_table *table)
{
unknown's avatar
unknown committed
8355 8356 8357 8358
  uchar *bit_ptr;
  uchar bit_offset;
  LINT_INIT(bit_ptr);
  LINT_INIT(bit_offset);
8359
  if (field_type == FIELD_TYPE_BIT && !f_bit_as_char(pack_flag))
unknown's avatar
unknown committed
8360 8361 8362 8363 8364 8365 8366 8367 8368 8369
  {
    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
8370 8371 8372 8373 8374
  if (!f_maybe_null(pack_flag))
  {
    null_pos=0;
    null_bit=0;
  }
unknown's avatar
unknown committed
8375 8376 8377 8378
  else
  {
    null_bit= ((uchar) 1) << null_bit;
  }
unknown's avatar
unknown committed
8379 8380 8381 8382 8383 8384 8385 8386 8387 8388 8389 8390

  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
8391 8392 8393
  if (f_is_alpha(pack_flag))
  {
    if (!f_is_packed(pack_flag))
unknown's avatar
unknown committed
8394
    {
8395
      if (field_type == MYSQL_TYPE_STRING ||
8396
          field_type == FIELD_TYPE_DECIMAL ||   // 3.23 or 4.0 string
8397
          field_type == MYSQL_TYPE_VAR_STRING)
unknown's avatar
unknown committed
8398 8399 8400
        return new Field_string(ptr,field_length,null_pos,null_bit,
                                unireg_check, field_name, table,
                                field_charset);
8401
      if (field_type == MYSQL_TYPE_VARCHAR)
8402 8403 8404
        return new Field_varstring(ptr,field_length,
                                   HA_VARCHAR_PACKLENGTH(field_length),
                                   null_pos,null_bit,
8405 8406
                                   unireg_check, field_name, table,
                                   field_charset);
unknown's avatar
unknown committed
8407 8408
      return 0;                                 // Error
    }
unknown's avatar
unknown committed
8409 8410 8411 8412 8413

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

unknown's avatar
unknown committed
8414
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
8415 8416
    if (f_is_geom(pack_flag))
      return new Field_geom(ptr,null_pos,null_bit,
unknown's avatar
unknown committed
8417
			    unireg_check, field_name, table,
unknown's avatar
unknown committed
8418
			    pack_length, geom_type);
unknown's avatar
unknown committed
8419
#endif
unknown's avatar
unknown committed
8420 8421 8422
    if (f_is_blob(pack_flag))
      return new Field_blob(ptr,null_pos,null_bit,
			    unireg_check, field_name, table,
unknown's avatar
unknown committed
8423
			    pack_length, field_charset);
unknown's avatar
unknown committed
8424 8425 8426 8427 8428
    if (interval)
    {
      if (f_is_enum(pack_flag))
	return new Field_enum(ptr,field_length,null_pos,null_bit,
				  unireg_check, field_name, table,
8429
				  pack_length, interval, field_charset);
unknown's avatar
unknown committed
8430 8431 8432
      else
	return new Field_set(ptr,field_length,null_pos,null_bit,
			     unireg_check, field_name, table,
8433
			     pack_length, interval, field_charset);
unknown's avatar
unknown committed
8434 8435 8436
    }
  }

8437
  switch (field_type) {
unknown's avatar
unknown committed
8438 8439 8440 8441 8442 8443
  case FIELD_TYPE_DECIMAL:
    return new Field_decimal(ptr,field_length,null_pos,null_bit,
			     unireg_check, field_name, table,
			     f_decimals(pack_flag),
			     f_is_zerofill(pack_flag) != 0,
			     f_is_dec(pack_flag) == 0);
unknown's avatar
unknown committed
8444 8445 8446 8447 8448 8449
  case FIELD_TYPE_NEWDECIMAL:
    return new Field_new_decimal(ptr,field_length,null_pos,null_bit,
                                 unireg_check, field_name, table,
                                 f_decimals(pack_flag),
                                 f_is_zerofill(pack_flag) != 0,
                                 f_is_dec(pack_flag) == 0);
unknown's avatar
unknown committed
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
  case FIELD_TYPE_FLOAT:
    return new Field_float(ptr,field_length,null_pos,null_bit,
			   unireg_check, field_name, table,
			   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,
			    unireg_check, field_name, table,
			    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,
			  unireg_check, field_name, table,
			  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,
			   unireg_check, field_name, table,
			   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,
			    unireg_check, field_name, table,
			    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,
			   unireg_check, field_name, table,
			   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,
			      unireg_check, field_name, table,
			      f_is_zerofill(pack_flag) != 0,
			      f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_TIMESTAMP:
8488 8489 8490
    return new Field_timestamp(ptr,field_length, null_pos, null_bit,
                               unireg_check, field_name, table,
                               field_charset);
unknown's avatar
unknown committed
8491 8492 8493 8494 8495
  case FIELD_TYPE_YEAR:
    return new Field_year(ptr,field_length,null_pos,null_bit,
			  unireg_check, field_name, table);
  case FIELD_TYPE_DATE:
    return new Field_date(ptr,null_pos,null_bit,
8496
			  unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
8497 8498
  case FIELD_TYPE_NEWDATE:
    return new Field_newdate(ptr,null_pos,null_bit,
8499
			     unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
8500 8501
  case FIELD_TYPE_TIME:
    return new Field_time(ptr,null_pos,null_bit,
8502
			  unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
8503 8504
  case FIELD_TYPE_DATETIME:
    return new Field_datetime(ptr,null_pos,null_bit,
8505
			      unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
8506
  case FIELD_TYPE_NULL:
8507
    return new Field_null(ptr,field_length,unireg_check,field_name,table, field_charset);
unknown's avatar
unknown committed
8508
  case FIELD_TYPE_BIT:
8509 8510 8511 8512
    return f_bit_as_char(pack_flag) ?
           new Field_bit_as_char(ptr, field_length, null_pos, null_bit, bit_ptr,
                                 bit_offset, unireg_check, field_name, table) :
           new Field_bit(ptr, field_length, null_pos, null_bit, bit_ptr,
unknown's avatar
unknown committed
8513
                         bit_offset, unireg_check, field_name, table);
8514 8515
  default:					// Impossible (Wrong version)
    break;
unknown's avatar
unknown committed
8516
  }
unknown's avatar
unknown committed
8517
  return 0;
unknown's avatar
unknown committed
8518 8519 8520 8521 8522
}


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

8523
create_field::create_field(Field *old_field,Field *orig_field)
unknown's avatar
unknown committed
8524 8525 8526 8527 8528 8529 8530
{
  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();
8531
  key_length= old_field->key_length();
unknown's avatar
unknown committed
8532
  sql_type=   old_field->real_type();
unknown's avatar
unknown committed
8533 8534
  charset=    old_field->charset();		// May be NULL ptr
  comment=    old_field->comment;
8535
  decimals=   old_field->decimals();
unknown's avatar
unknown committed
8536 8537 8538

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

8542 8543 8544 8545 8546 8547 8548 8549 8550 8551 8552
  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;
8553
  case MYSQL_TYPE_STRING:
unknown's avatar
unknown committed
8554
    /* Change CHAR -> VARCHAR if dynamic record length */
8555 8556 8557 8558 8559 8560 8561 8562
    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:
8563
    /* This is corrected in create_length_to_internal_length */
8564 8565 8566 8567 8568 8569 8570
    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
unknown's avatar
unknown committed
8571
  case FIELD_TYPE_BIT:
8572 8573 8574
    length= (old_field->key_type() == HA_KEYTYPE_BIT) ?
            ((Field_bit *) old_field)->bit_len + length * 8 :
            ((Field_bit_as_char *) old_field)->create_length;
unknown's avatar
unknown committed
8575
    break;
8576 8577
  default:
    break;
unknown's avatar
unknown committed
8578
  }
8579

unknown's avatar
unknown committed
8580 8581 8582 8583
  if (flags & (ENUM_FLAG | SET_FLAG))
    interval= ((Field_enum*) old_field)->typelib;
  else
    interval=0;
8584
  def=0;
8585

8586
  if (!(flags & (NO_DEFAULT_VALUE_FLAG | BLOB_FLAG)) &&
8587 8588 8589 8590
      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
8591 8592
  {
    char buff[MAX_FIELD_WIDTH],*pos;
8593 8594
    String tmp(buff,sizeof(buff), charset), *res;
    my_ptrdiff_t diff;
8595

unknown's avatar
unknown committed
8596
    /* Get the value from default_values */
8597 8598
    diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
                          orig_field->table->record[0]);
unknown's avatar
unknown committed
8599
    orig_field->move_field(diff);		// Points now at default_values
8600
    bool is_null=orig_field->is_real_null();
8601
    res= orig_field->val_str(&tmp);
8602
    orig_field->move_field(-diff);		// Back to record[0]
8603
    if (!is_null)
8604
    {
8605 8606
      pos= (char*) sql_strmake(res->ptr(), res->length());
      def= new Item_string(pos, res->length(), charset);
8607
    }
unknown's avatar
unknown committed
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
/*
  maximum possible display length for blob

  SYNOPSIS
    Field_blob::max_length()

  RETURN
    length
*/
uint32 Field_blob::max_length()
{
  switch (packlength)
  {
  case 1:
    return 255;
  case 2:
    return 65535;
  case 3:
    return 16777215;
  case 4:
    return (uint32) 4294967295U;
  default:
    DBUG_ASSERT(0); // we should never go here
    return 0;
  }
}


/*****************************************************************************
 Warning handling
*****************************************************************************/
8643 8644 8645 8646

/*
  Produce warning or note about data saved into field

unknown's avatar
unknown committed
8647
  SYNOPSIS
8648 8649 8650 8651 8652 8653 8654 8655 8656 8657
    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
8658 8659
    1 if count_cuted_fields == FIELD_CHECK_IGNORE
    0 otherwise
8660
*/
8661

8662
bool 
8663 8664
Field::set_warning(MYSQL_ERROR::enum_warning_level level, uint code,
                   int cuted_increment)
8665
{
8666
  THD *thd= table->in_use;
unknown's avatar
unknown committed
8667 8668
  if (thd->count_cuted_fields)
  {
8669
    thd->cuted_fields+= cuted_increment;
8670 8671
    push_warning_printf(thd, level, code, ER(code), field_name,
                        thd->row_count);
8672 8673 8674 8675 8676 8677 8678 8679 8680
    return 0;
  }
  return 1;
}


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

unknown's avatar
unknown committed
8681
  SYNOPSIS
unknown's avatar
unknown committed
8682
    set_datime_warning()
8683 8684 8685 8686 8687 8688 8689 8690 8691 8692 8693 8694
      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.
*/
8695

8696
void 
8697
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
8698 8699 8700
                            const char *str, uint str_length, 
                            timestamp_type ts_type, int cuted_increment)
{
unknown's avatar
unknown committed
8701 8702 8703 8704
  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);
8705 8706 8707 8708 8709 8710
}


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

unknown's avatar
unknown committed
8711
  SYNOPSIS
8712 8713 8714 8715 8716 8717 8718 8719 8720 8721 8722 8723
    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.
*/
8724

8725
void 
8726
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
8727 8728 8729
                            longlong nr, timestamp_type ts_type,
                            int cuted_increment)
{
unknown's avatar
unknown committed
8730 8731
  if (table->in_use->really_abort_on_warning() ||
      set_warning(level, code, cuted_increment))
8732 8733 8734
  {
    char str_nr[22];
    char *str_end= longlong10_to_str(nr, str_nr, -10);
8735 8736
    make_truncated_value_warning(table->in_use, str_nr, 
                                 (uint) (str_end - str_nr), 
unknown's avatar
unknown committed
8737
                                 ts_type, field_name);
8738 8739 8740 8741 8742 8743 8744
  }
}


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

unknown's avatar
unknown committed
8745
  SYNOPSIS
8746 8747 8748 8749 8750 8751 8752 8753 8754 8755 8756
    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.
*/
8757

8758
void 
8759
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
8760 8761
                            double nr, timestamp_type ts_type)
{
unknown's avatar
unknown committed
8762 8763
  if (table->in_use->really_abort_on_warning() ||
      set_warning(level, code, 1))
8764 8765 8766 8767
  {
    /* 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
8768 8769
    make_truncated_value_warning(table->in_use, str_nr, str_len, ts_type,
                                 field_name);
unknown's avatar
unknown committed
8770
  }
8771
}