field.cc 288 KB
Newer Older
1
/* Copyright 2000-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3 4
   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
5
   the Free Software Foundation; version 2 of the License.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7 8 9 10
   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.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
11

bk@work.mysql.com's avatar
bk@work.mysql.com committed
12 13 14 15 16
   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 */


17 18 19 20 21 22
/**
  @file

  @brief
  This file implements classes defined in field.h
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
23

24
#ifdef USE_PRAGMA_IMPLEMENTATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
25 26 27 28 29
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include "sql_select.h"
30 31
#include "rpl_rli.h"                            // Pull in Relay_log_info
#include "slave.h"                              // Pull in rpl_master_has_bug()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
32 33 34 35 36 37
#include <m_ctype.h>
#include <errno.h>
#ifdef HAVE_FCONVERT
#include <floatingpoint.h>
#endif

peter@mysql.com's avatar
peter@mysql.com committed
38 39 40
// Maximum allowed exponent value for converting string to decimal
#define MAX_EXPONENT 1024

bk@work.mysql.com's avatar
bk@work.mysql.com committed
41
/*****************************************************************************
42
  Instansiate templates and static variables
bk@work.mysql.com's avatar
bk@work.mysql.com committed
43 44
*****************************************************************************/

45
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
46 47
template class List<Create_field>;
template class List_iterator<Create_field>;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
48 49 50 51 52
#endif

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

53
#define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE 320
54 55
#define LONGLONG_TO_STRING_CONVERSION_BUFFER_SIZE 128
#define DECIMAL_TO_STRING_CONVERSION_BUFFER_SIZE 128
56 57
#define BLOB_PACK_LENGTH_TO_MAX_LENGH(arg) \
((ulong) ((LL(1) << min(arg, 4) * 8) - LL(1)))
58

59 60
#define ASSERT_COLUMN_MARKED_FOR_READ DBUG_ASSERT(!table || (!table->read_set || bitmap_is_set(table->read_set, field_index)))
#define ASSERT_COLUMN_MARKED_FOR_WRITE DBUG_ASSERT(!table || (!table->write_set || bitmap_is_set(table->write_set, field_index)))
61

62 63 64 65 66 67 68
/*
  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.
*/
69 70 71
#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))
72 73 74 75 76 77 78
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);
}

79

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

921 922
/**
  Return type of which can carry value of both given types in UNION result.
923

924 925
  @param a  type for merging
  @param b  type for merging
926

927
  @return
928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943
    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
944
  DECIMAL_RESULT,           INT_RESULT,
945 946 947 948 949 950 951 952 953 954 955 956
  //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,
957 958 959
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
  STRING_RESULT,            STRING_RESULT,
  //MYSQL_TYPE_BIT          <16>-<245>
960
  STRING_RESULT,
961 962
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
  DECIMAL_RESULT,           STRING_RESULT,
963 964 965 966 967 968 969 970 971 972 973
  //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
};


974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998
/*
  Test if the given string contains important data:
  not spaces for character string,
  or any data for binary string.

  SYNOPSIS
    test_if_important_data()
    cs          Character set
    str         String to test
    strend      String end

  RETURN
    FALSE - If string does not have important data
    TRUE  - If string has some important data
*/

static bool
test_if_important_data(CHARSET_INFO *cs, const char *str, const char *strend)
{
  if (cs != &my_charset_bin)
    str+= cs->cset->scan(cs, str, strend, MY_SEQ_SPACES);
  return (str < strend);
}


999 1000
/**
  Detect Item_result by given field type of UNION merge result.
1001

1002
  @param field_type  given field type
1003

1004
  @return
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
    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)];
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1015
/*****************************************************************************
1016
  Static help functions
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1017 1018
*****************************************************************************/

1019

1020 1021
/**
  Check whether a field type can be partially indexed by a key.
1022 1023 1024 1025

  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().

1026
  @param type  field type
1027

1028
  @retval
1029
    TRUE  Type can have a prefixed key
1030
  @retval
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
    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:
gkodinov/kgeorge@magare.gmz's avatar
gkodinov/kgeorge@magare.gmz committed
1044
  case MYSQL_TYPE_GEOMETRY:
1045 1046 1047 1048 1049 1050 1051
    return TRUE;
  default:
    return FALSE;
  }
}


1052 1053
/**
  Numeric fields base class constructor.
1054
*/
1055
Field_num::Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
1056 1057 1058 1059
                     uchar null_bit_arg, utype unireg_check_arg,
                     const char *field_name_arg,
                     uint8 dec_arg, bool zero_arg, bool unsigned_arg)
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1060
         unireg_check_arg, field_name_arg),
1061 1062 1063 1064 1065 1066 1067 1068 1069
  dec(dec_arg),zerofill(zero_arg),unsigned_flag(unsigned_arg)
{
  if (zerofill)
    flags|=ZEROFILL_FLAG;
  if (unsigned_flag)
    flags|=UNSIGNED_FLAG;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1070 1071 1072 1073 1074
void Field_num::prepend_zeros(String *value)
{
  int diff;
  if ((diff= (int) (field_length - value->length())) > 0)
  {
1075 1076
    bmove_upp((uchar*) value->ptr()+field_length,
              (uchar*) value->ptr()+value->length(),
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1077
	      value->length());
1078
    bfill((uchar*) value->ptr(),diff,'0');
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1079 1080 1081 1082 1083
    value->length(field_length);
    (void) value->c_ptr_quick();		// Avoid warnings in purify
  }
}

1084
/**
1085
  Test if given number is a int.
1086

1087 1088
  @todo
    Make this multi-byte-character safe
1089

1090 1091 1092 1093 1094 1095
  @param str		String to test
  @param length        Length of 'str'
  @param int_end	Pointer to char after last used digit
  @param cs		Character set

  @note
1096
    This is called after one has called strntoull10rnd() function.
1097

1098 1099 1100
  @retval
    0	OK
  @retval
1101
    1	error: empty string or wrong integer.
1102
  @retval
1103
    2   error: garbage at the end of string.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1104 1105
*/

1106 1107
int Field_num::check_int(CHARSET_INFO *cs, const char *str, int length, 
                         const char *int_end, int error)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1108
{
1109 1110
  /* Test if we get an empty string or wrong integer */
  if (str == int_end || error == MY_ERRNO_EDOM)
1111 1112
  {
    char buff[128];
1113
    String tmp(buff, (uint32) sizeof(buff), system_charset_info);
1114 1115 1116 1117 1118 1119
    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);
1120
    return 1;
1121
  }
1122 1123 1124 1125 1126 1127 1128 1129
  /* Test if we have garbage at the end of the given string. */
  if (test_if_important_data(cs, int_end, str + length))
  {
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
    return 2;
  }
  return 0;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1130

1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161

/*
  Conver a string to an integer then check bounds.
  
  SYNOPSIS
    Field_num::get_int
    cs            Character set
    from          String to convert
    len           Length of the string
    rnd           OUT longlong value
    unsigned_max  max unsigned value
    signed_min    min signed value
    signed_max    max signed value

  DESCRIPTION
    The function calls strntoull10rnd() to get an integer value then
    check bounds and errors returned. In case of any error a warning
    is raised.

  RETURN
    0   ok
    1   error
*/

bool Field_num::get_int(CHARSET_INFO *cs, const char *from, uint len,
                        longlong *rnd, ulonglong unsigned_max, 
                        longlong signed_min, longlong signed_max)
{
  char *end;
  int error;
  
1162 1163
  *rnd= (longlong) cs->cset->strntoull10rnd(cs, from, len,
                                            unsigned_flag, &end,
1164 1165
                                            &error);
  if (unsigned_flag)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1166
  {
1167

1168
    if ((((ulonglong) *rnd > unsigned_max) && (*rnd= (longlong) unsigned_max)) ||
1169 1170 1171 1172
        error == MY_ERRNO_ERANGE)
    {
      goto out_of_range;
    }
1173
  }
1174
  else
1175
  {
1176
    if (*rnd < signed_min)
1177
    {
1178 1179 1180 1181 1182 1183 1184
      *rnd= signed_min;
      goto out_of_range;
    }
    else if (*rnd > signed_max)
    {
      *rnd= signed_max;
      goto out_of_range;
1185
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1186
  }
1187 1188
  if (table->in_use->count_cuted_fields &&
      check_int(cs, from, len, end, error))
1189
    return 1;
1190
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1191

1192 1193 1194 1195
out_of_range:
  set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  return 1;
}
1196

1197
/**
1198 1199 1200
  Process decimal library return codes and issue warnings for overflow and
  truncation.

1201
  @param op_result  decimal library return code (E_DEC_* see include/decimal.h)
1202

1203
  @retval
1204
    1  there was overflow
1205
  @retval
1206 1207 1208
    0  no error or some other errors except overflow
*/

1209
int Field::warn_if_overflow(int op_result)
1210 1211 1212 1213 1214 1215
{
  if (op_result == E_DEC_OVERFLOW)
  {
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
    return 1;
  }
1216 1217
  if (op_result == E_DEC_TRUNCATED)
  {
1218
    set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
1219 1220
    /* We return 0 here as this is not a critical issue */
  }
1221 1222 1223
  return 0;
}

1224

serg@serg.mylan's avatar
serg@serg.mylan committed
1225
#ifdef NOT_USED
1226
static bool test_if_real(const char *str,int length, CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1227
{
1228
  cs= system_charset_info; // QQ move test_if_real into CHARSET_INFO struct
1229 1230

  while (length && my_isspace(cs,*str))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1231 1232 1233 1234 1235 1236 1237 1238
  {						// Allow start space
    length--; str++;
  }
  if (!length)
    return 0;
  if (*str == '+' || *str == '-')
  {
    length--; str++;
1239
    if (!length || !(my_isdigit(cs,*str) || *str == '.'))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1240 1241
      return 0;
  }
1242
  while (length && my_isdigit(cs,*str))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1243 1244 1245 1246 1247 1248 1249 1250
  {
    length--; str++;
  }
  if (!length)
    return 1;
  if (*str == '.')
  {
    length--; str++;
1251
    while (length && my_isdigit(cs,*str))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1252 1253 1254 1255 1256 1257 1258 1259
    {
      length--; str++;
    }
  }
  if (!length)
    return 1;
  if (*str == 'E' || *str == 'e')
  {
1260
    if (length < 3 || (str[1] != '+' && str[1] != '-') || 
1261
        !my_isdigit(cs,str[2]))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1262 1263 1264
      return 0;
    length-=3;
    str+=3;
1265
    while (length && my_isdigit(cs,*str))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1266 1267 1268 1269
    {
      length--; str++;
    }
  }
1270
  for (; length ; length--, str++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1271
  {						// Allow end space
1272
    if (!my_isspace(cs,*str))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1273 1274 1275 1276
      return 0;
  }
  return 1;
}
serg@serg.mylan's avatar
serg@serg.mylan committed
1277
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1278

1279

1280
/**
monty@mysql.com's avatar
monty@mysql.com committed
1281 1282
  Interpret field value as an integer but return the result as a string.

1283
  This is used for printing bit_fields as numbers while debugging.
monty@mysql.com's avatar
monty@mysql.com committed
1284 1285
*/

1286
String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_val)
monty@mysql.com's avatar
monty@mysql.com committed
1287
{
1288
  ASSERT_COLUMN_MARKED_FOR_READ;
monty@mysql.com's avatar
monty@mysql.com committed
1289
  CHARSET_INFO *cs= &my_charset_bin;
1290
  uint length;
monty@mysql.com's avatar
monty@mysql.com committed
1291
  longlong value= val_int();
1292

1293
  if (val_buffer->alloc(MY_INT64_NUM_DECIMAL_DIGITS))
monty@mysql.com's avatar
monty@mysql.com committed
1294
    return 0;
monty@mysql.com's avatar
monty@mysql.com committed
1295
  length= (uint) (*cs->cset->longlong10_to_str)(cs, (char*) val_buffer->ptr(),
1296
                                                MY_INT64_NUM_DECIMAL_DIGITS,
1297
                                                unsigned_val ? 10 : -10,
monty@mysql.com's avatar
monty@mysql.com committed
1298
                                                value);
monty@mysql.com's avatar
monty@mysql.com committed
1299 1300 1301 1302 1303
  val_buffer->length(length);
  return val_buffer;
}


1304
/// This is used as a table name when the table structure is not set up
1305
Field::Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
1306
	     uchar null_bit_arg,
1307
	     utype unireg_check_arg, const char *field_name_arg)
1308
  :ptr(ptr_arg), null_ptr(null_ptr_arg),
1309
   table(0), orig_table(0), table_name(0),
1310
   field_name(field_name_arg),
1311 1312
   key_start(0), part_of_key(0), part_of_key_not_clustered(0),
   part_of_sortkey(0), unireg_check(unireg_check_arg),
1313 1314
   field_length(length_arg), null_bit(null_bit_arg), 
   is_created_from_null_item(FALSE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1315 1316
{
  flags=null_ptr ? 0: NOT_NULL_FLAG;
1317 1318
  comment.str= (char*) "";
  comment.length=0;
1319
  field_index= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1320 1321
}

1322

1323 1324 1325 1326 1327 1328 1329 1330 1331 1332
void Field::hash(ulong *nr, ulong *nr2)
{
  if (is_null())
  {
    *nr^= (*nr << 1) | 1;
  }
  else
  {
    uint len= pack_length();
    CHARSET_INFO *cs= charset();
1333
    cs->coll->hash_sort(cs, ptr, len, nr, nr2);
1334 1335 1336
  }
}

1337
size_t
1338 1339
Field::do_last_null_byte() const
{
1340
  DBUG_ASSERT(null_ptr == NULL || null_ptr >= table->record[0]);
1341
  if (null_ptr)
1342 1343
    return (size_t) (null_ptr - table->record[0]) + 1;
  return LAST_NULL_BYTE_UNDEF;
1344 1345 1346
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1347 1348 1349 1350 1351
void Field::copy_from_tmp(int row_offset)
{
  memcpy(ptr,ptr+row_offset,pack_length());
  if (null_ptr)
  {
1352
    *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) |
1353
			(null_ptr[row_offset] & (uchar) null_bit));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1354 1355 1356 1357
  }
}


1358
bool Field::send_binary(Protocol *protocol)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1359 1360
{
  char buff[MAX_FIELD_WIDTH];
1361
  String tmp(buff,sizeof(buff),charset());
1362
  val_str(&tmp);
1363
  return protocol->store(tmp.ptr(), tmp.length(), tmp.charset());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1364 1365 1366
}


1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
/**
   Check to see if field size is compatible with destination.

   This method is used in row-based replication to verify that the slave's
   field size is less than or equal to the master's field size. The 
   encoded field metadata (from the master or source) is decoded and compared
   to the size of this field (the slave or destination). 

   @param   field_metadata   Encoded size in field metadata

   @retval 0 if this field's size is < the source field's size
   @retval 1 if this field's size is >= the source field's size
*/
1380 1381
int Field::compatible_field_size(uint field_metadata,
                                 const Relay_log_info *rli_arg __attribute__((unused)))
1382 1383 1384 1385 1386 1387 1388
{
  uint const source_size= pack_length_from_metadata(field_metadata);
  uint const destination_size= row_pack_length();
  return (source_size <= destination_size);
}


1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
int Field::store(const char *to, uint length, CHARSET_INFO *cs,
                 enum_check_fields check_level)
{
  int res;
  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
  table->in_use->count_cuted_fields= check_level;
  res= store(to, length, cs);
  table->in_use->count_cuted_fields= old_check_level;
  return res;
}


1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447
/**
   Pack the field into a format suitable for storage and transfer.

   To implement packing functionality, only the virtual function
   should be overridden. The other functions are just convenience
   functions and hence should not be overridden.

   The value of <code>low_byte_first</code> is dependent on how the
   packed data is going to be used: for local use, e.g., temporary
   store on disk or in memory, use the native format since that is
   faster. For data that is going to be transfered to other machines
   (e.g., when writing data to the binary log), data should always be
   stored in little-endian format.

   @note The default method for packing fields just copy the raw bytes
   of the record into the destination, but never more than
   <code>max_length</code> characters.

   @param to
   Pointer to memory area where representation of field should be put.

   @param from
   Pointer to memory area where record representation of field is
   stored.

   @param max_length
   Maximum length of the field, as given in the column definition. For
   example, for <code>CHAR(1000)</code>, the <code>max_length</code>
   is 1000. This information is sometimes needed to decide how to pack
   the data.

   @param low_byte_first
   @c TRUE if integers should be stored little-endian, @c FALSE if
   native format should be used. Note that for little-endian machines,
   the value of this flag is a moot point since the native format is
   little-endian.
*/
uchar *
Field::pack(uchar *to, const uchar *from, uint max_length,
            bool low_byte_first __attribute__((unused)))
{
  uint32 length= pack_length();
  set_if_smaller(length, max_length);
  memcpy(to, from, length);
  return to+length;
}

1448 1449 1450
/**
   Unpack a field from row data.

1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
   This method is used to unpack a field from a master whose size of
   the field is less than that of the slave.

   The <code>param_data</code> parameter is a two-byte integer (stored
   in the least significant 16 bits of the unsigned integer) usually
   consisting of two parts: the real type in the most significant byte
   and a original pack length in the least significant byte.

   The exact layout of the <code>param_data</code> field is given by
   the <code>Table_map_log_event::save_field_metadata()</code>.

   This is the default method for unpacking a field. It just copies
   the memory block in byte order (of original pack length bytes or
   length of field, whichever is smaller).

1466 1467
   @param   to         Destination of the data
   @param   from       Source of the data
1468 1469 1470 1471 1472 1473 1474
   @param   param_data Real type and original pack length of the field
                       data

   @param low_byte_first
   If this flag is @c true, all composite entities (e.g., lengths)
   should be unpacked in little-endian format; otherwise, the entities
   are unpacked in native order.
1475 1476 1477

   @return  New pointer into memory based on from + length of the data
*/
1478 1479 1480
const uchar *
Field::unpack(uchar* to, const uchar *from, uint param_data,
              bool low_byte_first __attribute__((unused)))
1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492
{
  uint length=pack_length();
  int from_type= 0;
  /*
    If from length is > 255, it has encoded data in the upper bits. Need
    to mask it out.
  */
  if (param_data > 255)
  {
    from_type= (param_data & 0xff00) >> 8U;  // real_type.
    param_data= param_data & 0x00ff;        // length.
  }
1493 1494 1495 1496 1497 1498 1499 1500 1501

  if ((param_data == 0) ||
      (length == param_data) ||
      (from_type != real_type()))
  {
    memcpy(to, from, length);
    return from+length;
  }

1502 1503
  uint len= (param_data && (param_data < length)) ?
            param_data : length;
1504

1505 1506 1507 1508 1509
  memcpy(to, from, param_data > length ? length : len);
  return from+len;
}


1510 1511 1512 1513 1514 1515 1516 1517
my_decimal *Field::val_decimal(my_decimal *decimal)
{
  /* This never have to be called */
  DBUG_ASSERT(0);
  return 0;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1518 1519
void Field_num::add_zerofill_and_unsigned(String &res) const
{
1520
  if (unsigned_flag)
1521
    res.append(STRING_WITH_LEN(" unsigned"));
1522
  if (zerofill)
1523
    res.append(STRING_WITH_LEN(" zerofill"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1524 1525
}

1526

1527
void Field::make_field(Send_field *field)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1528
{
1529
  if (orig_table && orig_table->s->db.str && *orig_table->s->db.str)
1530
  {
1531 1532
    field->db_name= orig_table->s->db.str;
    field->org_table_name= orig_table->s->table_name.str;
1533 1534
  }
  else
1535
    field->org_table_name= field->db_name= "";
1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
  if (orig_table)
  {
    field->table_name= orig_table->alias;
    field->org_col_name= field_name;
  }
  else
  {
    field->table_name= "";
    field->org_col_name= "";
  }
  field->col_name= field_name;
1547
  field->charsetnr= charset()->number;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1548 1549 1550
  field->length=field_length;
  field->type=type();
  field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
1551
  field->decimals= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1552 1553 1554
}


1555
/**
1556
  Conversion from decimal to longlong with checking overflow and
1557
  setting correct value (min/max) in case of overflow.
1558

1559 1560 1561
  @param val             value which have to be converted
  @param unsigned_flag   type of integer in which we convert val
  @param err             variable to pass error code
1562

1563
  @return
1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
    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;
    }
1578
    else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
1579 1580 1581 1582 1583 1584 1585
                                           ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
                                           val, TRUE, &i)))
    {
      i= ~(longlong) 0;
      *err= 1;
    }
  }
1586
  else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
                                         ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
                                         val, FALSE, &i)))
  {
    i= (val->sign() ? LONGLONG_MIN : LONGLONG_MAX);
    *err= 1;
  }
  return i;
}


1597
/**
1598 1599
  Storing decimal in integer fields.

1600
  @param val       value for storing
1601

1602
  @note
1603 1604
    This method is used by all integer fields, real/decimal redefine it

1605
  @retval
1606
    0     OK
1607 1608
  @retval
    !=0  error
1609 1610 1611 1612
*/

int Field_num::store_decimal(const my_decimal *val)
{
1613
  ASSERT_COLUMN_MARKED_FOR_WRITE;
1614 1615
  int err= 0;
  longlong i= convert_decimal2longlong(val, unsigned_flag, &err);
1616
  return test(err | store(i, unsigned_flag));
1617 1618 1619
}


1620 1621
/**
  Return decimal value of integer field.
1622

1623
  @param decimal_value     buffer for storing decimal value
1624

1625 1626
  @note
    This method is used by all integer fields, real/decimal redefine it.
1627 1628 1629
    All longlong values fit in our decimal buffer which cal store 8*9=72
    digits of integer number

1630
  @return
1631 1632 1633 1634 1635
    pointer to decimal buffer with value of field
*/

my_decimal* Field_num::val_decimal(my_decimal *decimal_value)
{
1636
  ASSERT_COLUMN_MARKED_FOR_READ;
1637 1638
  DBUG_ASSERT(result_type() == INT_RESULT);
  longlong nr= val_int();
1639
  int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
1640 1641 1642 1643
  return decimal_value;
}


1644
Field_str::Field_str(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
1645
                     uchar null_bit_arg, utype unireg_check_arg,
1646
                     const char *field_name_arg, CHARSET_INFO *charset_arg)
1647
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1648
         unireg_check_arg, field_name_arg)
1649
{
1650 1651
  field_charset= charset_arg;
  if (charset_arg->state & MY_CS_BINSORT)
1652
    flags|=BINARY_FLAG;
1653
  field_derivation= DERIVATION_IMPLICIT;
1654 1655 1656
}


1657
void Field_num::make_field(Send_field *field)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1658
{
1659 1660
  Field::make_field(field);
  field->decimals= dec;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1661 1662
}

1663 1664
/**
  Decimal representation of Field_str.
1665

1666
  @param d         value for storing
1667

1668 1669 1670 1671 1672
  @note
    Field_str is the base class for fields like Field_enum,
    Field_date and some 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.
1673

1674 1675 1676 1677
  @todo
    use decimal2string?

  @retval
1678
    0     OK
1679 1680
  @retval
    !=0  error
1681 1682 1683 1684
*/

int Field_str::store_decimal(const my_decimal *d)
{
1685
  ASSERT_COLUMN_MARKED_FOR_WRITE;
1686 1687
  double val;
  /* TODO: use decimal2string? */
1688
  int err= warn_if_overflow(my_decimal2double(E_DEC_FATAL_ERROR &
1689 1690 1691 1692 1693 1694 1695
                                            ~E_DEC_OVERFLOW, d, &val));
  return err | store(val);
}


my_decimal *Field_str::val_decimal(my_decimal *decimal_value)
{
1696
  ASSERT_COLUMN_MARKED_FOR_READ;
1697
  longlong nr= val_int();
1698
  int2my_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value);
1699 1700 1701
  return decimal_value;
}

1702

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1703 1704
uint Field::fill_cache_field(CACHE_FIELD *copy)
{
1705
  uint store_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1706 1707 1708 1709 1710 1711 1712
  copy->str=ptr;
  copy->length=pack_length();
  copy->blob_field=0;
  if (flags & BLOB_FLAG)
  {
    copy->blob_field=(Field_blob*) this;
    copy->strip=0;
1713
    copy->length-= table->s->blob_ptr_size;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1714 1715
    return copy->length;
  }
1716 1717 1718
  else if (!zero_pack() &&
           (type() == MYSQL_TYPE_STRING && copy->length >= 4 &&
            copy->length < 256))
1719
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1720
    copy->strip=1;				/* Remove end space */
1721 1722
    store_length= 2;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1723
  else
1724
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1725
    copy->strip=0;
1726 1727 1728
    store_length= 0;
  }
  return copy->length+ store_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1729 1730
}

1731

1732
bool Field::get_date(MYSQL_TIME *ltime,uint fuzzydate)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1733 1734
{
  char buff[40];
1735 1736
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  if (!(res=val_str(&tmp)) ||
1737 1738
      str_to_datetime_with_warn(res->ptr(), res->length(),
                                ltime, fuzzydate) <= MYSQL_TIMESTAMP_ERROR)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1739 1740 1741 1742
    return 1;
  return 0;
}

1743
bool Field::get_time(MYSQL_TIME *ltime)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1744 1745
{
  char buff[40];
1746 1747
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  if (!(res=val_str(&tmp)) ||
1748
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1749 1750 1751 1752
    return 1;
  return 0;
}

1753 1754
/**
  This is called when storing a date in a string.
1755

1756 1757
  @note
    Needs to be changed if/when we want to support different time formats.
1758
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1759

1760
int Field::store_time(MYSQL_TIME *ltime, timestamp_type type_arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1761
{
1762
  ASSERT_COLUMN_MARKED_FOR_WRITE;
1763 1764
  char buff[MAX_DATE_STRING_REP_LENGTH];
  uint length= (uint) my_TIME_to_str(ltime, buff);
1765
  return store(buff, length, &my_charset_bin);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1766 1767 1768
}


1769
bool Field::optimize_range(uint idx, uint part)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1770
{
1771
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1772 1773
}

1774

1775 1776
Field *Field::new_field(MEM_ROOT *root, struct st_table *new_table,
                        bool keep_type __attribute__((unused)))
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
{
  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);
1788
  tmp->unireg_check= Field::NONE;
1789 1790 1791 1792 1793 1794
  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG |
                ZEROFILL_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
  tmp->reset_fields();
  return tmp;
}

monty@mysql.com's avatar
monty@mysql.com committed
1795 1796

Field *Field::new_key_field(MEM_ROOT *root, struct st_table *new_table,
1797
                            uchar *new_ptr, uchar *new_null_ptr,
monty@mysql.com's avatar
monty@mysql.com committed
1798 1799 1800
                            uint new_null_bit)
{
  Field *tmp;
1801
  if ((tmp= new_field(root, new_table, table == new_table)))
monty@mysql.com's avatar
monty@mysql.com committed
1802 1803 1804 1805 1806 1807 1808 1809
  {
    tmp->ptr=      new_ptr;
    tmp->null_ptr= new_null_ptr;
    tmp->null_bit= new_null_bit;
  }
  return tmp;
}

1810

1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
/* This is used to generate a field in TABLE from TABLE_SHARE */

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


1826
/****************************************************************************
1827
  Field_null, a field that always return NULL
1828 1829 1830 1831
****************************************************************************/

void Field_null::sql_type(String &res) const
{
1832
  res.set_ascii(STRING_WITH_LEN("null"));
1833 1834 1835
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1836
/****************************************************************************
1837 1838
  Functions for the Field_decimal class
  This is an number stored as a pre-space (or pre-zero) string
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1839 1840
****************************************************************************/

1841
int
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1842 1843
Field_decimal::reset(void)
{
1844
  Field_decimal::store(STRING_WITH_LEN("0"),&my_charset_bin);
1845
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1846 1847 1848 1849 1850
}

void Field_decimal::overflow(bool negative)
{
  uint len=field_length;
1851
  uchar *to=ptr, filler= '9';
1852

1853
  set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1854
  if (negative)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1855
  {
1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878
    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
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1879
  }
1880
  bfill(to, len, filler);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1881 1882 1883 1884 1885 1886
  if (dec)
    ptr[field_length-dec-1]='.';
  return;
}


1887
int Field_decimal::store(const char *from_arg, uint len, CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1888
{
1889
  ASSERT_COLUMN_MARKED_FOR_WRITE;
1890
  char buff[STRING_BUFFER_USUAL_SIZE];
1891
  String tmp(buff,sizeof(buff), &my_charset_bin);
1892
  const uchar *from= (uchar*) from_arg;
1893

1894
  /* Convert character set if the old one is multi uchar */
1895 1896
  if (cs->mbmaxlen > 1)
  { 
1897
    uint dummy_errors;
1898 1899
    tmp.copy((char*) from, len, cs, &my_charset_bin, &dummy_errors);
    from= (uchar*) tmp.ptr();
1900 1901
    len=  tmp.length();
  }
1902

1903
  const uchar *end= from+len;
1904
  /* The pointer where the field value starts (i.e., "where to write") */
1905
  uchar *to= ptr;
1906 1907 1908 1909 1910
  uint tmp_dec, tmp_uint;
  /*
    The sign of the number : will be 0 (means positive but sign not
    specified), '+' or '-'
  */
1911
  uchar sign_char=0;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1912
  /* The pointers where prezeros start and stop */
1913
  const uchar *pre_zeros_from, *pre_zeros_end;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1914
  /* The pointers where digits at the left of '.' start and stop */
1915
  const uchar *int_digits_from, *int_digits_end;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1916
  /* The pointers where digits at the right of '.' start and stop */
1917
  const uchar *frac_digits_from, *frac_digits_end;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1918
  /* The sign of the exponent : will be 0 (means no exponent), '+' or '-' */
1919
  char expo_sign_char=0;
peter@mysql.com's avatar
peter@mysql.com committed
1920
  uint exponent=0;                                // value of the exponent
1921 1922 1923 1924
  /*
    Pointers used when digits move from the left of the '.' to the
    right of the '.' (explained below)
  */
Staale Smedseng's avatar
Staale Smedseng committed
1925
  const uchar *UNINIT_VAR(int_digits_tail_from);
1926
  /* Number of 0 that need to be added at the left of the '.' (1E3: 3 zeros) */
1927
  uint UNINIT_VAR(int_digits_added_zeros);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1928 1929 1930 1931
  /*
    Pointer used when digits move from the right of the '.' to the left
    of the '.'
  */
Staale Smedseng's avatar
Staale Smedseng committed
1932
  const uchar *UNINIT_VAR(frac_digits_head_end);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1933
  /* Number of 0 that need to be added at the right of the '.' (for 1E-3) */
1934
  uint UNINIT_VAR(frac_digits_added_zeros);
1935
  uchar *pos,*tmp_left_pos,*tmp_right_pos;
1936
  /* Pointers that are used as limits (begin and end of the field buffer) */
1937 1938
  uchar *left_wall,*right_wall;
  uchar tmp_char;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1939
  /*
1940
    To remember if table->in_use->cuted_fields has already been incremented,
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1941 1942
    to do that only once
  */
1943 1944 1945 1946
  bool is_cuted_fields_incr=0;

  /*
    There are three steps in this function :
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1947 1948
    - parse the input string
    - modify the position of digits around the decimal dot '.' 
1949
      according to the exponent value (if specified)
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1950
    - write the formatted number
1951 1952 1953 1954 1955
  */

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

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1956
  /* skip pre-space */
1957
  while (from != end && my_isspace(&my_charset_bin,*from))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1958
    from++;
1959
  if (from == end)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1960
  {
1961
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
1962
    is_cuted_fields_incr=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1963
  }
1964
  else if (*from == '+' || *from == '-')	// Found some sign ?
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1965
  {
1966
    sign_char= *from++;
1967
    /*
1968 1969 1970
      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
1971 1972 1973 1974
    */ 
    if (unsigned_flag)  
    { 
      if (sign_char=='-')
1975
      {
1976
        Field_decimal::overflow(1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1977
        return 1;
1978
      }
1979
      /* 
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
1980 1981
	 Defining this will not store "+" for unsigned decimal type even if
	 it is passed in numeric string. This will make some tests to fail
1982 1983
      */	 
#ifdef DONT_ALLOW_UNSIGNED_PLUS      
1984 1985
      else 
        sign_char=0;
1986
#endif 	
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1987
    }
1988
  }
1989

1990 1991 1992 1993
  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 '.'*/
1994
  for (; from != end && my_isdigit(&my_charset_bin, *from) ; from++) ;
1995 1996 1997 1998 1999
  int_digits_end=from;
  if (from!=end && *from == '.')		// Some '.' ?
    from++;
  frac_digits_from= from;
  /* Read digits at the right of '.' */
2000
  for (;from!=end && my_isdigit(&my_charset_bin, *from); from++) ;
2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
  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= '+';
    /*
2011 2012 2013 2014
      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).
2015
    */
2016
    for (;from!=end && my_isdigit(&my_charset_bin, *from); from++)
2017
    {
2018
      exponent=10*exponent+(*from-'0');
peter@mysql.com's avatar
peter@mysql.com committed
2019
      if (exponent>MAX_EXPONENT)
2020 2021
        break;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2022
  }
2023
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2024
  /*
2025 2026
    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.
2027
    Even if this flag is not set, it's OK to increment warnings, if
2028
    it makes the code easer to read.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2029
  */
2030

2031
  if (table->in_use->count_cuted_fields)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2032
  {
2033
    // Skip end spaces
2034
    for (;from != end && my_isspace(&my_charset_bin, *from); from++) ;
2035
    if (from != end)                     // If still something left, warn
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2036
    {
2037
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
2038
      is_cuted_fields_incr=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2039
    }
2040 2041 2042 2043 2044 2045
  }
  
  /*
    Now "move" digits around the decimal dot according to the exponent value,
    and add necessary zeros.
    Examples :
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2046 2047 2048
    - 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'
2049
    - 1234.5E-3 : '234' moves at the right of '.'
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2050 2051
    These moves are implemented with pointers which point at the begin
    and end of each moved segment. Examples :
2052
    - 1234.5E-3 : before the code below is executed, the int_digits part is
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2053 2054 2055
    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'.
2056
    - 1234.5E3 : before the code below is executed, the int_digits part is
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2057 2058 2059 2060
    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).
2061 2062
  */
  
2063
  /* 
peter@mysql.com's avatar
peter@mysql.com committed
2064
     Below tmp_uint cannot overflow with small enough MAX_EXPONENT setting,
2065
     as int_digits_added_zeros<=exponent<4G and 
2066 2067
     (int_digits_end-int_digits_from)<=max_allowed_packet<=2G and
     (frac_digits_from-int_digits_tail_from)<=max_allowed_packet<=2G
2068 2069
  */

2070 2071 2072 2073 2074 2075 2076 2077
  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;
peter@mysql.com's avatar
peter@mysql.com committed
2078
    tmp_uint=tmp_dec+(uint)(int_digits_end-int_digits_from);     
2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
  }
  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;
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2104
    }
2105
    tmp_uint= (uint) (tmp_dec+(int_digits_end-int_digits_from)+
2106 2107
               (uint)(frac_digits_from-int_digits_tail_from)+
               int_digits_added_zeros);
2108 2109 2110 2111 2112 2113 2114 2115 2116 2117
  }
  
  /*
    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
  */

2118
  if (field_length < tmp_uint + (int) (sign_char == '-')) 
2119
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2120
    // too big number, change to max or min number
2121
    Field_decimal::overflow(sign_char == '-');
2122
    return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2123
  }
2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
 
  /*
    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';  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2141
  }
2142 2143 2144 2145 2146 2147
  /*
    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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2148 2149

  /*
2150 2151
    Step back to the position of the leftmost digit of the int_% parts,
    to write sign and fill with zeros or blanks or prezeros.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2152
  */
2153 2154 2155 2156
  pos=tmp_left_pos-1;
  if (zerofill)
  {
    left_wall=to-1;
2157
    while (pos > left_wall)			// Fill with zeros
2158 2159 2160 2161
      *pos--='0';
  }
  else
  {
2162
    left_wall=to+(sign_char != 0)-1;
2163 2164
    if (!expo_sign_char)	// If exponent was specified, ignore prezeros
    {
2165
      for (;pos > left_wall && pre_zeros_from !=pre_zeros_end;
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180
	   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
  }
  
2181 2182
  /*
    Write digits of the frac_% parts ;
2183
    Depending on table->in_use->count_cutted_fields, we may also want
2184 2185 2186 2187 2188
    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)
  */
2189
      
2190 2191 2192
  pos=to+(uint)(field_length-tmp_dec);	// Calculate post to '.'
  right_wall=to+field_length;
  if (pos != right_wall) 
2193 2194
    *pos++='.';

2195 2196 2197
  if (expo_sign_char == '-')
  {
    while (frac_digits_added_zeros-- > 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2198
    {
2199
      if (pos == right_wall) 
2200
      {
2201
        if (table->in_use->count_cuted_fields && !is_cuted_fields_incr) 
2202
          break; // Go on below to see if we lose non zero digits
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2203
        return 0;
2204
      }
2205 2206 2207 2208 2209 2210
      *pos++='0';
    }
    while (int_digits_end != frac_digits_head_end)
    {
      tmp_char= *int_digits_end++;
      if (pos == right_wall)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2211
      {
2212 2213 2214
        if (tmp_char != '0')			// Losing a non zero digit ?
        {
          if (!is_cuted_fields_incr)
2215
            set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
2216
                        WARN_DATA_TRUNCATED, 1);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2217
          return 0;
2218 2219
        }
        continue;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2220
      }
2221
      *pos++= tmp_char;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2222
    }
2223
  }
2224

2225 2226 2227 2228
  for (;frac_digits_from!=frac_digits_end;) 
  {
    tmp_char= *frac_digits_from++;
    if (pos == right_wall)
2229
    {
2230
      if (tmp_char != '0')			// Losing a non zero digit ?
2231
      {
2232
        if (!is_cuted_fields_incr)
2233 2234 2235 2236 2237
        {
          /*
            This is a note, not a warning, as we don't want to abort
            when we cut decimals in strict mode
          */
2238
	  set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
2239
        }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2240
        return 0;
2241
      }
2242
      continue;
2243
    }
2244
    *pos++= tmp_char;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2245
  }
2246 2247 2248
      
  while (pos != right_wall)
   *pos++='0';			// Fill with zeros at right of '.'
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2249
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2250 2251 2252
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2253
int Field_decimal::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2254
{
2255
  ASSERT_COLUMN_MARKED_FOR_WRITE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2256 2257 2258
  if (unsigned_flag && nr < 0)
  {
    overflow(1);
2259
    return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2260
  }
2261
  
2262
  if (!isfinite(nr)) // Handle infinity as special case
2263 2264
  {
    overflow(nr < 0.0);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2265
    return 1;
2266
  }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2267

2268 2269 2270
  reg4 uint i;
  size_t length;
  uchar fyllchar,*to;
2271
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2272 2273

  fyllchar = zerofill ? (char) '0' : (char) ' ';
serg@serg.mylan's avatar
serg@serg.mylan committed
2274
#ifdef HAVE_SNPRINTF
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
2275 2276
  buff[sizeof(buff)-1]=0;			// Safety
  snprintf(buff,sizeof(buff)-1, "%.*f",(int) dec,nr);
2277
  length= strlen(buff);
2278
#else
2279
  length= my_sprintf(buff,(buff,"%.*f",dec,nr));
2280
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2281 2282 2283 2284

  if (length > field_length)
  {
    overflow(nr < 0.0);
2285
    return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2286 2287 2288 2289 2290 2291 2292
  }
  else
  {
    to=ptr;
    for (i=field_length-length ; i-- > 0 ;)
      *to++ = fyllchar;
    memcpy(to,buff,length);
2293
    return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2294 2295 2296 2297
  }
}


2298
int Field_decimal::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2299
{
2300
  ASSERT_COLUMN_MARKED_FOR_WRITE;
2301 2302
  char buff[22];
  uint length, int_part;
2303 2304
  char fyllchar;
  uchar *to;
2305 2306

  if (nr < 0 && unsigned_flag && !unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2307 2308
  {
    overflow(1);
2309
    return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2310
  }
2311 2312
  length= (uint) (longlong10_to_str(nr,buff,unsigned_val ? 10 : -10) - buff);
  int_part= field_length- (dec  ? dec+1 : 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2313 2314 2315

  if (length > int_part)
  {
2316
    overflow(!unsigned_val && nr < 0L);		/* purecov: inspected */
2317
    return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2318
  }
2319 2320 2321 2322 2323 2324 2325

  fyllchar = zerofill ? (char) '0' : (char) ' ';
  to= ptr;
  for (uint i=int_part-length ; i-- > 0 ;)
    *to++ = fyllchar;
  memcpy(to,buff,length);
  if (dec)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2326
  {
2327 2328
    to[length]='.';
    bfill(to+length+1,dec,'0');
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2329
  }
2330
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2331 2332 2333 2334 2335
}


double Field_decimal::val_real(void)
{
2336
  ASSERT_COLUMN_MARKED_FOR_READ;
2337
  int not_used;
2338
  char *end_not_used;
2339
  return my_strntod(&my_charset_bin, (char*) ptr, field_length, &end_not_used,
2340
                    &not_used);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2341 2342 2343 2344
}

longlong Field_decimal::val_int(void)
{
2345
  ASSERT_COLUMN_MARKED_FOR_READ;
2346
  int not_used;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2347
  if (unsigned_flag)
2348
    return my_strntoull(&my_charset_bin, (char*) ptr, field_length, 10, NULL,
2349
			&not_used);
2350 2351
  return my_strntoll(&my_charset_bin, (char*) ptr, field_length, 10, NULL,
                     &not_used);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2352 2353
}

2354

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2355 2356 2357
String *Field_decimal::val_str(String *val_buffer __attribute__((unused)),
			       String *val_ptr)
{
2358
  ASSERT_COLUMN_MARKED_FOR_READ;
2359 2360 2361
  uchar *str;
  size_t tmp_length;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2362
  for (str=ptr ; *str == ' ' ; str++) ;
2363
  val_ptr->set_charset(&my_charset_bin);
2364
  tmp_length= (size_t) (str-ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2365 2366 2367
  if (field_length < tmp_length)		// Error in data
    val_ptr->length(0);
  else
2368
    val_ptr->set_ascii((const char*) str, field_length-tmp_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2369 2370 2371
  return val_ptr;
}

2372 2373 2374
/**
  Should be able to handle at least the following fixed decimal formats:
  5.00 , -1.0,  05,  -05, +5 with optional pre/end space
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2375 2376
*/

2377
int Field_decimal::cmp(const uchar *a_ptr,const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2378
{
2379
  const uchar *end;
2380
  int swap=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2381 2382 2383 2384
  /* First remove prefixes '0', ' ', and '-' */
  for (end=a_ptr+field_length;
       a_ptr != end &&
	 (*a_ptr == *b_ptr ||
2385
	  ((my_isspace(&my_charset_bin,*a_ptr)  || *a_ptr == '+' || 
2386
            *a_ptr == '0') &&
2387
	   (my_isspace(&my_charset_bin,*b_ptr) || *b_ptr == '+' || 
2388
            *b_ptr == '0')));
2389 2390 2391 2392 2393
       a_ptr++,b_ptr++)
  {
    if (*a_ptr == '-')				// If both numbers are negative
      swap= -1 ^ 1;				// Swap result      
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2394 2395 2396
  if (a_ptr == end)
    return 0;
  if (*a_ptr == '-')
2397
    return -1;
2398
  if (*b_ptr == '-')
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409
    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;
}


2410
void Field_decimal::sort_string(uchar *to,uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2411
{
2412
  uchar *str,*end;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2413 2414
  for (str=ptr,end=ptr+length;
       str != end &&
2415
	 ((my_isspace(&my_charset_bin,*str) || *str == '+' ||
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2416
	   *str == '0')) ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2417 2418 2419 2420 2421 2422 2423 2424 2425 2426
       str++)
    *to++=' ';
  if (str == end)
    return;					/* purecov: inspected */

  if (*str == '-')
  {
    *to++=1;					// Smaller than any number
    str++;
    while (str != end)
2427
      if (my_isdigit(&my_charset_bin,*str))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2428 2429 2430 2431 2432 2433 2434
	*to++= (char) ('9' - *str++);
      else
	*to++= *str++;
  }
  else memcpy(to,str,(uint) (end-str));
}

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2435

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2436 2437
void Field_decimal::sql_type(String &res) const
{
2438
  CHARSET_INFO *cs=res.charset();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2439 2440 2441 2442 2443
  uint tmp=field_length;
  if (!unsigned_flag)
    tmp--;
  if (dec)
    tmp--;
2444
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2445
			  "decimal(%d,%d)",tmp,dec));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2446 2447 2448 2449
  add_zerofill_and_unsigned(res);
}


2450 2451 2452 2453
/****************************************************************************
** Field_new_decimal
****************************************************************************/

2454
Field_new_decimal::Field_new_decimal(uchar *ptr_arg,
2455 2456 2457 2458 2459 2460
                                     uint32 len_arg, uchar *null_ptr_arg,
                                     uchar null_bit_arg,
                                     enum utype unireg_check_arg,
                                     const char *field_name_arg,
                                     uint8 dec_arg,bool zero_arg,
                                     bool unsigned_arg)
2461 2462
  :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
             unireg_check_arg, field_name_arg, dec_arg, zero_arg, unsigned_arg)
2463
{
2464
  precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
2465
  set_if_smaller(precision, DECIMAL_MAX_PRECISION);
2466 2467 2468
  DBUG_ASSERT((precision <= DECIMAL_MAX_PRECISION) &&
              (dec <= DECIMAL_MAX_SCALE));
  bin_size= my_decimal_get_binary_size(precision, dec);
2469 2470 2471 2472
}


Field_new_decimal::Field_new_decimal(uint32 len_arg,
2473
                                     bool maybe_null_arg,
2474
                                     const char *name,
2475 2476
                                     uint8 dec_arg,
                                     bool unsigned_arg)
2477
  :Field_num((uchar*) 0, len_arg,
2478
             maybe_null_arg ? (uchar*) "": 0, 0,
2479
             NONE, name, dec_arg, 0, unsigned_arg)
2480
{
2481
  precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
2482
  set_if_smaller(precision, DECIMAL_MAX_PRECISION);
2483 2484 2485
  DBUG_ASSERT((precision <= DECIMAL_MAX_PRECISION) &&
              (dec <= DECIMAL_MAX_SCALE));
  bin_size= my_decimal_get_binary_size(precision, dec);
2486 2487 2488
}


2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 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
Field *Field_new_decimal::create_from_item (Item *item)
{
  uint8 dec= item->decimals;
  uint8 intg= item->decimal_precision() - dec;
  uint32 len= item->max_length;

  DBUG_ASSERT (item->result_type() == DECIMAL_RESULT);

  /*
    Trying to put too many digits overall in a DECIMAL(prec,dec)
    will always throw a warning. We must limit dec to
    DECIMAL_MAX_SCALE however to prevent an assert() later.
  */

  if (dec > 0)
  {
    signed int overflow;

    dec= min(dec, DECIMAL_MAX_SCALE);

    /*
      If the value still overflows the field with the corrected dec,
      we'll throw out decimals rather than integers. This is still
      bad and of course throws a truncation warning.
      +1: for decimal point
      */

    const int required_length=
      my_decimal_precision_to_length(intg + dec, dec,
                                     item->unsigned_flag);

    overflow= required_length - len;

    if (overflow > 0)
      dec= max(0, dec - overflow);            // too long, discard fract
    else
      /* Corrected value fits. */
      len= required_length;
  }
  return new Field_new_decimal(len, item->maybe_null, item->name,
                               dec, item->unsigned_flag);
}


holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
2533
int Field_new_decimal::reset(void)
2534 2535
{
  store_value(&decimal_zero);
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
2536
  return 0;
2537 2538 2539
}


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

2543 2544
  @param decimal_value     buffer for value
  @param sign              sign of value which caused overflow
2545 2546 2547 2548 2549 2550
*/

void Field_new_decimal::set_value_on_overflow(my_decimal *decimal_value,
                                              bool sign)
{
  DBUG_ENTER("Field_new_decimal::set_value_on_overflow");
2551
  max_my_decimal(decimal_value, precision, decimals());
2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562
  if (sign)
  {
    if (unsigned_flag)
      my_decimal_set_zero(decimal_value);
    else
      decimal_value->sign(TRUE);
  }
  DBUG_VOID_RETURN;
}


2563 2564
/**
  Store decimal value in the binary buffer.
2565

2566 2567 2568
  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.
2569

2570
  @param decimal_value   my_decimal
2571

2572 2573 2574 2575
  @retval
    0 ok
  @retval
    1 error
2576 2577 2578 2579
*/

bool Field_new_decimal::store_value(const my_decimal *decimal_value)
{
2580
  ASSERT_COLUMN_MARKED_FOR_WRITE;
2581 2582
  int error= 0;
  DBUG_ENTER("Field_new_decimal::store_value");
2583 2584 2585 2586 2587 2588
#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
2589 2590 2591 2592 2593 2594

  /* 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);
2595
    error= 1;
2596 2597 2598 2599 2600
    decimal_value= &decimal_zero;
  }
#ifndef DBUG_OFF
  {
    char dbug_buff[DECIMAL_MAX_STR_LENGTH+1];
2601
    DBUG_PRINT("info", ("saving with precision %d  scale: %d  value %s",
2602 2603
                        (int)precision, (int)dec,
                        dbug_decimal_as_string(dbug_buff, decimal_value)));
2604
  }
2605
#endif
2606

2607 2608
  if (warn_if_overflow(my_decimal2binary(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
                                         decimal_value, ptr, precision, dec)))
2609 2610 2611
  {
    my_decimal buff;
    DBUG_PRINT("info", ("overflow"));
2612 2613
    set_value_on_overflow(&buff, decimal_value->sign());
    my_decimal2binary(E_DEC_FATAL_ERROR, &buff, ptr, precision, dec);
2614
    error= 1;
2615
  }
2616
  DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (uchar *) ptr,
2617
                                          bin_size););
2618
  DBUG_RETURN(error);
2619 2620 2621 2622
}


int Field_new_decimal::store(const char *from, uint length,
2623
                             CHARSET_INFO *charset_arg)
2624
{
2625
  ASSERT_COLUMN_MARKED_FOR_WRITE;
2626 2627
  int err;
  my_decimal decimal_value;
2628 2629
  DBUG_ENTER("Field_new_decimal::store(char*)");

2630
  if ((err= str2my_decimal(E_DEC_FATAL_ERROR &
2631 2632 2633
                           ~(E_DEC_OVERFLOW | E_DEC_BAD_NUM),
                           from, length, charset_arg,
                           &decimal_value)) &&
2634 2635
      table->in_use->abort_on_warning)
  {
2636 2637 2638 2639
    /* Because "from" is not NUL-terminated and we use %s in the ER() */
    String from_as_str;
    from_as_str.copy(from, length, &my_charset_bin);

2640 2641 2642
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_ERROR,
                        ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
                        ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
2643
                        "decimal", from_as_str.c_ptr(), field_name,
2644
                        (ulong) table->in_use->row_count);
2645

2646 2647 2648 2649
    DBUG_RETURN(err);
  }

  switch (err) {
2650 2651 2652 2653 2654 2655 2656 2657
  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:
2658 2659 2660 2661 2662
    {
      /* Because "from" is not NUL-terminated and we use %s in the ER() */
      String from_as_str;
      from_as_str.copy(from, length, &my_charset_bin);

2663 2664 2665
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
                        ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
2666
                          "decimal", from_as_str.c_ptr(), field_name,
2667 2668
                        (ulong) table->in_use->row_count);
    my_decimal_set_zero(&decimal_value);
2669

2670
    break;
2671
    }
2672 2673
  }

2674 2675 2676 2677 2678
#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
2679 2680 2681 2682 2683
  store_value(&decimal_value);
  DBUG_RETURN(err);
}


2684 2685 2686 2687 2688 2689
/**
  @todo
  Fix following when double2my_decimal when double2decimal
  will return E_DEC_TRUNCATED always correctly
*/

2690 2691
int Field_new_decimal::store(double nr)
{
2692
  ASSERT_COLUMN_MARKED_FOR_WRITE;
2693
  my_decimal decimal_value;
2694 2695 2696 2697 2698
  int err;
  DBUG_ENTER("Field_new_decimal::store(double)");

  err= double2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW, nr,
                         &decimal_value);
2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
  /*
    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;
  }
2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721
  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);
2722 2723 2724
}


2725
int Field_new_decimal::store(longlong nr, bool unsigned_val)
2726
{
2727
  ASSERT_COLUMN_MARKED_FOR_WRITE;
2728 2729
  my_decimal decimal_value;
  int err;
2730 2731

  if ((err= int2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
2732
                           nr, unsigned_val, &decimal_value)))
2733 2734 2735 2736 2737 2738 2739 2740 2741 2742
  {
    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);
2743 2744 2745 2746 2747 2748
  return err;
}


int Field_new_decimal::store_decimal(const my_decimal *decimal_value)
{
2749
  ASSERT_COLUMN_MARKED_FOR_WRITE;
2750 2751 2752 2753
  return store_value(decimal_value);
}


2754
int Field_new_decimal::store_time(MYSQL_TIME *ltime, timestamp_type t_type)
2755 2756 2757
{
    my_decimal decimal_value;
    return store_value(date2my_decimal(ltime, &decimal_value));
2758 2759 2760 2761 2762
}


double Field_new_decimal::val_real(void)
{
2763
  ASSERT_COLUMN_MARKED_FOR_READ;
2764 2765 2766 2767 2768 2769 2770 2771 2772
  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)
{
2773
  ASSERT_COLUMN_MARKED_FOR_READ;
2774 2775 2776 2777 2778 2779 2780 2781 2782 2783
  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)
{
2784
  ASSERT_COLUMN_MARKED_FOR_READ;
2785 2786
  DBUG_ENTER("Field_new_decimal::val_decimal");
  binary2my_decimal(E_DEC_FATAL_ERROR, ptr, decimal_value,
2787
                    precision, dec);
2788
  DBUG_EXECUTE("info", print_decimal_buff(decimal_value, (uchar *) ptr,
2789
                                          bin_size););
2790 2791 2792 2793 2794
  DBUG_RETURN(decimal_value);
}


String *Field_new_decimal::val_str(String *val_buffer,
2795
                                   String *val_ptr __attribute__((unused)))
2796
{
2797
  ASSERT_COLUMN_MARKED_FOR_READ;
2798
  my_decimal decimal_value;
2799
  uint fixed_precision= zerofill ? precision : 0;
2800
  my_decimal2string(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
2801
                    fixed_precision, dec, '0', val_buffer);
2802 2803 2804 2805
  return val_buffer;
}


2806
int Field_new_decimal::cmp(const uchar *a,const uchar*b)
2807 2808 2809 2810 2811
{
  return memcmp(a, b, bin_size);
}


2812
void Field_new_decimal::sort_string(uchar *buff,
2813 2814 2815 2816 2817 2818 2819 2820 2821 2822
                                    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(),
2823
                                "decimal(%d,%d)", precision, (int)dec));
2824 2825 2826
  add_zerofill_and_unsigned(str);
}

2827

2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881
/**
   Save the field metadata for new decimal fields.

   Saves the precision in the first byte and decimals() in the second
   byte of the field metadata array at index of *metadata_ptr and 
   *(metadata_ptr + 1).

   @param   metadata_ptr   First byte of field metadata

   @returns number of bytes written to metadata_ptr
*/
int Field_new_decimal::do_save_field_metadata(uchar *metadata_ptr)
{
  *metadata_ptr= precision;
  *(metadata_ptr + 1)= decimals();
  return 2;
}


/**
   Returns the number of bytes field uses in row-based replication 
   row packed size.

   This method is used in row-based replication to determine the number
   of bytes that the field consumes in the row record format. This is
   used to skip fields in the master that do not exist on the slave.

   @param   field_metadata   Encoded size in field metadata

   @returns The size of the field based on the field metadata.
*/
uint Field_new_decimal::pack_length_from_metadata(uint field_metadata)
{
  uint const source_precision= (field_metadata >> 8U) & 0x00ff;
  uint const source_decimal= field_metadata & 0x00ff; 
  uint const source_size= my_decimal_get_binary_size(source_precision, 
                                                     source_decimal);
  return (source_size);
}


/**
   Check to see if field size is compatible with destination.

   This method is used in row-based replication to verify that the slave's
   field size is less than or equal to the master's field size. The 
   encoded field metadata (from the master or source) is decoded and compared
   to the size of this field (the slave or destination). 

   @param   field_metadata   Encoded size in field metadata

   @retval 0 if this field's size is < the source field's size
   @retval 1 if this field's size is >= the source field's size
*/
2882 2883
int Field_new_decimal::compatible_field_size(uint field_metadata,
                                             const Relay_log_info * __attribute__((unused)))
2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898
{
  int compatible= 0;
  uint const source_precision= (field_metadata >> 8U) & 0x00ff;
  uint const source_decimal= field_metadata & 0x00ff; 
  uint const source_size= my_decimal_get_binary_size(source_precision, 
                                                     source_decimal);
  uint const destination_size= row_pack_length();
  compatible= (source_size <= destination_size);
  if (compatible)
    compatible= (source_precision <= precision) &&
                (source_decimal <= decimals());
  return (compatible);
}


2899
uint Field_new_decimal::is_equal(Create_field *new_field)
2900 2901 2902 2903 2904 2905
{
  return ((new_field->sql_type == real_type()) &&
          ((new_field->flags & UNSIGNED_FLAG) == 
           (uint) (flags & UNSIGNED_FLAG)) &&
          ((new_field->flags & AUTO_INCREMENT_FLAG) ==
           (uint) (flags & AUTO_INCREMENT_FLAG)) &&
2906
          (new_field->length == max_display_length()) &&
2907 2908 2909 2910
          (new_field->decimals == dec));
}


2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922
/**
   Unpack a decimal field from row data.

   This method is used to unpack a decimal or numeric field from a master
   whose size of the field is less than that of the slave.
  
   @param   to         Destination of the data
   @param   from       Source of the data
   @param   param_data Precision (upper) and decimal (lower) values

   @return  New pointer into memory based on from + length of the data
*/
2923 2924 2925 2926 2927
const uchar *
Field_new_decimal::unpack(uchar* to,
                          const uchar *from,
                          uint param_data,
                          bool low_byte_first)
2928
{
2929 2930 2931
  if (param_data == 0)
    return Field::unpack(to, from, param_data, low_byte_first);

2932 2933 2934 2935 2936 2937
  uint from_precision= (param_data & 0xff00) >> 8U;
  uint from_decimal= param_data & 0x00ff;
  uint length=pack_length();
  uint from_pack_len= my_decimal_get_binary_size(from_precision, from_decimal);
  uint len= (param_data && (from_pack_len < length)) ?
            from_pack_len : length;
2938 2939 2940
  if ((from_pack_len && (from_pack_len < length)) ||
      (from_precision < precision) ||
      (from_decimal < decimals()))
2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963
  {
    /*
      If the master's data is smaller than the slave, we need to convert
      the binary to decimal then resize the decimal converting it back to
      a decimal and write that to the raw data buffer.
    */
    decimal_digit_t dec_buf[DECIMAL_MAX_PRECISION];
    decimal_t dec;
    dec.len= from_precision;
    dec.buf= dec_buf;
    /*
      Note: bin2decimal does not change the length of the field. So it is
      just the first step the resizing operation. The second step does the
      resizing using the precision and decimals from the slave.
    */
    bin2decimal((uchar *)from, &dec, from_precision, from_decimal);
    decimal2bin(&dec, to, precision, decimals());
  }
  else
    memcpy(to, from, len); // Sizes are the same, just copy the data.
  return from+len;
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2964 2965 2966 2967
/****************************************************************************
** tiny int
****************************************************************************/

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2968
int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2969
{
2970
  ASSERT_COLUMN_MARKED_FOR_WRITE;
2971
  int error;
2972 2973 2974 2975
  longlong rnd;
  
  error= get_int(cs, from, len, &rnd, 255, -128, 127);
  ptr[0]= unsigned_flag ? (char) (ulonglong) rnd : (char) rnd;
2976
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2977 2978 2979
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2980
int Field_tiny::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2981
{
2982
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2983
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2984 2985 2986 2987 2988 2989
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0.0)
    {
      *ptr=0;
2990
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2991
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2992 2993 2994 2995
    }
    else if (nr > 255.0)
    {
      *ptr=(char) 255;
2996
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2997
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2998 2999 3000 3001 3002 3003 3004 3005 3006
    }
    else
      *ptr=(char) nr;
  }
  else
  {
    if (nr < -128.0)
    {
      *ptr= (char) -128;
3007
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3008
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3009 3010 3011 3012
    }
    else if (nr > 127.0)
    {
      *ptr=127;
3013
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3014
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3015 3016
    }
    else
serg@serg.mylan's avatar
serg@serg.mylan committed
3017
      *ptr=(char) (int) nr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3018
  }
3019
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3020 3021
}

3022 3023

int Field_tiny::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3024
{
3025
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3026
  int error= 0;
3027

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3028 3029
  if (unsigned_flag)
  {
3030
    if (nr < 0 && !unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3031
    {
3032
      *ptr= 0;
3033
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3034
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3035
    }
3036
    else if ((ulonglong) nr > (ulonglong) 255)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3037 3038
    {
      *ptr= (char) 255;
3039
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3040
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3041 3042 3043 3044 3045 3046
    }
    else
      *ptr=(char) nr;
  }
  else
  {
3047 3048 3049
    if (nr < 0 && unsigned_val)
      nr= 256;                                    // Generate overflow
    if (nr < -128)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3050 3051
    {
      *ptr= (char) -128;
3052
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3053
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3054
    }
3055
    else if (nr > 127)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3056 3057
    {
      *ptr=127;
3058
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3059
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3060 3061 3062 3063
    }
    else
      *ptr=(char) nr;
  }
3064
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3065 3066 3067 3068 3069
}


double Field_tiny::val_real(void)
{
3070
  ASSERT_COLUMN_MARKED_FOR_READ;
3071
  int tmp= unsigned_flag ? (int) ptr[0] :
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3072 3073 3074 3075
    (int) ((signed char*) ptr)[0];
  return (double) tmp;
}

3076

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3077 3078
longlong Field_tiny::val_int(void)
{
3079
  ASSERT_COLUMN_MARKED_FOR_READ;
3080
  int tmp= unsigned_flag ? (int) ptr[0] :
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3081 3082 3083 3084
    (int) ((signed char*) ptr)[0];
  return (longlong) tmp;
}

3085

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3086 3087 3088
String *Field_tiny::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
3089
  ASSERT_COLUMN_MARKED_FOR_READ;
3090
  CHARSET_INFO *cs= &my_charset_bin;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3091
  uint length;
3092 3093
  uint mlength=max(field_length+1,5*cs->mbmaxlen);
  val_buffer->alloc(mlength);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3094
  char *to=(char*) val_buffer->ptr();
3095

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3096
  if (unsigned_flag)
3097
    length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
3098
					   (long) *ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3099
  else
3100 3101
    length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
					   (long) *((signed char*) ptr));
3102
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3103 3104 3105 3106 3107 3108
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}

3109 3110 3111 3112
bool Field_tiny::send_binary(Protocol *protocol)
{
  return protocol->store_tiny((longlong) (int8) ptr[0]);
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3113

3114
int Field_tiny::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3115 3116 3117 3118 3119 3120 3121 3122
{
  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;
}

3123
void Field_tiny::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3124 3125 3126 3127
{
  if (unsigned_flag)
    *to= *ptr;
  else
3128
    to[0] = (char) (ptr[0] ^ (uchar) 128);	/* Revers signbit */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3129 3130 3131 3132
}

void Field_tiny::sql_type(String &res) const
{
3133
  CHARSET_INFO *cs=res.charset();
3134
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3135
			  "tinyint(%d)",(int) field_length));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3136 3137 3138 3139
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
3140
 Field type short int (2 byte)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3141 3142
****************************************************************************/

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3143
int Field_short::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3144
{
3145
  ASSERT_COLUMN_MARKED_FOR_WRITE;
3146
  int store_tmp;
3147
  int error;
3148 3149 3150 3151
  longlong rnd;
  
  error= get_int(cs, from, len, &rnd, UINT_MAX16, INT_MIN16, INT_MAX16);
  store_tmp= unsigned_flag ? (int) (ulonglong) rnd : (int) rnd;
3152
#ifdef WORDS_BIGENDIAN
3153 3154 3155
  if (table->s->db_low_byte_first)
  {
    int2store(ptr, store_tmp);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3156 3157 3158
  }
  else
#endif
3159
    shortstore(ptr, (short) store_tmp);
3160
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3161 3162 3163
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3164
int Field_short::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3165
{
3166
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3167
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3168 3169 3170 3171 3172 3173 3174
  int16 res;
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
3175
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3176
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3177
    }
serg@serg.mylan's avatar
serg@serg.mylan committed
3178
    else if (nr > (double) UINT_MAX16)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3179
    {
serg@serg.mylan's avatar
serg@serg.mylan committed
3180
      res=(int16) UINT_MAX16;
3181
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3182
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3183 3184 3185 3186 3187 3188 3189 3190 3191
    }
    else
      res=(int16) (uint16) nr;
  }
  else
  {
    if (nr < (double) INT_MIN16)
    {
      res=INT_MIN16;
3192
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3193
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3194 3195 3196 3197
    }
    else if (nr > (double) INT_MAX16)
    {
      res=INT_MAX16;
3198
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3199
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3200 3201
    }
    else
serg@serg.mylan's avatar
serg@serg.mylan committed
3202
      res=(int16) (int) nr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3203 3204
  }
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3205
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3206 3207 3208 3209 3210 3211
  {
    int2store(ptr,res);
  }
  else
#endif
    shortstore(ptr,res);
3212
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3213 3214
}

3215 3216

int Field_short::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3217
{
3218
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3219
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3220
  int16 res;
3221

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3222 3223
  if (unsigned_flag)
  {
3224
    if (nr < 0L && !unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3225 3226
    {
      res=0;
3227
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3228
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3229
    }
3230
    else if ((ulonglong) nr > (ulonglong) UINT_MAX16)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3231
    {
serg@serg.mylan's avatar
serg@serg.mylan committed
3232
      res=(int16) UINT_MAX16;
3233
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3234
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3235 3236 3237 3238 3239 3240
    }
    else
      res=(int16) (uint16) nr;
  }
  else
  {
3241 3242 3243
    if (nr < 0 && unsigned_val)
      nr= UINT_MAX16+1;                         // Generate overflow

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3244 3245 3246
    if (nr < INT_MIN16)
    {
      res=INT_MIN16;
3247
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3248
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3249
    }
3250
    else if (nr > (longlong) INT_MAX16)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3251 3252
    {
      res=INT_MAX16;
3253
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3254
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3255 3256 3257 3258 3259
    }
    else
      res=(int16) nr;
  }
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3260
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3261 3262 3263 3264 3265 3266
  {
    int2store(ptr,res);
  }
  else
#endif
    shortstore(ptr,res);
3267
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3268 3269 3270 3271 3272
}


double Field_short::val_real(void)
{
3273
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3274 3275
  short j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3276
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3277 3278 3279 3280 3281 3282 3283 3284 3285
    j=sint2korr(ptr);
  else
#endif
    shortget(j,ptr);
  return unsigned_flag ? (double) (unsigned short) j : (double) j;
}

longlong Field_short::val_int(void)
{
3286
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3287 3288
  short j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3289
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3290 3291 3292 3293 3294 3295 3296
    j=sint2korr(ptr);
  else
#endif
    shortget(j,ptr);
  return unsigned_flag ? (longlong) (unsigned short) j : (longlong) j;
}

3297

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3298 3299 3300
String *Field_short::val_str(String *val_buffer,
			     String *val_ptr __attribute__((unused)))
{
3301
  ASSERT_COLUMN_MARKED_FOR_READ;
3302
  CHARSET_INFO *cs= &my_charset_bin;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3303
  uint length;
3304 3305
  uint mlength=max(field_length+1,7*cs->mbmaxlen);
  val_buffer->alloc(mlength);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3306 3307 3308
  char *to=(char*) val_buffer->ptr();
  short j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3309
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3310 3311 3312 3313 3314 3315
    j=sint2korr(ptr);
  else
#endif
    shortget(j,ptr);

  if (unsigned_flag)
3316 3317
    length=(uint) cs->cset->long10_to_str(cs, to, mlength, 10, 
					  (long) (uint16) j);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3318
  else
3319
    length=(uint) cs->cset->long10_to_str(cs, to, mlength,-10, (long) j);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3320 3321 3322 3323 3324 3325 3326
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


3327 3328 3329 3330 3331 3332
bool Field_short::send_binary(Protocol *protocol)
{
  return protocol->store_short(Field_short::val_int());
}


3333
int Field_short::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3334 3335 3336
{
  short a,b;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3337
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354
  {
    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;
}

3355
void Field_short::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3356 3357
{
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3358
  if (!table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3359 3360 3361 3362
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
3363
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3364 3365 3366 3367 3368 3369 3370 3371
    to[1]   = ptr[1];
  }
  else
#endif
  {
    if (unsigned_flag)
      to[0] = ptr[1];
    else
3372
      to[0] = (char) (ptr[1] ^ 128);		/* Revers signbit */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3373 3374 3375 3376 3377 3378
    to[1]   = ptr[0];
  }
}

void Field_short::sql_type(String &res) const
{
3379
  CHARSET_INFO *cs=res.charset();
3380
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3381
			  "smallint(%d)",(int) field_length));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3382 3383 3384 3385 3386
  add_zerofill_and_unsigned(res);
}


/****************************************************************************
3387
  Field type medium int (3 byte)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3388 3389
****************************************************************************/

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3390
int Field_medium::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3391
{
3392
  ASSERT_COLUMN_MARKED_FOR_WRITE;
3393
  int store_tmp;
3394
  int error;
3395 3396 3397 3398 3399
  longlong rnd;
  
  error= get_int(cs, from, len, &rnd, UINT_MAX24, INT_MIN24, INT_MAX24);
  store_tmp= unsigned_flag ? (int) (ulonglong) rnd : (int) rnd;
  int3store(ptr, store_tmp);
3400
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3401 3402 3403
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3404
int Field_medium::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3405
{
3406
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3407
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3408 3409 3410 3411 3412 3413
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      int3store(ptr,0);
3414
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3415
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3416 3417 3418
    }
    else if (nr >= (double) (long) (1L << 24))
    {
3419
      uint32 tmp=(uint32) (1L << 24)-1L;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3420
      int3store(ptr,tmp);
3421
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3422
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3423 3424
    }
    else
3425
      int3store(ptr,(uint32) nr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3426 3427 3428 3429 3430 3431 3432
  }
  else
  {
    if (nr < (double) INT_MIN24)
    {
      long tmp=(long) INT_MIN24;
      int3store(ptr,tmp);
3433
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3434
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3435 3436 3437 3438 3439
    }
    else if (nr > (double) INT_MAX24)
    {
      long tmp=(long) INT_MAX24;
      int3store(ptr,tmp);
3440
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3441
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3442 3443 3444 3445
    }
    else
      int3store(ptr,(long) nr);
  }
3446
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3447 3448
}

3449 3450

int Field_medium::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3451
{
3452
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3453
  int error= 0;
3454

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3455 3456
  if (unsigned_flag)
  {
3457
    if (nr < 0 && !unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3458 3459
    {
      int3store(ptr,0);
3460
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3461
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3462
    }
3463
    else if ((ulonglong) nr >= (ulonglong) (long) (1L << 24))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3464
    {
3465
      long tmp= (long) (1L << 24)-1L;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3466
      int3store(ptr,tmp);
3467
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3468
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3469 3470
    }
    else
3471
      int3store(ptr,(uint32) nr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3472 3473 3474
  }
  else
  {
3475 3476 3477
    if (nr < 0 && unsigned_val)
      nr= (ulonglong) (long) (1L << 24);        // Generate overflow

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3478 3479
    if (nr < (longlong) INT_MIN24)
    {
3480
      long tmp= (long) INT_MIN24;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3481
      int3store(ptr,tmp);
3482
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3483
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3484 3485 3486 3487 3488
    }
    else if (nr > (longlong) INT_MAX24)
    {
      long tmp=(long) INT_MAX24;
      int3store(ptr,tmp);
3489
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3490
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3491 3492 3493 3494
    }
    else
      int3store(ptr,(long) nr);
  }
3495
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3496 3497 3498 3499 3500
}


double Field_medium::val_real(void)
{
3501
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3502 3503 3504 3505
  long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
  return (double) j;
}

3506

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3507 3508
longlong Field_medium::val_int(void)
{
3509
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3510 3511 3512 3513
  long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
  return (longlong) j;
}

3514

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3515 3516 3517
String *Field_medium::val_str(String *val_buffer,
			      String *val_ptr __attribute__((unused)))
{
3518
  ASSERT_COLUMN_MARKED_FOR_READ;
3519
  CHARSET_INFO *cs= &my_charset_bin;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3520
  uint length;
3521 3522
  uint mlength=max(field_length+1,10*cs->mbmaxlen);
  val_buffer->alloc(mlength);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3523 3524 3525
  char *to=(char*) val_buffer->ptr();
  long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);

3526
  length=(uint) cs->cset->long10_to_str(cs,to,mlength,-10,j);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3527 3528 3529 3530 3531 3532 3533
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer); /* purecov: inspected */
  return val_buffer;
}


3534 3535
bool Field_medium::send_binary(Protocol *protocol)
{
3536
  ASSERT_COLUMN_MARKED_FOR_READ;
3537 3538 3539 3540
  return protocol->store_long(Field_medium::val_int());
}


3541
int Field_medium::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556
{
  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;
}

3557
void Field_medium::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569
{
  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
{
3570
  CHARSET_INFO *cs=res.charset();
3571
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(), 
3572
			  "mediumint(%d)",(int) field_length));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3573 3574 3575 3576 3577 3578 3579
  add_zerofill_and_unsigned(res);
}

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

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3580
int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3581
{
3582
  ASSERT_COLUMN_MARKED_FOR_WRITE;
3583 3584
  long store_tmp;
  int error;
3585 3586 3587 3588
  longlong rnd;
  
  error= get_int(cs, from, len, &rnd, UINT_MAX32, INT_MIN32, INT_MAX32);
  store_tmp= unsigned_flag ? (long) (ulonglong) rnd : (long) rnd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3589
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3590
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3591
  {
3592
    int4store(ptr, store_tmp);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3593 3594 3595
  }
  else
#endif
3596
    longstore(ptr, store_tmp);
3597
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3598 3599 3600
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3601
int Field_long::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3602
{
3603
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3604
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3605 3606 3607 3608 3609 3610 3611
  int32 res;
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3612
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3613
    }
3614
    else if (nr > (double) UINT_MAX32)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3615
    {
3616
      res= UINT_MAX32;
3617
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3618
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3619 3620 3621 3622 3623 3624 3625 3626 3627
    }
    else
      res=(int32) (ulong) nr;
  }
  else
  {
    if (nr < (double) INT_MIN32)
    {
      res=(int32) INT_MIN32;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3628
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3629 3630 3631 3632
    }
    else if (nr > (double) INT_MAX32)
    {
      res=(int32) INT_MAX32;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3633
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3634 3635
    }
    else
serg@serg.mylan's avatar
serg@serg.mylan committed
3636
      res=(int32) (longlong) nr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3637
  }
3638 3639 3640
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3641
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3642
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3643 3644 3645 3646 3647 3648
  {
    int4store(ptr,res);
  }
  else
#endif
    longstore(ptr,res);
3649
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3650 3651 3652
}


3653
int Field_long::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3654
{
3655
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3656
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3657
  int32 res;
serg@serg.mylan's avatar
serg@serg.mylan committed
3658

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3659 3660
  if (unsigned_flag)
  {
3661
    if (nr < 0 && !unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3662 3663
    {
      res=0;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3664
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3665
    }
3666
    else if ((ulonglong) nr >= (LL(1) << 32))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3667 3668
    {
      res=(int32) (uint32) ~0L;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3669
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3670 3671 3672 3673 3674 3675
    }
    else
      res=(int32) (uint32) nr;
  }
  else
  {
3676
    if (nr < 0 && unsigned_val)
3677
      nr= ((longlong) INT_MAX32) + 1;           // Generate overflow
3678
    if (nr < (longlong) INT_MIN32) 
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3679 3680
    {
      res=(int32) INT_MIN32;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3681
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3682 3683 3684 3685
    }
    else if (nr > (longlong) INT_MAX32)
    {
      res=(int32) INT_MAX32;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3686
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3687 3688 3689 3690
    }
    else
      res=(int32) nr;
  }
3691 3692 3693
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3694
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3695
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3696 3697 3698 3699 3700 3701
  {
    int4store(ptr,res);
  }
  else
#endif
    longstore(ptr,res);
3702
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3703 3704 3705 3706 3707
}


double Field_long::val_real(void)
{
3708
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3709 3710
  int32 j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3711
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3712 3713 3714 3715 3716 3717 3718 3719 3720
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return unsigned_flag ? (double) (uint32) j : (double) j;
}

longlong Field_long::val_int(void)
{
3721
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3722
  int32 j;
3723 3724
  /* See the comment in Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3725
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3726
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3727 3728 3729 3730 3731 3732 3733 3734 3735 3736
    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)))
{
3737
  ASSERT_COLUMN_MARKED_FOR_READ;
3738
  CHARSET_INFO *cs= &my_charset_bin;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3739
  uint length;
3740 3741
  uint mlength=max(field_length+1,12*cs->mbmaxlen);
  val_buffer->alloc(mlength);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3742 3743 3744
  char *to=(char*) val_buffer->ptr();
  int32 j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3745
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3746 3747 3748 3749 3750
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);

3751
  if (unsigned_flag)
3752
    length=cs->cset->long10_to_str(cs,to,mlength, 10,(long) (uint32)j);
3753
  else
3754
    length=cs->cset->long10_to_str(cs,to,mlength,-10,(long) j);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3755 3756 3757 3758 3759 3760 3761
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


3762 3763
bool Field_long::send_binary(Protocol *protocol)
{
3764
  ASSERT_COLUMN_MARKED_FOR_READ;
3765 3766 3767
  return protocol->store_long(Field_long::val_int());
}

3768
int Field_long::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3769 3770 3771
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3772
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783
  {
    a=sint4korr(a_ptr);
    b=sint4korr(b_ptr);
  }
  else
#endif
  {
    longget(a,a_ptr);
    longget(b,b_ptr);
  }
  if (unsigned_flag)
3784
    return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3785 3786 3787
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

3788
void Field_long::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3789 3790
{
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3791
  if (!table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3792 3793 3794 3795
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
3796
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3797 3798 3799 3800 3801 3802 3803 3804 3805 3806
    to[1]   = ptr[1];
    to[2]   = ptr[2];
    to[3]   = ptr[3];
  }
  else
#endif
  {
    if (unsigned_flag)
      to[0] = ptr[3];
    else
3807
      to[0] = (char) (ptr[3] ^ 128);		/* Revers signbit */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3808 3809 3810 3811 3812 3813 3814 3815 3816
    to[1]   = ptr[2];
    to[2]   = ptr[1];
    to[3]   = ptr[0];
  }
}


void Field_long::sql_type(String &res) const
{
3817
  CHARSET_INFO *cs=res.charset();
3818
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
3819
			  "int(%d)",(int) field_length));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3820 3821 3822 3823
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
3824
 Field type longlong int (8 bytes)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3825 3826
****************************************************************************/

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3827
int Field_longlong::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3828
{
3829
  ASSERT_COLUMN_MARKED_FOR_WRITE;
3830
  int error= 0;
3831
  char *end;
3832
  ulonglong tmp;
3833

3834 3835
  tmp= cs->cset->strntoull10rnd(cs,from,len,unsigned_flag,&end,&error);
  if (error == MY_ERRNO_ERANGE)
3836
  {
3837
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3838 3839
    error= 1;
  }
3840 3841
  else if (table->in_use->count_cuted_fields && 
           check_int(cs, from, len, end, error))
3842 3843 3844
    error= 1;
  else
    error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3845
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3846
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3847 3848 3849 3850 3851 3852
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
3853
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3854 3855 3856
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3857
int Field_longlong::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3858
{
3859
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3860
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3861
  longlong res;
3862 3863

  nr= rint(nr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3864 3865 3866 3867 3868
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3869
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3870
    }
serg@serg.mylan's avatar
serg@serg.mylan committed
3871
    else if (nr >= (double) ULONGLONG_MAX)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3872 3873
    {
      res= ~(longlong) 0;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
3874
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3875 3876
    }
    else
3877
      res=(longlong) double2ulonglong(nr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3878 3879 3880
  }
  else
  {
serg@serg.mylan's avatar
serg@serg.mylan committed
3881
    if (nr <= (double) LONGLONG_MIN)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3882
    {
3883
      res= LONGLONG_MIN;
serg@serg.mylan's avatar
serg@serg.mylan committed
3884
      error= (nr < (double) LONGLONG_MIN);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3885
    }
3886
    else if (nr >= (double) (ulonglong) LONGLONG_MAX)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3887
    {
3888
      res= LONGLONG_MAX;
serg@serg.mylan's avatar
serg@serg.mylan committed
3889
      error= (nr > (double) LONGLONG_MAX);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3890 3891 3892 3893
    }
    else
      res=(longlong) nr;
  }
3894 3895 3896
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3897
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3898
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3899 3900 3901 3902 3903 3904
  {
    int8store(ptr,res);
  }
  else
#endif
    longlongstore(ptr,res);
3905
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3906 3907 3908
}


3909
int Field_longlong::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3910
{
3911
  ASSERT_COLUMN_MARKED_FOR_WRITE;
3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927
  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;
    }
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3928
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3929
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3930 3931 3932 3933 3934 3935
  {
    int8store(ptr,nr);
  }
  else
#endif
    longlongstore(ptr,nr);
3936
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3937 3938 3939 3940 3941
}


double Field_longlong::val_real(void)
{
3942
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3943 3944
  longlong j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3945
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3946 3947 3948 3949 3950 3951
  {
    j=sint8korr(ptr);
  }
  else
#endif
    longlongget(j,ptr);
3952 3953 3954 3955 3956 3957 3958
  /* 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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3959 3960
}

3961

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3962 3963
longlong Field_longlong::val_int(void)
{
3964
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3965 3966
  longlong j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3967
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978
    j=sint8korr(ptr);
  else
#endif
    longlongget(j,ptr);
  return j;
}


String *Field_longlong::val_str(String *val_buffer,
				String *val_ptr __attribute__((unused)))
{
3979
  CHARSET_INFO *cs= &my_charset_bin;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3980
  uint length;
3981 3982
  uint mlength=max(field_length+1,22*cs->mbmaxlen);
  val_buffer->alloc(mlength);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3983 3984 3985
  char *to=(char*) val_buffer->ptr();
  longlong j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
3986
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3987 3988 3989 3990 3991
    j=sint8korr(ptr);
  else
#endif
    longlongget(j,ptr);

3992
  length=(uint) (cs->cset->longlong10_to_str)(cs,to,mlength,
3993
					unsigned_flag ? 10 : -10, j);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3994 3995 3996 3997 3998 3999 4000
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


4001 4002
bool Field_longlong::send_binary(Protocol *protocol)
{
4003
  ASSERT_COLUMN_MARKED_FOR_READ;
4004 4005 4006 4007
  return protocol->store_longlong(Field_longlong::val_int(), unsigned_flag);
}


4008
int Field_longlong::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4009 4010 4011
{
  longlong a,b;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4012
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028
  {
    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;
}

4029
void Field_longlong::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4030 4031
{
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4032
  if (!table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4033 4034 4035 4036
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
4037
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051
    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
4052
      to[0] = (char) (ptr[7] ^ 128);		/* Revers signbit */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065
    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
{
4066
  CHARSET_INFO *cs=res.charset();
4067
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
4068
			  "bigint(%d)",(int) field_length));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4069 4070 4071
  add_zerofill_and_unsigned(res);
}

monty@mysql.com's avatar
monty@mysql.com committed
4072

4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113
/*
  Floating-point numbers
 */

uchar *
Field_real::pack(uchar *to, const uchar *from,
                 uint max_length, bool low_byte_first)
{
  DBUG_ENTER("Field_real::pack");
  DBUG_ASSERT(max_length >= pack_length());
#ifdef WORDS_BIGENDIAN
  if (low_byte_first != table->s->db_low_byte_first)
  {
    const uchar *dptr= from + pack_length();
    while (dptr-- > from)
      *to++ = *dptr;
    DBUG_RETURN(to);
  }
  else
#endif
    DBUG_RETURN(Field::pack(to, from, max_length, low_byte_first));
}

const uchar *
Field_real::unpack(uchar *to, const uchar *from,
                   uint param_data, bool low_byte_first)
{
  DBUG_ENTER("Field_real::unpack");
#ifdef WORDS_BIGENDIAN
  if (low_byte_first != table->s->db_low_byte_first)
  {
    const uchar *dptr= from + pack_length();
    while (dptr-- > from)
      *to++ = *dptr;
    DBUG_RETURN(from + pack_length());
  }
  else
#endif
    DBUG_RETURN(Field::unpack(to, from, param_data, low_byte_first));
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4114
/****************************************************************************
monty@mysql.com's avatar
monty@mysql.com committed
4115
  single precision float
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4116 4117
****************************************************************************/

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4118
int Field_float::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4119
{
monty@mysql.com's avatar
monty@mysql.com committed
4120
  int error;
4121
  char *end;
monty@mysql.com's avatar
monty@mysql.com committed
4122
  double nr= my_strntod(cs,(char*) from,len,&end,&error);
4123 4124
  if (error || (!len || ((uint) (end-from) != len &&
                table->in_use->count_cuted_fields)))
4125
  {
4126
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4127
                (error ? ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED), 1);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4128
    error= error ? 1 : 2;
4129
  }
monty@mysql.com's avatar
monty@mysql.com committed
4130 4131
  Field_float::store(nr);
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4132 4133 4134
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4135
int Field_float::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4136
{
4137
  ASSERT_COLUMN_MARKED_FOR_WRITE;
4138
  int error= truncate(&nr, FLT_MAX);
4139
  float j= (float)nr;
4140

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4141
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4142
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4143 4144 4145 4146 4147
  {
    float4store(ptr,j);
  }
  else
#endif
4148
    memcpy_fixed(ptr,(uchar*) &j,sizeof(j));
4149
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4150 4151 4152
}


4153
int Field_float::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4154
{
4155 4156
  return Field_float::store(unsigned_val ? ulonglong2double((ulonglong) nr) :
                            (double) nr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4157 4158
}

4159

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4160 4161
double Field_float::val_real(void)
{
4162
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4163 4164
  float j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4165
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4166 4167 4168 4169 4170
  {
    float4get(j,ptr);
  }
  else
#endif
4171
    memcpy_fixed((uchar*) &j,ptr,sizeof(j));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4172 4173 4174 4175 4176 4177 4178
  return ((double) j);
}

longlong Field_float::val_int(void)
{
  float j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4179
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4180 4181 4182 4183 4184
  {
    float4get(j,ptr);
  }
  else
#endif
4185
    memcpy_fixed((uchar*) &j,ptr,sizeof(j));
4186
  return (longlong) rint(j);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4187 4188 4189 4190 4191 4192
}


String *Field_float::val_str(String *val_buffer,
			     String *val_ptr __attribute__((unused)))
{
4193
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4194 4195
  float nr;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4196
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4197 4198 4199 4200 4201
  {
    float4get(nr,ptr);
  }
  else
#endif
4202
    memcpy_fixed((uchar*) &nr,ptr,sizeof(nr));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4203

4204 4205
  uint to_length=max(field_length,70);
  val_buffer->alloc(to_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253
  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++;
4254
#else
4255 4256 4257
#ifdef HAVE_SNPRINTF
    to[to_length-1]=0;			// Safety
    snprintf(to,to_length-1,"%.*f",dec,nr);
4258
    to=strend(to);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4259
#else
4260
    to+= my_sprintf(to,(to,"%.*f",dec,nr));
4261
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273
#endif
  }
#ifdef HAVE_FCONVERT
 end:
#endif
  val_buffer->length((uint) (to-val_buffer->ptr()));
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


4274
int Field_float::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4275 4276 4277
{
  float a,b;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4278
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293
  {
    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)

4294
void Field_float::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4295 4296 4297
{
  float nr;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4298
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4299 4300 4301 4302 4303 4304 4305
  {
    float4get(nr,ptr);
  }
  else
#endif
    memcpy_fixed(&nr,ptr,sizeof(float));

4306
  uchar *tmp= to;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322
  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++)
4323
	tmp[i]= (uchar) (tmp[i] ^ (uchar) 255);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336
    }
    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;
    }
  }
}


4337 4338
bool Field_float::send_binary(Protocol *protocol)
{
4339
  ASSERT_COLUMN_MARKED_FOR_READ;
4340 4341 4342 4343
  return protocol->store((float) Field_float::val_real(), dec, (String*) 0);
}


4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359
/**
   Save the field metadata for float fields.

   Saves the pack length in the first byte.

   @param   metadata_ptr   First byte of field metadata

   @returns number of bytes written to metadata_ptr
*/
int Field_float::do_save_field_metadata(uchar *metadata_ptr)
{
  *metadata_ptr= pack_length();
  return 1;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
4360 4361 4362
void Field_float::sql_type(String &res) const
{
  if (dec == NOT_FIXED_DEC)
4363
  {
4364
    res.set_ascii(STRING_WITH_LEN("float"));
4365
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4366
  else
4367
  {
4368
    CHARSET_INFO *cs= res.charset();
4369
    res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
4370
			    "float(%d,%d)",(int) field_length,dec));
4371
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4372 4373 4374
  add_zerofill_and_unsigned(res);
}

monty@mysql.com's avatar
monty@mysql.com committed
4375

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4376
/****************************************************************************
monty@mysql.com's avatar
monty@mysql.com committed
4377
  double precision floating point numbers
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4378 4379
****************************************************************************/

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4380
int Field_double::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4381
{
monty@mysql.com's avatar
monty@mysql.com committed
4382
  int error;
4383
  char *end;
monty@mysql.com's avatar
monty@mysql.com committed
4384
  double nr= my_strntod(cs,(char*) from, len, &end, &error);
4385 4386
  if (error || (!len || ((uint) (end-from) != len &&
                table->in_use->count_cuted_fields)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4387
  {
4388
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4389
                (error ? ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED), 1);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4390
    error= error ? 1 : 2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4391
  }
monty@mysql.com's avatar
monty@mysql.com committed
4392 4393
  Field_double::store(nr);
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4394 4395 4396
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4397
int Field_double::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4398
{
4399
  ASSERT_COLUMN_MARKED_FOR_WRITE;
4400
  int error= truncate(&nr, DBL_MAX);
4401

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4402
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4403
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4404 4405 4406 4407 4408 4409
  {
    float8store(ptr,nr);
  }
  else
#endif
    doublestore(ptr,nr);
4410
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4411 4412 4413
}


4414
int Field_double::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4415
{
4416 4417
  return Field_double::store(unsigned_val ? ulonglong2double((ulonglong) nr) :
                             (double) nr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4418 4419
}

4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476
/*
  If a field has fixed length, truncate the double argument pointed to by 'nr'
  appropriately.
  Also ensure that the argument is within [-max_value; max_value] range.
*/

int Field_real::truncate(double *nr, double max_value)
{
  int error= 1;
  double res= *nr;
  
  if (isnan(res))
  {
    res= 0;
    set_null();
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
    goto end;
  }
  else if (unsigned_flag && res < 0)
  {
    res= 0;
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
    goto end;
  }

  if (!not_fixed)
  {
    uint order= field_length - dec;
    uint step= array_elements(log_10) - 1;
    max_value= 1.0;
    for (; order > step; order-= step)
      max_value*= log_10[step];
    max_value*= log_10[order];
    max_value-= 1.0 / log_10[dec];

    double tmp= rint((res - floor(res)) * log_10[dec]) / log_10[dec];
    res= floor(res) + tmp;
  }
  
  if (res < -max_value)
  {
   res= -max_value;
   set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  }
  else if (res > max_value)
  {
    res= max_value;
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  }
  else
    error= 0;

end:
  *nr= res;
  return error;
}

4477

4478 4479 4480 4481 4482 4483
int Field_real::store_decimal(const my_decimal *dm)
{
  double dbl;
  my_decimal2double(E_DEC_FATAL_ERROR, dm, &dbl);
  return store(dbl);
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4484 4485 4486

double Field_double::val_real(void)
{
4487
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4488 4489
  double j;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4490
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501
  {
    float8get(j,ptr);
  }
  else
#endif
    doubleget(j,ptr);
  return j;
}

longlong Field_double::val_int(void)
{
4502
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4503
  double j;
bar@mysql.com's avatar
bar@mysql.com committed
4504
  longlong res;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4505
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4506
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4507 4508 4509 4510 4511 4512
  {
    float8get(j,ptr);
  }
  else
#endif
    doubleget(j,ptr);
4513 4514
  /* Check whether we fit into longlong range */
  if (j <= (double) LONGLONG_MIN)
bar@mysql.com's avatar
bar@mysql.com committed
4515 4516 4517 4518
  {
    res= (longlong) LONGLONG_MIN;
    goto warn;
  }
4519
  if (j >= (double) (ulonglong) LONGLONG_MAX)
bar@mysql.com's avatar
bar@mysql.com committed
4520 4521 4522 4523
  {
    res= (longlong) LONGLONG_MAX;
    goto warn;
  }
4524
  return (longlong) rint(j);
bar@mysql.com's avatar
bar@mysql.com committed
4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536

warn:
  {
    char buf[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
    String tmp(buf, sizeof(buf), &my_charset_latin1), *str;
    str= val_str(&tmp, 0);
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE,
                        ER(ER_TRUNCATED_WRONG_VALUE), "INTEGER",
                        str->c_ptr());
  }
  return res;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4537 4538 4539
}


4540 4541
my_decimal *Field_real::val_decimal(my_decimal *decimal_value)
{
4542
  ASSERT_COLUMN_MARKED_FOR_READ;
4543 4544 4545 4546 4547
  double2my_decimal(E_DEC_FATAL_ERROR, val_real(), decimal_value);
  return decimal_value;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
4548 4549 4550
String *Field_double::val_str(String *val_buffer,
			      String *val_ptr __attribute__((unused)))
{
4551
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4552 4553
  double nr;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4554
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4555 4556 4557 4558 4559 4560 4561
  {
    float8get(nr,ptr);
  }
  else
#endif
    doubleget(nr,ptr);

4562
  uint to_length=max(field_length, DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573
  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
bar@mysql.com's avatar
bar@mysql.com committed
4574
    char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
4575
    char *pos= buff;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613
    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
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4614
    to[to_length-1]=0;			// Safety
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
4615
    snprintf(to,to_length-1,"%.*f",dec,nr);
4616
    to=strend(to);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4617
#else
4618
    to+= my_sprintf(to,(to,"%.*f",dec,nr));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631
#endif
#endif
  }
#ifdef HAVE_FCONVERT
 end:
#endif

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

4632 4633
bool Field_double::send_binary(Protocol *protocol)
{
4634
  return protocol->store((double) Field_double::val_real(), dec, (String*) 0);
4635 4636
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4637

4638
int Field_double::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4639 4640 4641
{
  double a,b;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4642
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4643 4644 4645 4646 4647 4648 4649
  {
    float8get(a,a_ptr);
    float8get(b,b_ptr);
  }
  else
#endif
  {
4650 4651
    doubleget(a, a_ptr);
    doubleget(b, b_ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4652 4653 4654 4655 4656 4657 4658 4659 4660
  }
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}


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

/* The following should work for IEEE */

4661
void Field_double::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4662 4663 4664
{
  double nr;
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
4665
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4666 4667 4668 4669 4670
  {
    float8get(nr,ptr);
  }
  else
#endif
4671
    doubleget(nr,ptr);
4672
  change_double_for_sort(nr, to);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4673 4674 4675
}


4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692
/**
   Save the field metadata for double fields.

   Saves the pack length in the first byte of the field metadata array
   at index of *metadata_ptr.

   @param   metadata_ptr   First byte of field metadata

   @returns number of bytes written to metadata_ptr
*/
int Field_double::do_save_field_metadata(uchar *metadata_ptr)
{
  *metadata_ptr= pack_length();
  return 1;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
4693 4694
void Field_double::sql_type(String &res) const
{
4695
  CHARSET_INFO *cs=res.charset();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4696
  if (dec == NOT_FIXED_DEC)
4697
  {
4698
    res.set_ascii(STRING_WITH_LEN("double"));
4699
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4700
  else
4701
  {
4702
    res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
4703
			    "double(%d,%d)",(int) field_length,dec));
4704
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4705 4706 4707 4708
  add_zerofill_and_unsigned(res);
}


4709 4710
/**
  TIMESTAMP type holds datetime values in range from 1970-01-01 00:00:01 UTC to 
4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731
  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 
4732
    field which has 0 as default value and is not automatically updated.
4733 4734 4735 4736 4737 4738 4739 4740 4741 4742
  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).

4743
  Note that TIMESTAMP_OLD_FIELDs are never created explicitly now, they are 
4744 4745 4746 4747 4748 4749 4750 4751
  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.
 */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4752

4753
Field_timestamp::Field_timestamp(uchar *ptr_arg, uint32 len_arg,
4754
                                 uchar *null_ptr_arg, uchar null_bit_arg,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4755 4756
				 enum utype unireg_check_arg,
				 const char *field_name_arg,
4757
				 TABLE_SHARE *share,
4758
				 CHARSET_INFO *cs)
4759
  :Field_str(ptr_arg, MAX_DATETIME_WIDTH, null_ptr_arg, null_bit_arg,
4760
	     unireg_check_arg, field_name_arg, cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4761
{
4762 4763
  /* For 4.0 MYD and 4.0 InnoDB compatibility */
  flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
4764
  if (!share->timestamp_field && unireg_check != NONE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4765
  {
4766
    /* This timestamp has auto-update */
4767 4768
    share->timestamp_field= this;
    flags|= TIMESTAMP_FLAG;
4769 4770
    if (unireg_check != TIMESTAMP_DN_FIELD)
      flags|= ON_UPDATE_NOW_FLAG;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4771 4772 4773 4774
  }
}


4775 4776
Field_timestamp::Field_timestamp(bool maybe_null_arg,
                                 const char *field_name_arg,
evgen@sunlight.local's avatar
evgen@sunlight.local committed
4777
                                 CHARSET_INFO *cs)
4778 4779
  :Field_str((uchar*) 0, MAX_DATETIME_WIDTH,
             maybe_null_arg ? (uchar*) "": 0, 0,
evgen@sunlight.local's avatar
evgen@sunlight.local committed
4780
	     NONE, field_name_arg, cs)
4781 4782 4783
{
  /* For 4.0 MYD and 4.0 InnoDB compatibility */
  flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
4784 4785
    if (unireg_check != TIMESTAMP_DN_FIELD)
      flags|= ON_UPDATE_NOW_FLAG;
4786 4787 4788
}


4789
/**
4790 4791
  Get auto-set type for TIMESTAMP field.

4792 4793
  Returns value indicating during which operations this TIMESTAMP field
  should be auto-set to current timestamp.
4794
*/
4795
timestamp_auto_set_type Field_timestamp::get_auto_set_type() const
4796
{
4797 4798 4799 4800 4801 4802
  switch (unireg_check)
  {
  case TIMESTAMP_DN_FIELD:
    return TIMESTAMP_AUTO_SET_ON_INSERT;
  case TIMESTAMP_UN_FIELD:
    return TIMESTAMP_AUTO_SET_ON_UPDATE;
4803 4804
  case TIMESTAMP_OLD_FIELD:
    /*
4805
      Although we can have several such columns in legacy tables this
4806 4807 4808 4809 4810
      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 */
4811 4812 4813 4814 4815 4816 4817 4818 4819 4820
  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;
  }
4821 4822 4823
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4824
int Field_timestamp::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4825
{
4826
  ASSERT_COLUMN_MARKED_FOR_WRITE;
4827
  MYSQL_TIME l_time;
4828 4829 4830
  my_time_t tmp= 0;
  int error;
  bool have_smth_to_conv;
4831
  my_bool in_dst_time_gap;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
4832
  THD *thd= table ? table->in_use : current_thd;
4833

4834
  /* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
4835
  have_smth_to_conv= (str_to_datetime(from, len, &l_time,
evgen@moonbone.local's avatar
evgen@moonbone.local committed
4836
                                      (thd->variables.sql_mode &
4837 4838
                                       MODE_NO_ZERO_DATE) |
                                      MODE_NO_ZERO_IN_DATE, &error) >
4839
                      MYSQL_TIMESTAMP_ERROR);
4840

4841 4842 4843
  if (error || !have_smth_to_conv)
  {
    error= 1;
4844
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
4845
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
4846
  }
4847

4848 4849
  /* Only convert a correct date (not a zero date) */
  if (have_smth_to_conv && l_time.month)
4850 4851 4852
  {
    if (!(tmp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
    {
4853
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4854
                           ER_WARN_DATA_OUT_OF_RANGE,
4855
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
4856 4857 4858 4859 4860
      error= 1;
    }
    else if (in_dst_time_gap)
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4861
                           ER_WARN_INVALID_TIMESTAMP,
4862
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
4863 4864 4865
      error= 1;
    }
  }
4866
  store_timestamp(tmp);
4867
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4868 4869
}

4870

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4871
int Field_timestamp::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4872
{
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4873
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4874 4875
  if (nr < 0 || nr > 99991231235959.0)
  {
4876 4877
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                         ER_WARN_DATA_OUT_OF_RANGE,
4878
                         nr, MYSQL_TIMESTAMP_DATETIME);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
4879 4880
    nr= 0;					// Avoid overflow on buff
    error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4881
  }
4882
  error|= Field_timestamp::store((longlong) rint(nr), FALSE);
4883
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4884 4885 4886
}


4887
int Field_timestamp::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4888
{
4889
  ASSERT_COLUMN_MARKED_FOR_WRITE;
4890
  MYSQL_TIME l_time;
4891 4892
  my_time_t timestamp= 0;
  int error;
4893
  my_bool in_dst_time_gap;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
4894
  THD *thd= table ? table->in_use : current_thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4895

4896
  /* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
4897 4898 4899
  longlong tmp= number_to_datetime(nr, &l_time, (thd->variables.sql_mode &
                                                 MODE_NO_ZERO_DATE) |
                                   MODE_NO_ZERO_IN_DATE, &error);
4900
  if (tmp == LL(-1))
4901 4902 4903 4904 4905
  {
    error= 2;
  }

  if (!error && tmp)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4906
  {
4907 4908
    if (!(timestamp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
    {
4909 4910 4911
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                           ER_WARN_DATA_OUT_OF_RANGE,
                           nr, MYSQL_TIMESTAMP_DATETIME, 1);
4912 4913 4914 4915 4916
      error= 1;
    }
    if (in_dst_time_gap)
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4917 4918
                           ER_WARN_INVALID_TIMESTAMP,
                           nr, MYSQL_TIMESTAMP_DATETIME, 1);
4919 4920
      error= 1;
    }
4921 4922
  } else if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
4923
                         WARN_DATA_TRUNCATED,
4924
                         nr, MYSQL_TIMESTAMP_DATETIME, 1);
4925

4926
  store_timestamp(timestamp);
monty@mysql.com's avatar
monty@mysql.com committed
4927
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4928 4929 4930 4931
}

double Field_timestamp::val_real(void)
{
4932
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4933 4934 4935 4936 4937
  return (double) Field_timestamp::val_int();
}

longlong Field_timestamp::val_int(void)
{
4938
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4939
  uint32 temp;
4940
  MYSQL_TIME time_tmp;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
4941
  THD  *thd= table ? table->in_use : current_thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4942

4943
  thd->time_zone_used= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4944
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
4945
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4946 4947 4948 4949 4950 4951 4952
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);

  if (temp == 0L)				// No time
    return(0);					/* purecov: inspected */
4953 4954 4955 4956 4957 4958
  
  thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp, (my_time_t)temp);
  
  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;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4959 4960 4961
}


serg@serg.mylan's avatar
serg@serg.mylan committed
4962
String *Field_timestamp::val_str(String *val_buffer, String *val_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4963
{
4964
  ASSERT_COLUMN_MARKED_FOR_READ;
4965
  uint32 temp, temp2;
4966
  MYSQL_TIME time_tmp;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
4967
  THD *thd= table ? table->in_use : current_thd;
monty@mysql.com's avatar
monty@mysql.com committed
4968
  char *to;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4969 4970

  val_buffer->alloc(field_length+1);
monty@mysql.com's avatar
monty@mysql.com committed
4971
  to= (char*) val_buffer->ptr();
4972
  val_buffer->length(field_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4973

4974
  thd->time_zone_used= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4975
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
4976
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4977 4978 4979 4980 4981 4982 4983
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);

  if (temp == 0L)
  {				      /* Zero time is "000000" */
4984
    val_ptr->set(STRING_WITH_LEN("0000-00-00 00:00:00"), &my_charset_bin);
4985
    return val_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4986
  }
4987
  val_buffer->set_charset(&my_charset_bin);	// Safety
4988 4989
  
  thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp,(my_time_t)temp);
4990

4991
  temp= time_tmp.year % 100;
4992
  if (temp < YY_PART_YEAR - 1)
4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005
  {
    *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++= '-';
5006
  temp=time_tmp.month;
5007 5008 5009 5010
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= '-';
5011
  temp=time_tmp.day;
5012 5013 5014 5015
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ' ';
5016
  temp=time_tmp.hour;
5017 5018 5019 5020
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ':';
5021
  temp=time_tmp.minute;
5022 5023 5024 5025
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ':';
5026
  temp=time_tmp.second;
5027 5028 5029 5030
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5031 5032 5033
  return val_buffer;
}

5034

5035
bool Field_timestamp::get_date(MYSQL_TIME *ltime, uint fuzzydate)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5036 5037
{
  long temp;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5038
  THD *thd= table ? table->in_use : current_thd;
5039
  thd->time_zone_used= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5040
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5041
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5042 5043 5044 5045 5046 5047
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);
  if (temp == 0L)
  {				      /* Zero time is "000000" */
5048
    if (fuzzydate & TIME_NO_ZERO_DATE)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5049
      return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5050 5051 5052 5053
    bzero((char*) ltime,sizeof(*ltime));
  }
  else
  {
5054
    thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)temp);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5055 5056 5057 5058
  }
  return 0;
}

5059
bool Field_timestamp::get_time(MYSQL_TIME *ltime)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5060
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5061
  return Field_timestamp::get_date(ltime,0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5062 5063
}

5064 5065 5066

bool Field_timestamp::send_binary(Protocol *protocol)
{
5067
  MYSQL_TIME tm;
5068
  Field_timestamp::get_date(&tm, 0);
5069 5070 5071 5072
  return protocol->store(&tm);
}


5073
int Field_timestamp::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5074 5075 5076
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5077
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090
  {
    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;
}

5091

5092
void Field_timestamp::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5093 5094
{
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5095
  if (!table || !table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114
  {
    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
{
5115
  res.set_ascii(STRING_WITH_LEN("timestamp"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5116 5117 5118 5119 5120
}


void Field_timestamp::set_time()
{
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5121 5122
  THD *thd= table ? table->in_use : current_thd;
  long tmp= (long) thd->query_start();
5123
  set_notnull();
5124
  store_timestamp(tmp);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5125 5126 5127 5128 5129 5130 5131 5132 5133
}

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

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5134
int Field_time::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5135
{
5136
  MYSQL_TIME ltime;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5137
  long tmp;
5138 5139
  int error= 0;
  int warning;
5140

5141
  if (str_to_time(from, len, &ltime, &warning))
5142
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5143
    tmp=0L;
5144
    error= 2;
5145
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
5146
                         from, len, MYSQL_TIMESTAMP_TIME, 1);
5147
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5148 5149
  else
  {
5150
    if (warning & MYSQL_TIME_WARN_TRUNCATED)
5151 5152
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
5153
                           WARN_DATA_TRUNCATED,
5154
                           from, len, MYSQL_TIMESTAMP_TIME, 1);
5155 5156
      error= 1;
    }
5157
    if (warning & MYSQL_TIME_WARN_OUT_OF_RANGE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5158
    {
5159 5160
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                           ER_WARN_DATA_OUT_OF_RANGE,
5161
                           from, len, MYSQL_TIMESTAMP_TIME, !error);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5162
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5163
    }
5164 5165 5166
    if (ltime.month)
      ltime.day=0;
    tmp=(ltime.day*24L+ltime.hour)*10000L+(ltime.minute*100+ltime.second);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5167
  }
5168
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5169 5170
  if (ltime.neg)
    tmp= -tmp;
5171
  int3store(ptr,tmp);
5172
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5173 5174 5175
}


5176
int Field_time::store_time(MYSQL_TIME *ltime, timestamp_type time_type)
5177 5178 5179 5180 5181
{
  long tmp= ((ltime->month ? 0 : ltime->day * 24L) + ltime->hour) * 10000L +
            (ltime->minute * 100 + ltime->second);
  if (ltime->neg)
    tmp= -tmp;
holyfoot/hf@mysql.com/deer.(none)'s avatar
holyfoot/hf@mysql.com/deer.(none) committed
5182
  return Field_time::store((longlong) tmp, FALSE);
5183 5184 5185
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5186
int Field_time::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5187
{
5188
  ASSERT_COLUMN_MARKED_FOR_WRITE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5189
  long tmp;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5190
  int error= 0;
5191
  if (nr > (double)TIME_MAX_VALUE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5192
  {
5193
    tmp= TIME_MAX_VALUE;
5194
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
5195
                         ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5196
    error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5197
  }
5198
  else if (nr < (double)-TIME_MAX_VALUE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5199
  {
5200
    tmp= -TIME_MAX_VALUE;
5201
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
5202
                         ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5203
    error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5204 5205 5206 5207 5208 5209 5210 5211 5212
  }
  else
  {
    tmp=(long) floor(fabs(nr));			// Remove fractions
    if (nr < 0)
      tmp= -tmp;
    if (tmp % 100 > 59 || tmp/100 % 100 > 59)
    {
      tmp=0;
5213
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
5214 5215
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_TIME);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5216
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5217 5218 5219
    }
  }
  int3store(ptr,tmp);
5220
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5221 5222 5223
}


5224
int Field_time::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5225
{
5226
  ASSERT_COLUMN_MARKED_FOR_WRITE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5227
  long tmp;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5228
  int error= 0;
5229
  if (nr < (longlong) -TIME_MAX_VALUE && !unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5230
  {
5231
    tmp= -TIME_MAX_VALUE;
5232
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
5233 5234
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_TIME, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5235
    error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5236
  }
5237
  else if (nr > (longlong) TIME_MAX_VALUE || (nr < 0 && unsigned_val))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5238
  {
5239
    tmp= TIME_MAX_VALUE;
5240
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
5241 5242
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_TIME, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5243
    error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5244 5245 5246 5247 5248 5249 5250
  }
  else
  {
    tmp=(long) nr;
    if (tmp % 100 > 59 || tmp/100 % 100 > 59)
    {
      tmp=0;
5251
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
5252 5253
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_TIME, 1);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5254
      error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5255 5256 5257
    }
  }
  int3store(ptr,tmp);
5258
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5259 5260 5261 5262 5263
}


double Field_time::val_real(void)
{
5264
  ASSERT_COLUMN_MARKED_FOR_READ;
5265
  uint32 j= (uint32) uint3korr(ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5266 5267 5268 5269 5270
  return (double) j;
}

longlong Field_time::val_int(void)
{
5271
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5272 5273 5274
  return (longlong) sint3korr(ptr);
}

5275

5276 5277
/**
  @note
5278 5279 5280 5281
  This function is multi-byte safe as the result string is always of type
  my_charset_bin
*/

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5282 5283 5284
String *Field_time::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
5285
  ASSERT_COLUMN_MARKED_FOR_READ;
5286
  MYSQL_TIME ltime;
5287
  val_buffer->alloc(MAX_DATE_STRING_REP_LENGTH);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5288
  long tmp=(long) sint3korr(ptr);
5289
  ltime.neg= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5290 5291 5292
  if (tmp < 0)
  {
    tmp= -tmp;
5293 5294 5295 5296 5297 5298
    ltime.neg= 1;
  }
  ltime.day= (uint) 0;
  ltime.hour= (uint) (tmp/10000);
  ltime.minute= (uint) (tmp/100 % 100);
  ltime.second= (uint) (tmp % 100);
5299
  make_time((DATE_TIME_FORMAT*) 0, &ltime, val_buffer);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5300 5301 5302
  return val_buffer;
}

5303

5304 5305
/**
  @note
5306
  Normally we would not consider 'time' as a valid date, but we allow
monty@mysql.com's avatar
monty@mysql.com committed
5307 5308 5309 5310
  get_date() here to be able to do things like
  DATE_FORMAT(time, "%l.%i %p")
*/
 
5311
bool Field_time::get_date(MYSQL_TIME *ltime, uint fuzzydate)
5312
{
monty@mysql.com's avatar
monty@mysql.com committed
5313
  long tmp;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5314
  THD *thd= table ? table->in_use : current_thd;
5315
  if (!(fuzzydate & TIME_FUZZY_DATE))
monty@mysql.com's avatar
monty@mysql.com committed
5316
  {
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5317
    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
5318 5319
                        ER_WARN_DATA_OUT_OF_RANGE,
                        ER(ER_WARN_DATA_OUT_OF_RANGE), field_name,
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5320
                        thd->row_count);
monty@mysql.com's avatar
monty@mysql.com committed
5321 5322 5323
    return 1;
  }
  tmp=(long) sint3korr(ptr);
5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337
  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;
}

monty@mysql.com's avatar
monty@mysql.com committed
5338

5339
bool Field_time::get_time(MYSQL_TIME *ltime)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5340 5341 5342 5343 5344 5345 5346 5347
{
  long tmp=(long) sint3korr(ptr);
  ltime->neg=0;
  if (tmp < 0)
  {
    ltime->neg= 1;
    tmp=-tmp;
  }
5348
  ltime->year= ltime->month= ltime->day= 0;
5349
  ltime->hour=   (int) (tmp/10000);
5350
  tmp-=ltime->hour*10000;
5351 5352
  ltime->minute= (int) tmp/100;
  ltime->second= (int) tmp % 100;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5353
  ltime->second_part=0;
5354
  ltime->time_type= MYSQL_TIMESTAMP_TIME;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5355 5356 5357
  return 0;
}

5358 5359 5360

bool Field_time::send_binary(Protocol *protocol)
{
5361
  MYSQL_TIME tm;
5362
  Field_time::get_time(&tm);
5363 5364
  tm.day= tm.hour/24;				// Move hours to days
  tm.hour-= tm.day*24;
5365
  return protocol->store_time(&tm);
5366 5367 5368
}


5369
int Field_time::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5370
{
5371 5372 5373
  int32 a,b;
  a=(int32) sint3korr(a_ptr);
  b=(int32) sint3korr(b_ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5374 5375 5376
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

5377
void Field_time::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5378 5379 5380 5381 5382 5383 5384 5385
{
  to[0] = (uchar) (ptr[2] ^ 128);
  to[1] = ptr[1];
  to[2] = ptr[0];
}

void Field_time::sql_type(String &res) const
{
5386
  res.set_ascii(STRING_WITH_LEN("time"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5387 5388 5389 5390 5391 5392 5393 5394
}

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

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5395
int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5396
{
5397
  ASSERT_COLUMN_MARKED_FOR_WRITE;
5398
  char *end;
5399
  int error;
5400
  longlong nr= cs->cset->strntoull10rnd(cs, from, len, 0, &end, &error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5401

5402
  if (nr < 0 || (nr >= 100 && nr <= 1900) || nr > 2155 ||
5403
      error == MY_ERRNO_ERANGE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5404 5405
  {
    *ptr=0;
5406
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
5407
    return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5408
  }
5409 5410 5411 5412 5413 5414 5415 5416
  if (table->in_use->count_cuted_fields && 
      (error= check_int(cs, from, len, end, error)))
  {
    if (error == 1)  /* empty or incorrect string */
    {
      *ptr= 0;
      return 1;
    }
5417
    error= 1;
5418
  }
5419

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5420 5421 5422 5423 5424 5425 5426
  if (nr != 0 || len != 4)
  {
    if (nr < YY_PART_YEAR)
      nr+=100;					// 2000 - 2069
    else if (nr > 1900)
      nr-= 1900;
  }
monty@mysql.com's avatar
monty@mysql.com committed
5427
  *ptr= (char) (uchar) nr;
5428
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5429 5430
}

monty@mysql.com's avatar
monty@mysql.com committed
5431

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5432
int Field_year::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5433 5434
{
  if (nr < 0.0 || nr >= 2155.0)
5435
  {
5436
    (void) Field_year::store((longlong) -1, FALSE);
5437 5438
    return 1;
  }
5439
  return Field_year::store((longlong) nr, FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5440 5441
}

5442 5443

int Field_year::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5444
{
5445
  ASSERT_COLUMN_MARKED_FOR_WRITE;
5446
  if (nr < 0 || (nr >= 100 && nr <= 1900) || nr > 2155)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5447
  {
5448
    *ptr= 0;
5449
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
5450
    return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5451 5452 5453 5454 5455 5456 5457 5458
  }
  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;
  }
monty@mysql.com's avatar
monty@mysql.com committed
5459
  *ptr= (char) (uchar) nr;
5460
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5461 5462
}

5463

5464 5465
bool Field_year::send_binary(Protocol *protocol)
{
5466
  ASSERT_COLUMN_MARKED_FOR_READ;
5467
  ulonglong tmp= Field_year::val_int();
5468
  return protocol->store_short(tmp);
5469
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5470

5471

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5472 5473 5474 5475 5476
double Field_year::val_real(void)
{
  return (double) Field_year::val_int();
}

5477

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5478 5479
longlong Field_year::val_int(void)
{
5480
  ASSERT_COLUMN_MARKED_FOR_READ;
5481
  int tmp= (int) ptr[0];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5482 5483 5484 5485 5486 5487 5488
  if (field_length != 4)
    tmp%=100;					// Return last 2 char
  else if (tmp)
    tmp+=1900;
  return (longlong) tmp;
}

5489

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5490 5491 5492 5493 5494 5495 5496 5497 5498 5499
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;
}

5500

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5501 5502
void Field_year::sql_type(String &res) const
{
5503
  CHARSET_INFO *cs=res.charset();
5504
  res.length(cs->cset->snprintf(cs,(char*)res.ptr(),res.alloced_length(),
5505
			  "year(%d)",(int) field_length));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5506 5507 5508 5509 5510 5511 5512 5513 5514 5515
}


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

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5516
int Field_date::store(const char *from, uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5517
{
5518
  ASSERT_COLUMN_MARKED_FOR_WRITE;
5519
  MYSQL_TIME l_time;
5520
  uint32 tmp;
5521
  int error;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5522
  THD *thd= table ? table->in_use : current_thd;
5523

5524
  if (str_to_datetime(from, len, &l_time, TIME_FUZZY_DATE |
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5525
                      (thd->variables.sql_mode &
5526 5527 5528
                       (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                        MODE_INVALID_DATES)),
                      &error) <= MYSQL_TIMESTAMP_ERROR)
5529
  {
5530
    tmp= 0;
5531
    error= 2;
5532
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5533
  else
5534
    tmp=(uint32) l_time.year*10000L + (uint32) (l_time.month*100+l_time.day);
5535 5536

  if (error)
5537
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
5538
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
5539

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5540
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5541
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5542 5543 5544 5545 5546 5547
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
5548
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5549 5550 5551
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5552
int Field_date::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5553
{
5554
  longlong tmp;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5555
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5556 5557 5558 5559
  if (nr >= 19000000000000.0 && nr <= 99991231235959.0)
    nr=floor(nr/1000000.0);			// Timestamp to date
  if (nr < 0.0 || nr > 99991231.0)
  {
5560
    tmp= LL(0);
5561 5562
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                         ER_WARN_DATA_OUT_OF_RANGE,
5563
                         nr, MYSQL_TIMESTAMP_DATE);
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5564
    error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5565 5566
  }
  else
5567
    tmp= (longlong) rint(nr);
5568

5569
  return Field_date::store(tmp, TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5570 5571 5572
}


5573
int Field_date::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5574
{
5575
  ASSERT_COLUMN_MARKED_FOR_WRITE;
5576
  MYSQL_TIME not_used;
5577 5578
  int error;
  longlong initial_nr= nr;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5579
  THD *thd= table ? table->in_use : current_thd;
5580 5581

  nr= number_to_datetime(nr, &not_used, (TIME_FUZZY_DATE |
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5582
                                         (thd->variables.sql_mode &
5583 5584 5585 5586
                                          (MODE_NO_ZERO_IN_DATE |
                                           MODE_NO_ZERO_DATE |
                                           MODE_INVALID_DATES))), &error);

5587
  if (nr == LL(-1))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5588
  {
5589 5590
    nr= 0;
    error= 2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5591
  }
5592

5593
  if (nr >= 19000000000000.0 && nr <= 99991231235959.0)
5594
    nr= (longlong) floor(nr/1000000.0);         // Timestamp to date
5595

5596 5597 5598 5599 5600
  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);
5601

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5602
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5603
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5604
  {
5605
    int4store(ptr, nr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5606 5607 5608
  }
  else
#endif
5609
    longstore(ptr, nr);
5610
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5611 5612 5613
}


5614 5615 5616
bool Field_date::send_binary(Protocol *protocol)
{
  longlong tmp= Field_date::val_int();
5617
  MYSQL_TIME tm;
5618 5619 5620 5621 5622 5623
  tm.year= (uint32) tmp/10000L % 10000;
  tm.month= (uint32) tmp/100 % 100;
  tm.day= (uint32) tmp % 100;
  return protocol->store_date(&tm);
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5624 5625 5626

double Field_date::val_real(void)
{
5627
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5628 5629
  int32 j;
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5630
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5631 5632 5633 5634 5635 5636 5637
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return (double) (uint32) j;
}

5638

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5639 5640
longlong Field_date::val_int(void)
{
5641
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5642 5643
  int32 j;
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5644
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5645 5646 5647 5648 5649 5650 5651
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return (longlong) (uint32) j;
}

5652

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5653 5654 5655
String *Field_date::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
5656
  ASSERT_COLUMN_MARKED_FOR_READ;
5657
  MYSQL_TIME ltime;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5658 5659 5660
  val_buffer->alloc(field_length);
  int32 tmp;
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5661
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5662 5663 5664 5665
    tmp=sint4korr(ptr);
  else
#endif
    longget(tmp,ptr);
5666 5667 5668 5669
  ltime.neg= 0;
  ltime.year= (int) ((uint32) tmp/10000L % 10000);
  ltime.month= (int) ((uint32) tmp/100 % 100);
  ltime.day= (int) ((uint32) tmp % 100);
5670
  make_date((DATE_TIME_FORMAT *) 0, &ltime, val_buffer);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5671 5672 5673
  return val_buffer;
}

5674

5675 5676 5677 5678 5679 5680 5681
bool Field_date::get_time(MYSQL_TIME *ltime)
{
  bzero((char *)ltime, sizeof(MYSQL_TIME));
  return 0;
}


5682
int Field_date::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5683 5684 5685
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5686
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700
  {
    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;
}


5701
void Field_date::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5702 5703
{
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5704
  if (!table || !table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722
  {
    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
{
5723
  res.set_ascii(STRING_WITH_LEN("date"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5724 5725
}

5726

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5727 5728 5729 5730 5731 5732
/****************************************************************************
** The new date type
** This is identical to the old date type, but stored on 3 bytes instead of 4
** In number context: YYYYMMDD
****************************************************************************/

5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746
/*
  Store string into a date field

  SYNOPSIS
    Field_newdate::store()
    from                Date string
    len                 Length of date field
    cs                  Character set (not used)

  RETURN
    0  ok
    1  Value was cut during conversion
    2  Wrong date string
    3  Datetime value that was cut (warning level NOTE)
5747 5748 5749
       This is used by opt_range.cc:get_mm_leaf(). Note that there is a
       nearly-identical class Field_date doesn't ever return 3 from its
       store function.
5750 5751
*/

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5752
int Field_newdate::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5753
{
5754
  ASSERT_COLUMN_MARKED_FOR_WRITE;
5755 5756
  long tmp;
  MYSQL_TIME l_time;
5757
  int error;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5758
  THD *thd= table ? table->in_use : current_thd;
5759 5760 5761 5762 5763 5764 5765 5766
  enum enum_mysql_timestamp_type ret;
  if ((ret= str_to_datetime(from, len, &l_time,
                            (TIME_FUZZY_DATE |
                             (thd->variables.sql_mode &
                              (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                               MODE_INVALID_DATES))),
                            &error)) <= MYSQL_TIMESTAMP_ERROR)
  {
5767
    tmp= 0;
5768
    error= 2;
5769
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5770
  else
5771
  {
5772
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
5773
    if (!error && (ret != MYSQL_TIMESTAMP_DATE) &&
5774
        (l_time.hour || l_time.minute || l_time.second || l_time.second_part))
5775
      error= 3;                                 // Datetime was cut (note)
5776
  }
5777 5778

  if (error)
5779 5780 5781
    set_datetime_warning(error == 3 ? MYSQL_ERROR::WARN_LEVEL_NOTE :
                         MYSQL_ERROR::WARN_LEVEL_WARN,
                         WARN_DATA_TRUNCATED,
5782
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
5783

5784
  int3store(ptr, tmp);
5785
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5786 5787
}

5788

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5789
int Field_newdate::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5790 5791
{
  if (nr < 0.0 || nr > 99991231235959.0)
5792
  {
5793
    int3store(ptr,(int32) 0);
5794
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
5795
                         WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATE);
5796 5797
    return 1;
  }
5798
  return Field_newdate::store((longlong) rint(nr), FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5799 5800 5801
}


5802
int Field_newdate::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5803
{
5804
  ASSERT_COLUMN_MARKED_FOR_WRITE;
5805
  MYSQL_TIME l_time;
5806
  longlong tmp;
5807
  int error;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5808
  THD *thd= table ? table->in_use : current_thd;
5809 5810
  if (number_to_datetime(nr, &l_time,
                         (TIME_FUZZY_DATE |
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5811
                          (thd->variables.sql_mode &
5812 5813 5814
                           (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                            MODE_INVALID_DATES))),
                         &error) == LL(-1))
5815 5816 5817
  {
    tmp= 0L;
    error= 2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5818 5819
  }
  else
5820
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
5821

5822 5823 5824 5825
  if (!error && l_time.time_type != MYSQL_TIMESTAMP_DATE &&
      (l_time.hour || l_time.minute || l_time.second || l_time.second_part))
    error= 3;

5826
  if (error)
5827 5828 5829 5830 5831
    set_datetime_warning(error == 3 ? MYSQL_ERROR::WARN_LEVEL_NOTE :
                         MYSQL_ERROR::WARN_LEVEL_WARN,
                         error == 2 ? 
                         ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED,
                         nr,MYSQL_TIMESTAMP_DATE, 1);
5832 5833

  int3store(ptr,tmp);
5834
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5835 5836
}

5837

5838
int Field_newdate::store_time(MYSQL_TIME *ltime,timestamp_type time_type)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5839
{
5840
  ASSERT_COLUMN_MARKED_FOR_WRITE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5841
  long tmp;
5842
  int error= 0;
5843 5844
  if (time_type == MYSQL_TIMESTAMP_DATE ||
      time_type == MYSQL_TIMESTAMP_DATETIME)
5845
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5846
    tmp=ltime->year*16*32+ltime->month*32+ltime->day;
5847 5848 5849 5850 5851
    if (check_date(ltime, tmp != 0,
                   (TIME_FUZZY_DATE |
                    (current_thd->variables.sql_mode &
                     (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                      MODE_INVALID_DATES))), &error))
5852
    {
5853
      char buff[MAX_DATE_STRING_REP_LENGTH];
5854
      String str(buff, sizeof(buff), &my_charset_latin1);
5855
      tmp= 0;
5856 5857 5858 5859
      make_date((DATE_TIME_FORMAT *) 0, ltime, &str);
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
                           str.ptr(), str.length(), MYSQL_TIMESTAMP_DATE, 1);
    }
5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870
    if (!error && ltime->time_type != MYSQL_TIMESTAMP_DATE &&
        (ltime->hour || ltime->minute || ltime->second || ltime->second_part))
    {
      char buff[MAX_DATE_STRING_REP_LENGTH];
      String str(buff, sizeof(buff), &my_charset_latin1);
      make_datetime((DATE_TIME_FORMAT *) 0, ltime, &str);
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_NOTE,
                           WARN_DATA_TRUNCATED,
                           str.ptr(), str.length(), MYSQL_TIMESTAMP_DATE, 1);
      error= 3;
    }
5871
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5872 5873 5874
  else
  {
    tmp=0;
5875
    error= 1;
5876
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5877 5878
  }
  int3store(ptr,tmp);
5879
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5880 5881
}

5882

5883 5884
bool Field_newdate::send_binary(Protocol *protocol)
{
5885
  MYSQL_TIME tm;
5886 5887 5888
  Field_newdate::get_date(&tm,0);
  return protocol->store_date(&tm);
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5889

5890

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5891 5892
double Field_newdate::val_real(void)
{
5893
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5894 5895 5896
  return (double) Field_newdate::val_int();
}

5897

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5898 5899
longlong Field_newdate::val_int(void)
{
5900
  ASSERT_COLUMN_MARKED_FOR_READ;
5901
  ulong j= uint3korr(ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5902 5903 5904 5905
  j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
  return (longlong) j;
}

5906

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5907 5908 5909
String *Field_newdate::val_str(String *val_buffer,
			       String *val_ptr __attribute__((unused)))
{
5910
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5911 5912
  val_buffer->alloc(field_length);
  val_buffer->length(field_length);
5913
  uint32 tmp=(uint32) uint3korr(ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5914 5915 5916 5917
  int part;
  char *pos=(char*) val_buffer->ptr()+10;

  /* Open coded to get more speed */
5918
  *pos--=0;					// End NULL
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5919
  part=(int) (tmp & 31);
5920 5921 5922
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5923
  part=(int) (tmp >> 5 & 15);
5924 5925 5926
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5927
  part=(int) (tmp >> 9);
5928 5929 5930 5931
  *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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5932 5933 5934
  return val_buffer;
}

5935

5936
bool Field_newdate::get_date(MYSQL_TIME *ltime,uint fuzzydate)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5937
{
5938
  uint32 tmp=(uint32) uint3korr(ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5939 5940 5941
  ltime->day=   tmp & 31;
  ltime->month= (tmp >> 5) & 15;
  ltime->year=  (tmp >> 9);
5942
  ltime->time_type= MYSQL_TIMESTAMP_DATE;
5943
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
5944 5945
  return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
          1 : 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5946 5947
}

5948

5949
bool Field_newdate::get_time(MYSQL_TIME *ltime)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5950
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
5951
  return Field_newdate::get_date(ltime,0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5952 5953
}

5954

5955
int Field_newdate::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5956
{
5957 5958 5959
  uint32 a,b;
  a=(uint32) uint3korr(a_ptr);
  b=(uint32) uint3korr(b_ptr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5960 5961 5962
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

5963

5964
void Field_newdate::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5965 5966 5967 5968 5969 5970
{
  to[0] = ptr[2];
  to[1] = ptr[1];
  to[2] = ptr[0];
}

5971

bk@work.mysql.com's avatar
bk@work.mysql.com committed
5972 5973
void Field_newdate::sql_type(String &res) const
{
5974
  res.set_ascii(STRING_WITH_LEN("date"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5975 5976 5977 5978 5979 5980 5981 5982 5983 5984
}


/****************************************************************************
** 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.
****************************************************************************/

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
5985
int Field_datetime::store(const char *from,uint len,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5986
{
5987
  ASSERT_COLUMN_MARKED_FOR_WRITE;
5988
  MYSQL_TIME time_tmp;
5989 5990
  int error;
  ulonglong tmp= 0;
5991
  enum enum_mysql_timestamp_type func_res;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5992
  THD *thd= table ? table->in_use : current_thd;
5993

5994 5995
  func_res= str_to_datetime(from, len, &time_tmp,
                            (TIME_FUZZY_DATE |
evgen@moonbone.local's avatar
evgen@moonbone.local committed
5996
                             (thd->variables.sql_mode &
5997 5998 5999 6000
                              (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                               MODE_INVALID_DATES))),
                            &error);
  if ((int) func_res > (int) MYSQL_TIMESTAMP_ERROR)
6001
    tmp= TIME_to_ulonglong_datetime(&time_tmp);
6002 6003 6004
  else
    error= 1;                                 // Fix if invalid zero date

6005
  if (error)
6006
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
6007
                         ER_WARN_DATA_OUT_OF_RANGE,
6008
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
6009

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6010
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
6011
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6012 6013 6014 6015 6016 6017
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
6018
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6019 6020 6021
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
6022
int Field_datetime::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6023
{
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
6024
  int error= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6025 6026
  if (nr < 0.0 || nr > 99991231235959.0)
  {
6027 6028
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE,
6029
                         nr, MYSQL_TIMESTAMP_DATETIME);
6030
    nr= 0.0;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
6031
    error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6032
  }
6033
  error|= Field_datetime::store((longlong) rint(nr), FALSE);
6034
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6035 6036 6037
}


6038
int Field_datetime::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6039
{
6040
  ASSERT_COLUMN_MARKED_FOR_WRITE;
6041
  MYSQL_TIME not_used;
6042 6043
  int error;
  longlong initial_nr= nr;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
6044
  THD *thd= table ? table->in_use : current_thd;
6045

6046
  nr= number_to_datetime(nr, &not_used, (TIME_FUZZY_DATE |
evgen@moonbone.local's avatar
evgen@moonbone.local committed
6047
                                         (thd->variables.sql_mode &
6048 6049 6050 6051
                                          (MODE_NO_ZERO_IN_DATE |
                                           MODE_NO_ZERO_DATE |
                                           MODE_INVALID_DATES))), &error);

6052
  if (nr == LL(-1))
6053
  {
6054 6055
    nr= 0;
    error= 2;
6056
  }
6057

6058 6059 6060 6061 6062 6063
  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);

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6064
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
6065
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6066 6067 6068 6069 6070 6071
  {
    int8store(ptr,nr);
  }
  else
#endif
    longlongstore(ptr,nr);
6072
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6073 6074
}

monty@mysql.com's avatar
monty@mysql.com committed
6075

6076
int Field_datetime::store_time(MYSQL_TIME *ltime,timestamp_type time_type)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6077
{
6078
  ASSERT_COLUMN_MARKED_FOR_WRITE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6079
  longlong tmp;
6080
  int error= 0;
6081 6082 6083 6084
  /*
    We don't perform range checking here since values stored in TIME
    structure always fit into DATETIME range.
  */
6085 6086
  if (time_type == MYSQL_TIMESTAMP_DATE ||
      time_type == MYSQL_TIMESTAMP_DATETIME)
6087
  {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6088 6089
    tmp=((ltime->year*10000L+ltime->month*100+ltime->day)*LL(1000000)+
	 (ltime->hour*10000L+ltime->minute*100+ltime->second));
6090 6091 6092 6093 6094
    if (check_date(ltime, tmp != 0,
                   (TIME_FUZZY_DATE |
                    (current_thd->variables.sql_mode &
                     (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                      MODE_INVALID_DATES))), &error))
6095
    {
6096
      char buff[MAX_DATE_STRING_REP_LENGTH];
6097
      String str(buff, sizeof(buff), &my_charset_latin1);
6098
      tmp= 0;
6099 6100 6101 6102 6103
      make_datetime((DATE_TIME_FORMAT *) 0, ltime, &str);
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
                           str.ptr(), str.length(), MYSQL_TIMESTAMP_DATETIME,1);
    }
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6104 6105 6106
  else
  {
    tmp=0;
6107
    error= 1;
6108
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6109 6110
  }
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
6111
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6112 6113 6114 6115 6116 6117
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
6118
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6119 6120
}

6121 6122
bool Field_datetime::send_binary(Protocol *protocol)
{
6123
  MYSQL_TIME tm;
6124
  Field_datetime::get_date(&tm, TIME_FUZZY_DATE);
6125 6126 6127
  return protocol->store(&tm);
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6128 6129 6130 6131 6132 6133 6134 6135

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

longlong Field_datetime::val_int(void)
{
6136
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6137 6138
  longlong j;
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
6139
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150
    j=sint8korr(ptr);
  else
#endif
    longlongget(j,ptr);
  return j;
}


String *Field_datetime::val_str(String *val_buffer,
				String *val_ptr __attribute__((unused)))
{
6151
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6152 6153 6154 6155 6156 6157 6158 6159
  val_buffer->alloc(field_length);
  val_buffer->length(field_length);
  ulonglong tmp;
  long part1,part2;
  char *pos;
  int part3;

#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
6160
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6161 6162 6163 6164 6165 6166
    tmp=sint8korr(ptr);
  else
#endif
    longlongget(tmp,ptr);

  /*
6167
    Avoid problem with slow longlong arithmetic and sprintf
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6168 6169 6170 6171 6172
  */

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

6173
  pos=(char*) val_buffer->ptr() + MAX_DATETIME_WIDTH;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6174
  *pos--=0;
6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193
  *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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6194 6195 6196
  return val_buffer;
}

6197
bool Field_datetime::get_date(MYSQL_TIME *ltime, uint fuzzydate)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6198 6199
{
  longlong tmp=Field_datetime::val_int();
6200 6201 6202
  uint32 part1,part2;
  part1=(uint32) (tmp/LL(1000000));
  part2=(uint32) (tmp - (ulonglong) part1*LL(1000000));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6203

6204
  ltime->time_type=	MYSQL_TIMESTAMP_DATETIME;
6205 6206 6207 6208 6209 6210 6211 6212
  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);
6213
  return (!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ? 1 : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6214 6215
}

6216
bool Field_datetime::get_time(MYSQL_TIME *ltime)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6217
{
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6218
  return Field_datetime::get_date(ltime,0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6219 6220
}

6221
int Field_datetime::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6222 6223 6224
{
  longlong a,b;
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
6225
  if (table && table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239
  {
    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;
}

6240
void Field_datetime::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6241 6242
{
#ifdef WORDS_BIGENDIAN
evgen@moonbone.local's avatar
evgen@moonbone.local committed
6243
  if (!table || !table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270
  {
    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
{
6271
  res.set_ascii(STRING_WITH_LEN("datetime"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6272 6273 6274 6275 6276 6277 6278
}

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

6279 6280 6281 6282 6283 6284 6285 6286 6287 6288
/*
  Report "not well formed" or "cannot convert" error
  after storing a character string info a field.

  SYNOPSIS
    check_string_copy_error()
    field                    - Field
    well_formed_error_pos    - where not well formed data was first met
    cannot_convert_error_pos - where a not-convertable character was first met
    end                      - end of the string
6289
    cs                       - character set of the string
6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308

  NOTES
    As of version 5.0 both cases return the same error:
  
      "Invalid string value: 'xxx' for column 't' at row 1"
  
  Future versions will possibly introduce a new error message:

      "Cannot convert character string: 'xxx' for column 't' at row 1"

  RETURN
    FALSE - If errors didn't happen
    TRUE  - If an error happened
*/

static bool
check_string_copy_error(Field_str *field,
                        const char *well_formed_error_pos,
                        const char *cannot_convert_error_pos,
6309 6310
                        const char *end,
                        CHARSET_INFO *cs)
6311
{
6312 6313
  const char *pos;
  char tmp[32];
6314 6315 6316 6317 6318
  
  if (!(pos= well_formed_error_pos) &&
      !(pos= cannot_convert_error_pos))
    return FALSE;

6319
  convert_to_printable(tmp, sizeof(tmp), pos, (end - pos), cs, 6);
6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333

  push_warning_printf(field->table->in_use, 
                      field->table->in_use->abort_on_warning ?
                      MYSQL_ERROR::WARN_LEVEL_ERROR :
                      MYSQL_ERROR::WARN_LEVEL_WARN,
                      ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, 
                      ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
                      "string", tmp, field->field_name,
                      (ulong) field->table->in_use->row_count);
  return TRUE;
}


/*
gshchepa/uchum@host.loc's avatar
gshchepa/uchum@host.loc committed
6334
  Check if we lost any important data and send a truncation error/warning
6335 6336

  SYNOPSIS
gshchepa/uchum@host.loc's avatar
gshchepa/uchum@host.loc committed
6337 6338 6339
    Field_longstr::report_if_important_data()
    ptr                      - Truncated rest of string
    end                      - End of truncated string
6340
    count_spaces             - Treat traling spaces as important data
6341

gshchepa/uchum@host.loc's avatar
gshchepa/uchum@host.loc committed
6342 6343 6344 6345 6346 6347 6348 6349
  RETURN VALUES
    0   - None was truncated (or we don't count cut fields)
    2   - Some bytes was truncated

  NOTE
    Check if we lost any important data (anything in a binary string,
    or any non-space in others). If only trailing spaces was lost,
    send a truncation note, otherwise send a truncation error.
6350
    Silently ignore traling spaces if the count_space parameter is FALSE.
6351 6352
*/

gshchepa/uchum@host.loc's avatar
gshchepa/uchum@host.loc committed
6353
int
6354 6355
Field_longstr::report_if_important_data(const char *ptr, const char *end,
                                        bool count_spaces)
6356
{
gshchepa/uchum@host.loc's avatar
gshchepa/uchum@host.loc committed
6357 6358 6359 6360 6361 6362 6363 6364
  if ((ptr < end) && table->in_use->count_cuted_fields)
  {
    if (test_if_important_data(field_charset, ptr, end))
    {
      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);
6365
      return 2;
gshchepa/uchum@host.loc's avatar
gshchepa/uchum@host.loc committed
6366
    }
6367 6368
    else if (count_spaces)
    { /* If we lost only spaces then produce a NOTE, not a WARNING */
gshchepa/uchum@host.loc's avatar
gshchepa/uchum@host.loc committed
6369
      set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
6370 6371
      return 2;
    }
gshchepa/uchum@host.loc's avatar
gshchepa/uchum@host.loc committed
6372 6373
  }
  return 0;
6374 6375 6376
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
6377 6378
	/* Copy a string and fill with space */

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
6379
int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6380
{
6381
  ASSERT_COLUMN_MARKED_FOR_WRITE;
bar@bar.intranet.mysql.r18.ru's avatar
bar@bar.intranet.mysql.r18.ru committed
6382
  uint copy_length;
6383 6384 6385
  const char *well_formed_error_pos;
  const char *cannot_convert_error_pos;
  const char *from_end_pos;
6386

6387 6388
  /* See the comment for Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
6389

6390
  copy_length= well_formed_copy_nchars(field_charset,
6391
                                       (char*) ptr, field_length,
6392 6393 6394 6395 6396
                                       cs, from, length,
                                       field_length / field_charset->mbmaxlen,
                                       &well_formed_error_pos,
                                       &cannot_convert_error_pos,
                                       &from_end_pos);
6397 6398 6399

  /* Append spaces if the string was shorter than the field. */
  if (copy_length < field_length)
6400
    field_charset->cset->fill(field_charset,(char*) ptr+copy_length,
6401
                              field_length-copy_length,
6402
                              field_charset->pad_char);
6403

6404
  if (check_string_copy_error(this, well_formed_error_pos,
6405
                              cannot_convert_error_pos, from + length, cs))
6406 6407
    return 2;

6408
  return report_if_important_data(from_end_pos, from + length, FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6409 6410 6411
}


6412
/**
6413 6414
  Store double value in Field_string or Field_varstring.

6415
  Pretty prints double number into field_length characters buffer.
6416

6417
  @param nr            number
6418 6419
*/

serg@serg.mylan's avatar
serg@serg.mylan committed
6420
int Field_str::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6421
{
6422
  ASSERT_COLUMN_MARKED_FOR_WRITE;
6423
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
6424
  uint length;
6425
  uint local_char_length= field_length / charset()->mbmaxlen;
6426
  double anr= fabs(nr);
6427
  bool fractional= (anr != floor(anr));
6428
  int neg= (nr < 0.0) ? 1 : 0;
6429 6430 6431 6432 6433 6434 6435 6436
  uint max_length;
  int exp;
  uint digits;
  uint i;

  /* Calculate the exponent from the 'e'-format conversion */
  if (anr < 1.0 && anr > 0)
  {
6437 6438 6439
    for (exp= 0; anr < 1e-100; exp-= 100, anr*= 1e100) ;
    for (; anr < 1e-10; exp-= 10, anr*= 1e10) ;
    for (i= 1; anr < 1 / log_10[i]; exp--, i++) ;
6440 6441 6442 6443
    exp--;
  }
  else
  {
6444 6445 6446
    for (exp= 0; anr > 1e100; exp+= 100, anr/= 1e100) ;
    for (; anr > 1e10; exp+= 10, anr/= 1e10) ;
    for (i= 1; anr > log_10[i]; exp++, i++) ;
6447 6448 6449 6450 6451 6452 6453 6454 6455
  }

  max_length= local_char_length - neg;

  /*
    Since in sprintf("%g") precision means the number of significant digits,
    calculate the maximum number of significant digits if the 'f'-format
    would be used (+1 for decimal point if the number has a fractional part).
  */
6456
  digits= max(1, (int) max_length - fractional);
6457 6458 6459 6460 6461
  /*
    If the exponent is negative, decrease digits by the number of leading zeros
    after the decimal point that do not count as significant digits.
  */
  if (exp < 0)
6462
    digits= max(1, (int) digits + exp);
6463 6464 6465 6466 6467 6468 6469
  /*
    'e'-format is used only if the exponent is less than -4 or greater than or
    equal to the precision. In this case we need to adjust the number of
    significant digits to take "e+NN" + decimal point into account (hence -5).
    We also have to reserve one additional character if abs(exp) >= 100.
  */
  if (exp >= (int) digits || exp < -4)
6470
    digits= max(1, (int) (max_length - 5 - (exp >= 100 || exp <= -100)));
6471 6472 6473

  /* Limit precision to DBL_DIG to avoid garbage past significant digits */
  set_if_smaller(digits, DBL_DIG);
6474
  
6475
  length= (uint) my_sprintf(buff, (buff, "%-.*g", digits, nr));
6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492

#ifdef __WIN__
  /*
    Windows always zero-pads the exponent to 3 digits, we want to remove the
    leading 0 to match the sprintf() output on other platforms.
  */
  if ((exp >= (int) digits || exp < -4) && exp > -100 && exp < 100)
  {
    DBUG_ASSERT(length >= 6); /* 1e+NNN */
    uint tmp= length - 3;
    buff[tmp]= buff[tmp + 1];
    tmp++;
    buff[tmp]= buff[tmp + 1];
    length--;
  }
#endif
  
6493 6494 6495 6496 6497
  /*
    +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)
6498
    the test for local_char_length < 5 is for extreme cases,
6499
    like inserting 500.0 in char(1)
6500
  */
6501
  DBUG_ASSERT(local_char_length < 5 || length <= local_char_length+1);
6502
  return store(buff, length, charset());
6503 6504
}

monty@mysql.com's avatar
monty@mysql.com committed
6505

6506
uint Field::is_equal(Create_field *new_field)
6507
{
6508
  return (new_field->sql_type == real_type());
6509 6510 6511
}


6512
uint Field_str::is_equal(Create_field *new_field)
6513
{
6514
  if (field_flags_are_binary() != new_field->field_flags_are_binary())
6515
    return 0;
6516

6517
  return ((new_field->sql_type == real_type()) &&
6518
	  new_field->charset == field_charset &&
6519
	  new_field->length == max_display_length());
6520 6521 6522
}


6523
int Field_string::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6524
{
6525 6526 6527
  char buff[64];
  int  l;
  CHARSET_INFO *cs=charset();
6528 6529
  l= (cs->cset->longlong10_to_str)(cs,buff,sizeof(buff),
                                   unsigned_val ? 10 : -10, nr);
6530
  return Field_string::store(buff,(uint)l,cs);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6531 6532
}

6533

6534 6535
int Field_longstr::store_decimal(const my_decimal *d)
{
6536 6537
  char buff[DECIMAL_MAX_STR_LENGTH+1];
  String str(buff, sizeof(buff), &my_charset_bin);
6538
  my_decimal2string(E_DEC_FATAL_ERROR, d, 0, 0, 0, &str);
6539
  return store(str.ptr(), str.length(), str.charset());
6540
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6541

6542 6543 6544 6545 6546
uint32 Field_longstr::max_data_length() const
{
  return field_length + (field_length > 255 ? 2 : 1);
}

6547

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6548 6549
double Field_string::val_real(void)
{
6550
  ASSERT_COLUMN_MARKED_FOR_READ;
6551 6552
  int error;
  char *end;
6553
  CHARSET_INFO *cs= charset();
6554 6555
  double result;
  
6556
  result=  my_strntod(cs,(char*) ptr,field_length,&end,&error);
6557
  if (!table->in_use->no_errors &&
6558 6559 6560
      (error || (field_length != (uint32)(end - (char*) ptr) && 
                 !check_if_only_end_space(cs, end,
                                          (char*) ptr + field_length))))
6561 6562 6563
  {
    char buf[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
    String tmp(buf, sizeof(buf), cs);
6564
    tmp.copy((char*) ptr, field_length, cs);
6565 6566 6567 6568 6569 6570
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE, 
                        ER(ER_TRUNCATED_WRONG_VALUE),
                        "DOUBLE", tmp.c_ptr());
  }
  return result;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6571 6572 6573 6574 6575
}


longlong Field_string::val_int(void)
{
6576
  ASSERT_COLUMN_MARKED_FOR_READ;
6577 6578 6579 6580 6581
  int error;
  char *end;
  CHARSET_INFO *cs= charset();
  longlong result;

6582
  result= my_strntoll(cs, (char*) ptr,field_length,10,&end,&error);
6583
  if (!table->in_use->no_errors &&
6584 6585 6586
      (error || (field_length != (uint32)(end - (char*) ptr) && 
                 !check_if_only_end_space(cs, end,
                                          (char*) ptr + field_length))))
6587 6588 6589
  {
    char buf[LONGLONG_TO_STRING_CONVERSION_BUFFER_SIZE];
    String tmp(buf, sizeof(buf), cs);
6590
    tmp.copy((char*) ptr, field_length, cs);
6591 6592 6593 6594 6595 6596
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE, 
                        ER(ER_TRUNCATED_WRONG_VALUE),
                        "INTEGER", tmp.c_ptr());
  }
  return result;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6597 6598 6599 6600 6601 6602
}


String *Field_string::val_str(String *val_buffer __attribute__((unused)),
			      String *val_ptr)
{
6603
  ASSERT_COLUMN_MARKED_FOR_READ;
6604 6605
  /* See the comment for Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
6606 6607 6608
  uint length;
  if (table->in_use->variables.sql_mode &
      MODE_PAD_CHAR_TO_FULL_LENGTH)
6609 6610
    length= my_charpos(field_charset, ptr, ptr + field_length,
                       field_length / field_charset->mbmaxlen);
6611
  else
6612 6613
    length= field_charset->cset->lengthsp(field_charset, (const char*) ptr,
                                          field_length);
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
6614
  val_ptr->set((const char*) ptr, length, field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6615 6616 6617 6618
  return val_ptr;
}


6619 6620
my_decimal *Field_string::val_decimal(my_decimal *decimal_value)
{
6621
  ASSERT_COLUMN_MARKED_FOR_READ;
6622 6623
  int err= str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr, field_length,
                          charset(), decimal_value);
6624 6625 6626 6627 6628
  if (!table->in_use->no_errors && err)
  {
    char buf[DECIMAL_TO_STRING_CONVERSION_BUFFER_SIZE];
    CHARSET_INFO *cs= charset();
    String tmp(buf, sizeof(buf), cs);
6629
    tmp.copy((char*) ptr, field_length, cs);
6630 6631 6632 6633 6634 6635
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE, 
                        ER(ER_TRUNCATED_WRONG_VALUE),
                        "DECIMAL", tmp.c_ptr());
  }

6636 6637 6638 6639
  return decimal_value;
}


6640 6641 6642 6643
struct Check_field_param {
  Field *field;
};

6644
#ifdef HAVE_REPLICATION
6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655
static bool
check_field_for_37426(const void *param_arg)
{
  Check_field_param *param= (Check_field_param*) param_arg;
  DBUG_ASSERT(param->field->real_type() == MYSQL_TYPE_STRING);
  DBUG_PRINT("debug", ("Field %s - type: %d, size: %d",
                       param->field->field_name,
                       param->field->real_type(),
                       param->field->row_pack_length()));
  return param->field->row_pack_length() > 255;
}
6656
#endif
6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670

int Field_string::compatible_field_size(uint field_metadata,
                                        const Relay_log_info *rli_arg)
{
#ifdef HAVE_REPLICATION
  const Check_field_param check_param = { this };
  if (rpl_master_has_bug(rli_arg, 37426, TRUE,
                         check_field_for_37426, &check_param))
    return FALSE;                        // Not compatible field sizes
#endif
  return Field::compatible_field_size(field_metadata, rli_arg);
}


6671
int Field_string::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6672
{
monty@mysql.com's avatar
monty@mysql.com committed
6673 6674 6675 6676 6677 6678 6679 6680 6681 6682
  uint a_len, b_len;

  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;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
6683 6684 6685 6686 6687
  /*
    We have to remove end space to be able to compare multi-byte-characters
    like in latin_de 'ae' and 0xe4
  */
  return field_charset->coll->strnncollsp(field_charset,
6688 6689
                                          a_ptr, a_len,
                                          b_ptr, b_len,
6690
                                          0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6691 6692
}

6693

6694
void Field_string::sort_string(uchar *to,uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6695
{
6696
  IF_DBUG(uint tmp=) my_strnxfrm(field_charset,
6697 6698
                                 to, length,
                                 ptr, field_length);
6699
  DBUG_ASSERT(tmp == length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6700 6701 6702 6703 6704
}


void Field_string::sql_type(String &res) const
{
6705
  THD *thd= table->in_use;
6706
  CHARSET_INFO *cs=res.charset();
6707 6708 6709 6710 6711 6712 6713
  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") :
6714
			      (has_charset() ? "char" : "binary")),
6715
                             (int) field_length / charset()->mbmaxlen);
6716
  res.length(length);
6717 6718
  if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
      has_charset() && (charset()->state & MY_CS_BINSORT))
6719
    res.append(STRING_WITH_LEN(" binary"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6720 6721
}

6722

6723 6724 6725
uchar *Field_string::pack(uchar *to, const uchar *from,
                          uint max_length,
                          bool low_byte_first __attribute__((unused)))
6726
{
monty@mysql.com's avatar
monty@mysql.com committed
6727
  uint length=      min(field_length,max_length);
6728 6729 6730 6731 6732
  uint local_char_length= max_length/field_charset->mbmaxlen;
  if (length > local_char_length)
    local_char_length= my_charpos(field_charset, from, from+length,
                                  local_char_length);
  set_if_smaller(length, local_char_length);
6733
  while (length && from[length-1] == field_charset->pad_char)
serg@serg.mylan's avatar
serg@serg.mylan committed
6734
    length--;
6735 6736

  // Length always stored little-endian
6737
  *to++= (uchar) length;
6738
  if (field_length > 255)
6739
    *to++= (uchar) (length >> 8);
6740 6741

  // Store the actual bytes of the string
6742 6743
  memcpy(to, from, length);
  return to+length;
6744 6745 6746
}


6747 6748 6749 6750 6751 6752 6753 6754 6755 6756
/**
   Unpack a string field from row data.

   This method is used to unpack a string field from a master whose size 
   of the field is less than that of the slave. Note that there can be a
   variety of field types represented with this class. Certain types like
   ENUM or SET are processed differently. Hence, the upper byte of the 
   @c param_data argument contains the result of field->real_type() from
   the master.

6757 6758 6759
   @note For information about how the length is packed, see @c
   Field_string::do_save_field_metadata

6760 6761 6762 6763 6764 6765
   @param   to         Destination of the data
   @param   from       Source of the data
   @param   param_data Real type (upper) and length (lower) values

   @return  New pointer into memory based on from + length of the data
*/
6766 6767 6768 6769 6770 6771
const uchar *
Field_string::unpack(uchar *to,
                     const uchar *from,
                     uint param_data,
                     bool low_byte_first __attribute__((unused)))
{
6772
  uint from_length, length;
6773

6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789
  /*
    Compute the declared length of the field on the master. This is
    used to decide if one or two bytes should be read as length.
   */
  if (param_data)
    from_length= (((param_data >> 4) & 0x300) ^ 0x300) + (param_data & 0x00ff);
  else
    from_length= field_length;

  DBUG_PRINT("debug",
             ("param_data: 0x%x, field_length: %u, from_length: %u",
              param_data, field_length, from_length));
  /*
    Compute the actual length of the data by reading one or two bits
    (depending on the declared field length on the master).
   */
6790
  if (from_length > 255)
6791 6792 6793 6794 6795
  {
    length= uint2korr(from);
    from+= 2;
  }
  else
6796
    length= (uint) *from++;
6797 6798 6799 6800

  memcpy(to, from, length);
  // Pad the string with the pad character of the fields charset
  bfill(to + length, field_length - length, field_charset->pad_char);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6801 6802 6803 6804
  return from+length;
}


6805 6806 6807 6808 6809 6810 6811
/**
   Save the field metadata for string fields.

   Saves the real type in the first byte and the field length in the 
   second byte of the field metadata array at index of *metadata_ptr and
   *(metadata_ptr + 1).

6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830
   @note In order to be able to handle lengths exceeding 255 and be
   backwards-compatible with pre-5.1.26 servers, an extra two bits of
   the length has been added to the metadata in such a way that if
   they are set, a new unrecognized type is generated.  This will
   cause pre-5.1-26 servers to stop due to a field type mismatch,
   while new servers will be able to extract the extra bits. If the
   length is <256, there will be no difference and both a new and an
   old server will be able to handle it.

   @note The extra two bits are added to bits 13 and 14 of the
   parameter data (with 1 being the least siginficant bit and 16 the
   most significant bit of the word) by xoring the extra length bits
   with the real type.  Since all allowable types have 0xF as most
   significant bits of the metadata word, lengths <256 will not affect
   the real type at all, while all other values will result in a
   non-existant type in the range 17-244.

   @see Field_string::unpack

6831 6832 6833 6834 6835 6836
   @param   metadata_ptr   First byte of field metadata

   @returns number of bytes written to metadata_ptr
*/
int Field_string::do_save_field_metadata(uchar *metadata_ptr)
{
6837 6838 6839 6840 6841 6842
  DBUG_ASSERT(field_length < 1024);
  DBUG_ASSERT((real_type() & 0xF0) == 0xF0);
  DBUG_PRINT("debug", ("field_length: %u, real_type: %u",
                       field_length, real_type()));
  *metadata_ptr= (real_type() ^ ((field_length & 0x300) >> 4));
  *(metadata_ptr + 1)= field_length & 0xFF;
6843 6844 6845 6846
  return 2;
}


6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862
/*
  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
*/

6863
int Field_string::pack_cmp(const uchar *a, const uchar *b, uint length,
6864
                           my_bool insert_or_update)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6865
{
6866
  uint a_length, b_length;
6867
  if (length > 255)
6868 6869 6870 6871 6872 6873 6874 6875
  {
    a_length= uint2korr(a);
    b_length= uint2korr(b);
    a+= 2;
    b+= 2;
  }
  else
  {
6876 6877
    a_length= (uint) *a++;
    b_length= (uint) *b++;
6878
  }
6879
  return field_charset->coll->strnncollsp(field_charset,
6880 6881
                                          a, a_length,
                                          b, b_length,
6882
                                          insert_or_update);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6883 6884 6885
}


6886 6887
/**
  Compare a packed key against row.
6888

6889 6890 6891
  @param key		        Original key
  @param length		Key length. (May be less than field length)
  @param insert_or_update	1 if this is an insert or update
6892

6893
  @return
6894
    < 0	  row < key
6895
  @return
6896
    0	  row = key
6897
  @return
6898 6899 6900
    > 0   row > key
*/

6901
int Field_string::pack_cmp(const uchar *key, uint length,
6902
                           my_bool insert_or_update)
6903
{
6904
  uint row_length, local_key_length;
6905
  uchar *end;
6906
  if (length > 255)
6907
  {
6908
    local_key_length= uint2korr(key);
6909
    key+= 2;
6910 6911
  }
  else
6912
    local_key_length= (uint) *key++;
6913 6914 6915
  
  /* Only use 'length' of key, not field_length */
  end= ptr + length;
6916 6917
  while (end > ptr && end[-1] == ' ')
    end--;
6918 6919 6920
  row_length= (uint) (end - ptr);

  return field_charset->coll->strnncollsp(field_charset,
6921 6922
                                          ptr, row_length,
                                          key, local_key_length,
6923
                                          insert_or_update);
6924 6925 6926
}


6927
uint Field_string::packed_col_length(const uchar *data_ptr, uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6928
{
6929
  if (length > 255)
6930
    return uint2korr(data_ptr)+2;
6931
  return (uint) *data_ptr + 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6932 6933
}

6934

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6935 6936
uint Field_string::max_packed_col_length(uint max_length)
{
6937
  return (max_length > 255 ? 2 : 1)+max_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6938 6939
}

6940 6941

uint Field_string::get_key_image(uchar *buff, uint length, imagetype type_arg)
6942
{
6943 6944
  uint bytes = my_charpos(field_charset, (char*) ptr,
                          (char*) ptr + field_length,
6945 6946 6947
                          length / field_charset->mbmaxlen);
  memcpy(buff, ptr, bytes);
  if (bytes < length)
6948 6949
    field_charset->cset->fill(field_charset, (char*) buff + bytes,
                              length - bytes, field_charset->pad_char);
6950 6951
  return bytes;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6952

6953

6954 6955
Field *Field_string::new_field(MEM_ROOT *root, struct st_table *new_table,
                               bool keep_type)
6956
{
6957
  Field *field;
6958
  if (type() != MYSQL_TYPE_VAR_STRING || keep_type)
kostja@bodhi.local's avatar
kostja@bodhi.local committed
6959
    field= Field::new_field(root, new_table, keep_type);
6960 6961
  else if ((field= new Field_varstring(field_length, maybe_null(), field_name,
                                       new_table->s, charset())))
6962 6963 6964 6965 6966 6967
  {
    /*
      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.
    */
6968
    field->init(new_table);
6969 6970 6971 6972 6973 6974
    /*
      Normally orig_table is different from table only if field was created
      via ::new_field.  Here we alter the type of field, so ::new_field is
      not applicable. But we still need to preserve the original field
      metadata for the client-server protocol.
    */
kostja@bodhi.local's avatar
kostja@bodhi.local committed
6975
    field->orig_table= orig_table;
6976
  }
6977
  return field;
6978 6979
}

6980

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6981
/****************************************************************************
6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992 6993 6994
  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.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6995 6996
****************************************************************************/

6997
const uint Field_varstring::MAX_SIZE= UINT_MAX16;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6998

6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012
/**
   Save the field metadata for varstring fields.

   Saves the field length in the first byte. Note: may consume
   2 bytes. Caller must ensure second byte is contiguous with
   first byte (e.g. array index 0,1).

   @param   metadata_ptr   First byte of field metadata

   @returns number of bytes written to metadata_ptr
*/
int Field_varstring::do_save_field_metadata(uchar *metadata_ptr)
{
  char *ptr= (char *)metadata_ptr;
7013
  DBUG_ASSERT(field_length <= 65535);
7014 7015 7016 7017
  int2store(ptr, field_length);
  return 2;
}

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
7018
int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7019
{
7020
  ASSERT_COLUMN_MARKED_FOR_WRITE;
7021 7022 7023 7024 7025 7026
  uint copy_length;
  const char *well_formed_error_pos;
  const char *cannot_convert_error_pos;
  const char *from_end_pos;

  copy_length= well_formed_copy_nchars(field_charset,
7027 7028
                                       (char*) ptr + length_bytes,
                                       field_length,
7029 7030 7031 7032 7033
                                       cs, from, length,
                                       field_length / field_charset->mbmaxlen,
                                       &well_formed_error_pos,
                                       &cannot_convert_error_pos,
                                       &from_end_pos);
7034

7035 7036 7037 7038
  if (length_bytes == 1)
    *ptr= (uchar) copy_length;
  else
    int2store(ptr, copy_length);
7039

7040
  if (check_string_copy_error(this, well_formed_error_pos,
7041
                              cannot_convert_error_pos, from + length, cs))
7042 7043
    return 2;

7044
  return report_if_important_data(from_end_pos, from + length, TRUE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7045 7046 7047
}


7048
int Field_varstring::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7049
{
7050
  char buff[64];
7051 7052 7053 7054
  uint  length;
  length= (uint) (field_charset->cset->longlong10_to_str)(field_charset,
                                                          buff,
                                                          sizeof(buff),
7055 7056 7057
                                                          (unsigned_val ? 10:
                                                           -10),
                                                           nr);
7058
  return Field_varstring::store(buff, length, field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7059 7060 7061 7062 7063
}


double Field_varstring::val_real(void)
{
7064
  ASSERT_COLUMN_MARKED_FOR_READ;
7065
  int not_used;
7066
  char *end_not_used;
7067 7068 7069
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
  return my_strntod(field_charset, (char*) ptr+length_bytes, length,
                    &end_not_used, &not_used);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7070 7071 7072 7073 7074
}


longlong Field_varstring::val_int(void)
{
7075
  ASSERT_COLUMN_MARKED_FOR_READ;
7076
  int not_used;
7077
  char *end_not_used;
7078 7079
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
  return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10,
7080
                     &end_not_used, &not_used);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7081 7082 7083 7084 7085
}

String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
				 String *val_ptr)
{
7086
  ASSERT_COLUMN_MARKED_FOR_READ;
7087
  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
7088
  val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7089 7090 7091 7092
  return val_ptr;
}


7093 7094
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
{
7095
  ASSERT_COLUMN_MARKED_FOR_READ;
7096 7097 7098
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
  str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
                 charset(), decimal_value);
7099 7100 7101 7102
  return decimal_value;
}


7103
int Field_varstring::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
7104
                             uint max_len)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7105
{
7106
  uint a_length, b_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7107
  int diff;
7108 7109 7110

  if (length_bytes == 1)
  {
7111 7112
    a_length= (uint) *a_ptr;
    b_length= (uint) *b_ptr;
7113 7114 7115 7116 7117 7118
  }
  else
  {
    a_length= uint2korr(a_ptr);
    b_length= uint2korr(b_ptr);
  }
7119 7120
  set_if_smaller(a_length, max_len);
  set_if_smaller(b_length, max_len);
7121
  diff= field_charset->coll->strnncollsp(field_charset,
7122
                                         a_ptr+
7123
                                         length_bytes,
7124
                                         a_length,
7125
                                         b_ptr+
7126
                                         length_bytes,
7127 7128
                                         b_length,0);
  return diff;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7129 7130
}

7131

7132 7133 7134
/**
  @note
    varstring and blob keys are ALWAYS stored with a 2 byte length prefix
7135 7136
*/

7137
int Field_varstring::key_cmp(const uchar *key_ptr, uint max_key_length)
7138
{
7139
  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
7140
  uint local_char_length= max_key_length / field_charset->mbmaxlen;
7141

7142 7143 7144
  local_char_length= my_charpos(field_charset, ptr + length_bytes,
                          ptr + length_bytes + length, local_char_length);
  set_if_smaller(length, local_char_length);
7145
  return field_charset->coll->strnncollsp(field_charset, 
7146
                                          ptr + length_bytes,
7147
                                          length,
7148
                                          key_ptr+
7149 7150
                                          HA_KEY_BLOB_LENGTH,
                                          uint2korr(key_ptr), 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7151 7152
}

7153

7154 7155
/**
  Compare to key segments (always 2 byte length prefix).
7156

7157
  @note
7158 7159 7160 7161
    This is used only to compare key segments created for index_read().
    (keys are created and compared in key.cc)
*/

7162
int Field_varstring::key_cmp(const uchar *a,const uchar *b)
7163
{
7164
  return field_charset->coll->strnncollsp(field_charset,
7165
                                          a + HA_KEY_BLOB_LENGTH,
7166
                                          uint2korr(a),
7167
                                          b + HA_KEY_BLOB_LENGTH,
7168 7169
                                          uint2korr(b),
                                          0);
7170 7171 7172
}


7173
void Field_varstring::sort_string(uchar *to,uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7174
{
7175
  uint tot_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186

  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;
  }
 
7187
  tot_length= my_strnxfrm(field_charset,
7188
			  to, length, ptr + length_bytes,
7189
			  tot_length);
monty@mysql.com's avatar
monty@mysql.com committed
7190
  DBUG_ASSERT(tot_length == length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7191 7192 7193
}


7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205
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;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
7206 7207
void Field_varstring::sql_type(String &res) const
{
7208
  THD *thd= table->in_use;
7209
  CHARSET_INFO *cs=res.charset();
7210 7211 7212 7213 7214 7215
  ulong length;

  length= cs->cset->snprintf(cs,(char*) res.ptr(),
                             res.alloced_length(), "%s(%d)",
                              (has_charset() ? "varchar" : "varbinary"),
                             (int) field_length / charset()->mbmaxlen);
7216
  res.length(length);
7217 7218
  if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
      has_charset() && (charset()->state & MY_CS_BINSORT))
7219
    res.append(STRING_WITH_LEN(" binary"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7220 7221
}

7222

7223
uint32 Field_varstring::data_length()
7224
{
7225
  return length_bytes == 1 ? (uint32) *ptr : uint2korr(ptr);
7226 7227
}

7228 7229 7230 7231 7232
/*
  Functions to create a packed row.
  Here the number of length bytes are depending on the given max_length
*/

7233 7234 7235
uchar *Field_varstring::pack(uchar *to, const uchar *from,
                             uint max_length,
                             bool low_byte_first __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7236
{
7237
  uint length= length_bytes == 1 ? (uint) *from : uint2korr(from);
7238
  set_if_smaller(max_length, field_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7239 7240
  if (length > max_length)
    length=max_length;
7241 7242 7243

  /* Length always stored little-endian */
  *to++= length & 0xFF;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7244
  if (max_length > 255)
7245 7246 7247 7248
    *to++= (length >> 8) & 0xFF;

  /* Store bytes of string */
  if (length > 0)
7249
    memcpy(to, from+length_bytes, length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7250 7251 7252 7253
  return to+length;
}


7254 7255 7256
uchar *
Field_varstring::pack_key(uchar *to, const uchar *key, uint max_length,
                          bool low_byte_first __attribute__((unused)))
7257
{
7258
  uint length=  length_bytes == 1 ? (uint) *key : uint2korr(key);
7259
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
7260
                     max_length/field_charset->mbmaxlen : max_length);
7261
  key+= length_bytes;
7262
  if (length > local_char_length)
7263
  {
7264 7265 7266
    local_char_length= my_charpos(field_charset, key, key+length,
                                  local_char_length);
    set_if_smaller(length, local_char_length);
7267
  }
7268 7269 7270 7271
  *to++= (char) (length & 255);
  if (max_length > 255)
    *to++= (char) (length >> 8);
  if (length)
7272 7273 7274 7275 7276
    memcpy(to, key, length);
  return to+length;
}


7277
/**
7278 7279
  Unpack a key into a record buffer.

7280 7281 7282
  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'.
7283

7284 7285 7286
  @param to                          Pointer into the record buffer.
  @param key                         Pointer to the packed key.
  @param max_length                  Key length limit from key description.
7287

7288
  @return
7289 7290 7291
    Pointer to end of 'key' (To the next key part if multi-segment key)
*/

7292 7293 7294
const uchar *
Field_varstring::unpack_key(uchar *to, const uchar *key, uint max_length,
                            bool low_byte_first __attribute__((unused)))
7295 7296
{
  /* get length of the blob key */
7297
  uint32 length= *key++;
7298
  if (max_length > 255)
7299
    length+= (*key++) << 8;
7300 7301 7302 7303 7304 7305 7306 7307 7308 7309

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

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

7313 7314 7315
  @param to		Store packed key segment here
  @param from		Key segment (as given to index_read())
  @param max_length  	Max length of key
7316

7317
  @return
7318 7319 7320
    end of key storage
*/

7321 7322 7323
uchar *
Field_varstring::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length,
                                         bool low_byte_first __attribute__((unused)))
7324 7325 7326 7327 7328 7329 7330 7331 7332 7333
{
  /* 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);
7334 7335 7336 7337
  return to+length;
}


7338 7339 7340 7341 7342
/**
   Unpack a varstring field from row data.

   This method is used to unpack a varstring field from a master
   whose size of the field is less than that of the slave.
7343 7344 7345

   @note
   The string length is always packed little-endian.
7346 7347 7348 7349 7350 7351 7352
  
   @param   to         Destination of the data
   @param   from       Source of the data
   @param   param_data Length bytes from the master's field data

   @return  New pointer into memory based on from + length of the data
*/
7353 7354 7355 7356
const uchar *
Field_varstring::unpack(uchar *to, const uchar *from,
                        uint param_data,
                        bool low_byte_first __attribute__((unused)))
7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367
{
  uint length;
  uint l_bytes= (param_data && (param_data < field_length)) ? 
                (param_data <= 255) ? 1 : 2 : length_bytes;
  if (l_bytes == 1)
  {
    to[0]= *from++;
    length= to[0];
    if (length_bytes == 2)
      to[1]= 0;
  }
7368
  else /* l_bytes == 2 */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7369
  {
7370 7371 7372
    length= uint2korr(from);
    to[0]= *from++;
    to[1]= *from++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7373 7374
  }
  if (length)
7375
    memcpy(to+ length_bytes, from, length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7376 7377 7378 7379
  return from+length;
}


7380
int Field_varstring::pack_cmp(const uchar *a, const uchar *b,
7381
                              uint key_length_arg,
7382
                              my_bool insert_or_update)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7383
{
7384
  uint a_length, b_length;
7385
  if (key_length_arg > 255)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7386
  {
7387 7388
    a_length=uint2korr(a); a+= 2;
    b_length=uint2korr(b); b+= 2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7389 7390 7391
  }
  else
  {
7392 7393
    a_length= (uint) *a++;
    b_length= (uint) *b++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7394
  }
7395
  return field_charset->coll->strnncollsp(field_charset,
7396 7397
                                          a, a_length,
                                          b, b_length,
7398
                                          insert_or_update);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7399 7400
}

7401

7402
int Field_varstring::pack_cmp(const uchar *b, uint key_length_arg,
7403
                              my_bool insert_or_update)
7404
{
7405 7406
  uchar *a= ptr+ length_bytes;
  uint a_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
7407
  uint b_length;
7408 7409 7410
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
                           key_length_arg / field_charset->mbmaxlen :
                           key_length_arg);
7411

7412
  if (key_length_arg > 255)
7413
  {
7414
    b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
7415 7416
  }
  else
7417
    b_length= (uint) *b++;
7418

7419
  if (a_length > local_char_length)
7420
  {
7421 7422 7423
    local_char_length= my_charpos(field_charset, a, a+a_length,
                                  local_char_length);
    set_if_smaller(a_length, local_char_length);
7424
  }
7425 7426

  return field_charset->coll->strnncollsp(field_charset,
7427 7428
                                          a, a_length,
                                          b, b_length,
7429
                                          insert_or_update);
7430 7431
}

7432

7433
uint Field_varstring::packed_col_length(const uchar *data_ptr, uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7434
{
7435
  if (length > 255)
7436
    return uint2korr(data_ptr)+2;
7437
  return (uint) *data_ptr + 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7438 7439
}

7440

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7441 7442
uint Field_varstring::max_packed_col_length(uint max_length)
{
7443
  return (max_length > 255 ? 2 : 1)+max_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7444 7445
}

7446
uint Field_varstring::get_key_image(uchar *buff, uint length, imagetype type)
7447
{
7448
  uint f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
7449
  uint local_char_length= length / field_charset->mbmaxlen;
7450
  uchar *pos= ptr+length_bytes;
7451 7452 7453
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
                                local_char_length);
  set_if_smaller(f_length, local_char_length);
7454
  /* Key is always stored with 2 bytes */
7455
  int2store(buff,f_length);
7456
  memcpy(buff+HA_KEY_BLOB_LENGTH, pos, f_length);
7457
  if (f_length < length)
7458 7459 7460 7461 7462
  {
    /*
      Must clear this as we do a memcmp in opt_range.cc to detect
      identical keys
    */
7463
    bzero(buff+HA_KEY_BLOB_LENGTH+f_length, (length-f_length));
7464
  }
7465
  return HA_KEY_BLOB_LENGTH+f_length;
7466 7467
}

7468

7469
void Field_varstring::set_key_image(const uchar *buff,uint length)
7470
{
7471
  length= uint2korr(buff);			// Real length is here
7472
  (void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
7473
                                field_charset);
7474 7475 7476
}


7477
int Field_varstring::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
7478 7479 7480 7481
                                uint32 max_length)
{
  uint32 a_length,b_length;

7482 7483
  if (length_bytes == 1)
  {
7484 7485
    a_length= (uint) *a_ptr;
    b_length= (uint) *b_ptr;
7486 7487 7488 7489 7490 7491
  }
  else
  {
    a_length= uint2korr(a_ptr);
    b_length= uint2korr(b_ptr);
  }
7492 7493 7494 7495
  set_if_smaller(a_length, max_length);
  set_if_smaller(b_length, max_length);
  if (a_length != b_length)
    return 1;
7496 7497 7498 7499
  return memcmp(a_ptr+length_bytes, b_ptr+length_bytes, a_length);
}


7500 7501
Field *Field_varstring::new_field(MEM_ROOT *root, struct st_table *new_table,
                                  bool keep_type)
7502
{
7503 7504
  Field_varstring *res= (Field_varstring*) Field::new_field(root, new_table,
                                                            keep_type);
7505 7506 7507 7508 7509 7510 7511
  if (res)
    res->length_bytes= length_bytes;
  return res;
}


Field *Field_varstring::new_key_field(MEM_ROOT *root,
monty@mysql.com's avatar
monty@mysql.com committed
7512
                                      struct st_table *new_table,
7513
                                      uchar *new_ptr, uchar *new_null_ptr,
monty@mysql.com's avatar
monty@mysql.com committed
7514 7515 7516 7517 7518 7519 7520 7521 7522 7523
                                      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 */
7524
    res->length_bytes= 2;
monty@mysql.com's avatar
monty@mysql.com committed
7525
  }
7526
  return res;
7527 7528
}

7529

7530
uint Field_varstring::is_equal(Create_field *new_field)
7531
{
7532
  if (new_field->sql_type == real_type() &&
7533 7534
      new_field->charset == field_charset)
  {
7535
    if (new_field->length == max_display_length())
7536
      return IS_EQUAL_YES;
7537 7538 7539
    if (new_field->length > max_display_length() &&
	((new_field->length <= 255 && max_display_length() <= 255) ||
	 (new_field->length > 255 && max_display_length() > 255)))
7540 7541 7542 7543 7544 7545
      return IS_EQUAL_PACK_LENGTH; // VARCHAR, longer variable length
  }
  return IS_EQUAL_NO;
}


7546 7547 7548 7549 7550 7551 7552 7553
void Field_varstring::hash(ulong *nr, ulong *nr2)
{
  if (is_null())
  {
    *nr^= (*nr << 1) | 1;
  }
  else
  {
7554
    uint len=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
7555
    CHARSET_INFO *cs= charset();
7556
    cs->coll->hash_sort(cs, ptr + length_bytes, len, nr, nr2);
7557 7558 7559 7560
  }
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
7561 7562 7563 7564 7565 7566
/****************************************************************************
** 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.
****************************************************************************/

7567
Field_blob::Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7568
		       enum utype unireg_check_arg, const char *field_name_arg,
7569
                       TABLE_SHARE *share, uint blob_pack_length,
7570
		       CHARSET_INFO *cs)
7571
  :Field_longstr(ptr_arg, BLOB_PACK_LENGTH_TO_MAX_LENGH(blob_pack_length),
7572 7573
                 null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
                 cs),
hf@deer.(none)'s avatar
hf@deer.(none) committed
7574
   packlength(blob_pack_length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7575 7576
{
  flags|= BLOB_FLAG;
7577
  share->blob_fields++;
7578
  /* TODO: why do not fill table->s->blob_field array here? */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7579 7580 7581
}


7582 7583 7584 7585
void Field_blob::store_length(uchar *i_ptr, 
                              uint i_packlength, 
                              uint32 i_number, 
                              bool low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7586
{
7587
  switch (i_packlength) {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7588
  case 1:
7589
    i_ptr[0]= (uchar) i_number;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7590 7591 7592
    break;
  case 2:
#ifdef WORDS_BIGENDIAN
7593
    if (low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7594
    {
7595
      int2store(i_ptr,(unsigned short) i_number);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7596 7597 7598
    }
    else
#endif
7599
      shortstore(i_ptr,(unsigned short) i_number);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7600 7601
    break;
  case 3:
7602
    int3store(i_ptr,i_number);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7603 7604 7605
    break;
  case 4:
#ifdef WORDS_BIGENDIAN
7606
    if (low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7607
    {
7608
      int4store(i_ptr,i_number);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7609 7610 7611
    }
    else
#endif
7612
      longstore(i_ptr,i_number);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7613 7614 7615 7616
  }
}


7617
uint32 Field_blob::get_length(const uchar *pos, uint packlength_arg, bool low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7618
{
7619
  switch (packlength_arg) {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7620
  case 1:
7621
    return (uint32) pos[0];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7622 7623 7624 7625
  case 2:
    {
      uint16 tmp;
#ifdef WORDS_BIGENDIAN
7626
      if (low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7627 7628 7629 7630
	tmp=sint2korr(pos);
      else
#endif
	shortget(tmp,pos);
7631
      return (uint32) tmp;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7632 7633
    }
  case 3:
7634
    return (uint32) uint3korr(pos);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7635 7636 7637 7638
  case 4:
    {
      uint32 tmp;
#ifdef WORDS_BIGENDIAN
7639
      if (low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7640 7641 7642 7643
	tmp=uint4korr(pos);
      else
#endif
	longget(tmp,pos);
7644
      return (uint32) tmp;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7645 7646
    }
  }
7647
  /* When expanding this, see also MAX_FIELD_BLOBLENGTH. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7648 7649 7650 7651
  return 0;					// Impossible
}


7652
/**
7653 7654
  Put a blob length field into a record buffer.

7655 7656 7657
  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'.
7658

7659 7660
  @param pos                 Pointer into the record buffer.
  @param length              The length value to put.
7661 7662
*/

7663
void Field_blob::put_length(uchar *pos, uint32 length)
7664 7665 7666 7667 7668 7669 7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681
{
  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;
  }
}


bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
7682
int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7683
{
7684
  ASSERT_COLUMN_MARKED_FOR_WRITE;
7685 7686 7687 7688 7689 7690 7691
  uint copy_length, new_length;
  const char *well_formed_error_pos;
  const char *cannot_convert_error_pos;
  const char *from_end_pos, *tmp;
  char buff[STRING_BUFFER_USUAL_SIZE];
  String tmpstr(buff,sizeof(buff), &my_charset_bin);

bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
7692
  if (!length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7693 7694
  {
    bzero(ptr,Field_blob::pack_length());
7695
    return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7696
  }
bar@bar.intranet.mysql.r18.ru's avatar
bar@bar.intranet.mysql.r18.ru committed
7697

7698 7699 7700 7701 7702 7703 7704
  /*
    If the 'from' address is in the range of the temporary 'value'-
    object we need to copy the content to a different location or it will be
    invalidated when the 'value'-object is reallocated to make room for
    the new character set.
  */
  if (from >= value.ptr() && from <= value.ptr()+value.length())
7705
  {
7706 7707 7708 7709
    /*
      If content of the 'from'-address is cached in the 'value'-object
      it is possible that the content needs a character conversion.
    */
7710 7711 7712 7713 7714 7715
    uint32 dummy_offset;
    if (!String::needs_conversion(length, cs, field_charset, &dummy_offset))
    {
      Field_blob::store_length(length);
      bmove(ptr+packlength,(char*) &from,sizeof(char*));
      return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7716
    }
7717 7718 7719
    if (tmpstr.copy(from, length, cs))
      goto oom_error;
    from= tmpstr.ptr();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7720
  }
7721 7722 7723 7724 7725

  new_length= min(max_data_length(), field_charset->mbmaxlen * length);
  if (value.alloc(new_length))
    goto oom_error;

7726 7727 7728 7729 7730 7731 7732 7733 7734 7735 7736

  if (f_is_hex_escape(flags))
  {
    copy_length= my_copy_with_hex_escaping(field_charset,
                                           (char*) value.ptr(), new_length,
                                            from, length);
    Field_blob::store_length(copy_length);
    tmp= value.ptr();
    bmove(ptr + packlength, (uchar*) &tmp, sizeof(char*));
    return 0;
  }
7737 7738 7739 7740 7741 7742 7743 7744 7745 7746 7747 7748 7749 7750 7751
  /*
    "length" is OK as "nchars" argument to well_formed_copy_nchars as this
    is never used to limit the length of the data. The cut of long data
    is done with the new_length value.
  */
  copy_length= well_formed_copy_nchars(field_charset,
                                       (char*) value.ptr(), new_length,
                                       cs, from, length,
                                       length,
                                       &well_formed_error_pos,
                                       &cannot_convert_error_pos,
                                       &from_end_pos);

  Field_blob::store_length(copy_length);
  tmp= value.ptr();
7752
  bmove(ptr+packlength,(uchar*) &tmp,sizeof(char*));
7753 7754

  if (check_string_copy_error(this, well_formed_error_pos,
7755
                              cannot_convert_error_pos, from + length, cs))
7756 7757
    return 2;

7758
  return report_if_important_data(from_end_pos, from + length, TRUE);
7759 7760 7761 7762 7763

oom_error:
  /* Fatal OOM error */
  bzero(ptr,Field_blob::pack_length());
  return -1; 
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7764 7765 7766
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
7767
int Field_blob::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7768
{
7769
  CHARSET_INFO *cs=charset();
7770
  value.set_real(nr, 2, cs);
7771
  return Field_blob::store(value.ptr(),(uint) value.length(), cs);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7772 7773 7774
}


7775
int Field_blob::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7776
{
7777
  CHARSET_INFO *cs=charset();
7778
  value.set_int(nr, unsigned_val, cs);
7779
  return Field_blob::store(value.ptr(), (uint) value.length(), cs);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7780 7781
}

7782

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7783 7784
double Field_blob::val_real(void)
{
7785
  ASSERT_COLUMN_MARKED_FOR_READ;
7786
  int not_used;
7787 7788 7789 7790
  char *end_not_used, *blob;
  uint32 length;
  CHARSET_INFO *cs;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7791 7792 7793
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
    return 0.0;
7794 7795
  length= get_length(ptr);
  cs= charset();
monty@mysql.com's avatar
monty@mysql.com committed
7796
  return my_strntod(cs, blob, length, &end_not_used, &not_used);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7797 7798 7799 7800 7801
}


longlong Field_blob::val_int(void)
{
7802
  ASSERT_COLUMN_MARKED_FOR_READ;
7803
  int not_used;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7804 7805 7806 7807
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
    return 0;
7808
  uint32 length=get_length(ptr);
7809
  return my_strntoll(charset(),blob,length,10,NULL,&not_used);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7810 7811 7812 7813 7814
}

String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
			    String *val_ptr)
{
7815
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7816 7817 7818
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
7819
    val_ptr->set("",0,charset());	// A bit safer than ->length(0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7820
  else
7821
    val_ptr->set((const char*) blob,get_length(ptr),charset());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7822 7823 7824 7825
  return val_ptr;
}


7826 7827
my_decimal *Field_blob::val_decimal(my_decimal *decimal_value)
{
7828
  ASSERT_COLUMN_MARKED_FOR_READ;
7829
  const char *blob;
7830 7831
  size_t length;
  memcpy_fixed(&blob, ptr+packlength, sizeof(const uchar*));
7832
  if (!blob)
7833
  {
7834
    blob= "";
7835 7836 7837 7838 7839 7840
    length= 0;
  }
  else
    length= get_length(ptr);

  str2my_decimal(E_DEC_FATAL_ERROR, blob, length, charset(),
7841 7842 7843 7844 7845
                 decimal_value);
  return decimal_value;
}


7846
int Field_blob::cmp(const uchar *a,uint32 a_length, const uchar *b,
7847
		    uint32 b_length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7848
{
7849
  return field_charset->coll->strnncollsp(field_charset, 
7850
                                          a, a_length, b, b_length,
7851
                                          0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7852 7853 7854
}


7855
int Field_blob::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
7856
                        uint max_length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7857
{
7858
  uchar *blob1,*blob2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7859 7860
  memcpy_fixed(&blob1,a_ptr+packlength,sizeof(char*));
  memcpy_fixed(&blob2,b_ptr+packlength,sizeof(char*));
7861 7862 7863 7864
  uint a_len= get_length(a_ptr), b_len= get_length(b_ptr);
  set_if_smaller(a_len, max_length);
  set_if_smaller(b_len, max_length);
  return Field_blob::cmp(blob1,a_len,blob2,b_len);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7865 7866 7867
}


7868
int Field_blob::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
7869
			   uint32 max_length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7870 7871 7872
{
  char *a,*b;
  uint diff;
7873
  uint32 a_length,b_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888
  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 */

7889
uint Field_blob::get_key_image(uchar *buff,uint length, imagetype type_arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7890
{
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
7891
  uint32 blob_length= get_length(ptr);
7892
  uchar *blob;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
7893

hf@deer.(none)'s avatar
hf@deer.(none) committed
7894
#ifdef HAVE_SPATIAL
7895
  if (type_arg == itMBR)
7896
  {
7897
    const char *dummy;
7898
    MBR mbr;
7899 7900
    Geometry_buffer buffer;
    Geometry *gobj;
7901
    const uint image_length= SIZEOF_STORED_DOUBLE*4;
7902 7903 7904

    if (blob_length < SRID_SIZE)
    {
7905 7906
      bzero(buff, image_length);
      return image_length;
7907 7908
    }
    get_ptr(&blob);
7909
    gobj= Geometry::construct(&buffer, (char*) blob, blob_length);
7910
    if (!gobj || gobj->get_mbr(&mbr, &dummy))
7911
      bzero(buff, image_length);
7912 7913 7914 7915 7916 7917 7918
    else
    {
      float8store(buff,    mbr.xmin);
      float8store(buff+8,  mbr.xmax);
      float8store(buff+16, mbr.ymin);
      float8store(buff+24, mbr.ymax);
    }
7919
    return image_length;
7920
  }
hf@deer.(none)'s avatar
hf@deer.(none) committed
7921
#endif /*HAVE_SPATIAL*/
7922

7923
  get_ptr(&blob);
7924 7925 7926 7927
  uint local_char_length= length / field_charset->mbmaxlen;
  local_char_length= my_charpos(field_charset, blob, blob + blob_length,
                          local_char_length);
  set_if_smaller(blob_length, local_char_length);
7928

7929
  if ((uint32) length > blob_length)
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
7930
  {
7931 7932 7933 7934
    /*
      Must clear this as we do a memcmp in opt_range.cc to detect
      identical keys
    */
7935
    bzero(buff+HA_KEY_BLOB_LENGTH+blob_length, (length-blob_length));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7936
    length=(uint) blob_length;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
7937
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7938
  int2store(buff,length);
7939
  memcpy(buff+HA_KEY_BLOB_LENGTH, blob, length);
7940
  return HA_KEY_BLOB_LENGTH+length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7941 7942
}

7943

7944
void Field_blob::set_key_image(const uchar *buff,uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7945
{
7946
  length= uint2korr(buff);
7947 7948
  (void) Field_blob::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
                           field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7949 7950
}

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
7951

7952
int Field_blob::key_cmp(const uchar *key_ptr, uint max_key_length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7953
{
7954
  uchar *blob1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7955 7956
  uint blob_length=get_length(ptr);
  memcpy_fixed(&blob1,ptr+packlength,sizeof(char*));
7957
  CHARSET_INFO *cs= charset();
7958 7959 7960 7961
  uint local_char_length= max_key_length / cs->mbmaxlen;
  local_char_length= my_charpos(cs, blob1, blob1+blob_length,
                                local_char_length);
  set_if_smaller(blob_length, local_char_length);
7962
  return Field_blob::cmp(blob1, blob_length,
7963
			 key_ptr+HA_KEY_BLOB_LENGTH,
7964
			 uint2korr(key_ptr));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7965 7966
}

7967
int Field_blob::key_cmp(const uchar *a,const uchar *b)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7968
{
7969 7970
  return Field_blob::cmp(a+HA_KEY_BLOB_LENGTH, uint2korr(a),
			 b+HA_KEY_BLOB_LENGTH, uint2korr(b));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7971 7972 7973
}


7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990
/**
   Save the field metadata for blob fields.

   Saves the pack length in the first byte of the field metadata array
   at index of *metadata_ptr.

   @param   metadata_ptr   First byte of field metadata

   @returns number of bytes written to metadata_ptr
*/
int Field_blob::do_save_field_metadata(uchar *metadata_ptr)
{
  *metadata_ptr= pack_length_no_ptr();
  return 1;
}


7991 7992 7993 7994 7995 7996 7997
uint32 Field_blob::sort_length() const
{
  return (uint32) (current_thd->variables.max_sort_length + 
                   (field_charset == &my_charset_bin ? 0 : packlength));
}


7998
void Field_blob::sort_string(uchar *to,uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7999
{
8000
  uchar *blob;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8001
  uint blob_length=get_length();
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
8002

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8003 8004 8005 8006
  if (!blob_length)
    bzero(to,length);
  else
  {
8007 8008
    if (field_charset == &my_charset_bin)
    {
8009
      uchar *pos;
8010 8011 8012 8013 8014 8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031

      /*
        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;
      }
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8032
    memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
8033 8034
    
    blob_length=my_strnxfrm(field_charset,
8035
                            to, length, blob, blob_length);
8036
    DBUG_ASSERT(blob_length == length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8037 8038 8039 8040 8041 8042 8043
  }
}


void Field_blob::sql_type(String &res) const
{
  const char *str;
8044
  uint length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8045
  switch (packlength) {
8046 8047 8048 8049 8050
  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;
  }
8051
  res.set_ascii(str,length);
8052
  if (charset() == &my_charset_bin)
8053
    res.append(STRING_WITH_LEN("blob"));
8054 8055
  else
  {
8056
    res.append(STRING_WITH_LEN("text"));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8057 8058 8059
  }
}

8060 8061
uchar *Field_blob::pack(uchar *to, const uchar *from,
                        uint max_length, bool low_byte_first)
8062
{
8063 8064 8065 8066 8067 8068
  DBUG_ENTER("Field_blob::pack");
  DBUG_PRINT("enter", ("to: 0x%lx; from: 0x%lx;"
                       " max_length: %u; low_byte_first: %d",
                       (ulong) to, (ulong) from,
                       max_length, low_byte_first));
  DBUG_DUMP("record", from, table->s->reclength);
8069 8070
  uchar *save= ptr;
  ptr= (uchar*) from;
8071
  uint32 length=get_length();			// Length of from string
8072 8073 8074 8075 8076 8077 8078 8079 8080 8081 8082 8083

  /*
    Store max length, which will occupy packlength bytes. If the max
    length given is smaller than the actual length of the blob, we
    just store the initial bytes of the blob.
  */
  store_length(to, packlength, min(length, max_length), low_byte_first);

  /*
    Store the actual blob data, which will occupy 'length' bytes.
   */
  if (length > 0)
8084
  {
8085
    get_ptr((uchar**) &from);
8086 8087 8088
    memcpy(to+packlength, from,length);
  }
  ptr=save;					// Restore org row pointer
8089 8090
  DBUG_DUMP("packed", to, packlength + length);
  DBUG_RETURN(to+packlength+length);
8091 8092 8093
}


8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104
/**
   Unpack a blob field from row data.

   This method is used to unpack a blob field from a master whose size of 
   the field is less than that of the slave. Note: This method is included
   to satisfy inheritance rules, but is not needed for blob fields. It
   simply is used as a pass-through to the original unpack() method for
   blob fields.

   @param   to         Destination of the data
   @param   from       Source of the data
8105 8106 8107
   @param   param_data @c TRUE if base types should be stored in little-
                       endian format, @c FALSE if native format should
                       be used.
8108 8109 8110 8111 8112

   @return  New pointer into memory based on from + length of the data
*/
const uchar *Field_blob::unpack(uchar *to, 
                                const uchar *from,
8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123
                                uint param_data,
                                bool low_byte_first)
{
  DBUG_ENTER("Field_blob::unpack");
  DBUG_PRINT("enter", ("to: 0x%lx; from: 0x%lx;"
                       " param_data: %u; low_byte_first: %d",
                       (ulong) to, (ulong) from, param_data, low_byte_first));
  uint const master_packlength=
    param_data > 0 ? param_data & 0xFF : packlength;
  uint32 const length= get_length(from, master_packlength, low_byte_first);
  DBUG_DUMP("packed", from, length + master_packlength);
8124
  bitmap_set_bit(table->write_set, field_index);
8125 8126 8127 8128
  store(reinterpret_cast<const char*>(from) + master_packlength,
        length, field_charset);
  DBUG_DUMP("record", to, table->s->reclength);
  DBUG_RETURN(from + master_packlength + length);
8129 8130
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8131 8132
/* Keys for blobs are like keys on varchars */

8133
int Field_blob::pack_cmp(const uchar *a, const uchar *b, uint key_length_arg,
8134
                         my_bool insert_or_update)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8135
{
8136
  uint a_length, b_length;
8137
  if (key_length_arg > 255)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8138 8139 8140 8141 8142 8143
  {
    a_length=uint2korr(a); a+=2;
    b_length=uint2korr(b); b+=2;
  }
  else
  {
8144 8145
    a_length= (uint) *a++;
    b_length= (uint) *b++;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8146
  }
8147
  return field_charset->coll->strnncollsp(field_charset,
8148 8149
                                          a, a_length,
                                          b, b_length,
8150
                                          insert_or_update);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8151 8152
}

8153

8154
int Field_blob::pack_cmp(const uchar *b, uint key_length_arg,
8155
                         my_bool insert_or_update)
8156
{
8157
  uchar *a;
8158
  uint a_length, b_length;
8159 8160
  memcpy_fixed(&a,ptr+packlength,sizeof(char*));
  if (!a)
8161
    return key_length_arg > 0 ? -1 : 0;
8162

8163 8164
  a_length= get_length(ptr);
  if (key_length_arg > 255)
8165
  {
8166
    b_length= uint2korr(b); b+=2;
8167 8168
  }
  else
8169
    b_length= (uint) *b++;
8170
  return field_charset->coll->strnncollsp(field_charset,
8171 8172
                                          a, a_length,
                                          b, b_length,
8173
                                          insert_or_update);
8174 8175
}

8176
/** Create a packed key that will be used for storage from a MySQL row. */
8177

8178 8179 8180
uchar *
Field_blob::pack_key(uchar *to, const uchar *from, uint max_length,
                     bool low_byte_first __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8181
{
8182 8183
  uchar *save= ptr;
  ptr= (uchar*) from;
8184
  uint32 length=get_length();        // Length of from string
8185
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
8186
                           max_length/field_charset->mbmaxlen : max_length);
8187
  if (length)
8188
    get_ptr((uchar**) &from);
8189 8190 8191 8192
  if (length > local_char_length)
    local_char_length= my_charpos(field_charset, from, from+length,
                                  local_char_length);
  set_if_smaller(length, local_char_length);
8193 8194 8195
  *to++= (uchar) length;
  if (max_length > 255)				// 2 byte length
    *to++= (uchar) (length >> 8);
8196
  memcpy(to, from, length);
8197 8198 8199 8200
  ptr=save;					// Restore org row pointer
  return to+length;
}

8201

8202
/**
8203 8204
  Unpack a blob key into a record buffer.

8205 8206 8207 8208 8209 8210 8211 8212
  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.
8213 8214


8215 8216 8217 8218 8219
  @param to                          Pointer into the record buffer.
  @param from                        Pointer to the packed key.
  @param max_length                  Key length limit from key description.

  @return
8220 8221 8222
    Pointer into 'from' past the last byte copied from packed key.
*/

8223 8224 8225
const uchar *
Field_blob::unpack_key(uchar *to, const uchar *from, uint max_length,
                       bool low_byte_first __attribute__((unused)))
8226 8227
{
  /* get length of the blob key */
8228
  uint32 length= *from++;
8229
  if (max_length > 255)
8230
    length+= *from++ << 8;
8231 8232 8233 8234 8235 8236 8237 8238 8239 8240 8241 8242 8243 8244

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

8245

8246
/** Create a packed key that will be used for storage from a MySQL key. */
8247

8248 8249 8250
uchar *
Field_blob::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length,
                                    bool low_byte_first __attribute__((unused)))
8251 8252
{
  uint length=uint2korr(from);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8253 8254
  if (length > max_length)
    length=max_length;
8255
  *to++= (char) (length & 255);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8256
  if (max_length > 255)
8257
    *to++= (char) (length >> 8);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8258
  if (length)
8259
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8260 8261 8262
  return to+length;
}

8263

8264
uint Field_blob::packed_col_length(const uchar *data_ptr, uint length)
8265 8266
{
  if (length > 255)
8267
    return uint2korr(data_ptr)+2;
8268
  return (uint) *data_ptr + 1;
8269 8270
}

8271

8272 8273 8274 8275
uint Field_blob::max_packed_col_length(uint max_length)
{
  return (max_length > 255 ? 2 : 1)+max_length;
}
8276

8277

8278
uint Field_blob::is_equal(Create_field *new_field)
8279
{
8280
  if (field_flags_are_binary() != new_field->field_flags_are_binary())
8281 8282 8283 8284
    return 0;

  return ((new_field->sql_type == get_blob_type_from_length(max_data_length()))
          && new_field->charset == field_charset &&
8285
          new_field->pack_length == pack_length());
8286 8287 8288
}


hf@deer.(none)'s avatar
hf@deer.(none) committed
8289
#ifdef HAVE_SPATIAL
ram@mysql.r18.ru's avatar
ram@mysql.r18.ru committed
8290 8291 8292

void Field_geom::sql_type(String &res) const
{
8293 8294 8295 8296
  CHARSET_INFO *cs= &my_charset_latin1;
  switch (geom_type)
  {
    case GEOM_POINT:
8297
     res.set(STRING_WITH_LEN("point"), cs);
8298 8299
     break;
    case GEOM_LINESTRING:
8300
     res.set(STRING_WITH_LEN("linestring"), cs);
8301 8302
     break;
    case GEOM_POLYGON:
8303
     res.set(STRING_WITH_LEN("polygon"), cs);
8304 8305
     break;
    case GEOM_MULTIPOINT:
8306
     res.set(STRING_WITH_LEN("multipoint"), cs);
8307 8308
     break;
    case GEOM_MULTILINESTRING:
8309
     res.set(STRING_WITH_LEN("multilinestring"), cs);
8310 8311
     break;
    case GEOM_MULTIPOLYGON:
8312
     res.set(STRING_WITH_LEN("multipolygon"), cs);
8313 8314
     break;
    case GEOM_GEOMETRYCOLLECTION:
8315
     res.set(STRING_WITH_LEN("geometrycollection"), cs);
8316 8317
     break;
    default:
8318
     res.set(STRING_WITH_LEN("geometry"), cs);
8319
  }
ram@mysql.r18.ru's avatar
ram@mysql.r18.ru committed
8320 8321 8322
}


8323 8324 8325 8326 8327 8328 8329 8330
int Field_geom::store(double nr)
{
  my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
             ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
  return -1;
}


8331
int Field_geom::store(longlong nr, bool unsigned_val)
8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343 8344 8345 8346
{
  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;
}


ram@mysql.r18.ru's avatar
ram@mysql.r18.ru committed
8347 8348 8349 8350 8351 8352
int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
{
  if (!length)
    bzero(ptr, Field_blob::pack_length());
  else
  {
8353 8354
    if (from == Geometry::bad_geometry_data.ptr())
      goto err;
8355 8356 8357 8358
    // Check given WKB
    uint32 wkb_type;
    if (length < SRID_SIZE + WKB_HEADER_SIZE + SIZEOF_STORED_DOUBLE*2)
      goto err;
8359
    wkb_type= uint4korr(from + SRID_SIZE + 1);
8360
    if (wkb_type < (uint32) Geometry::wkb_point ||
8361
	wkb_type > (uint32) Geometry::wkb_last)
8362
      goto err;
ram@mysql.r18.ru's avatar
ram@mysql.r18.ru committed
8363 8364 8365 8366 8367 8368 8369 8370 8371
    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;
8372 8373 8374

err:
  bzero(ptr, Field_blob::pack_length());  
8375 8376
  my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
             ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
8377
  return -1;
ram@mysql.r18.ru's avatar
ram@mysql.r18.ru committed
8378 8379
}

hf@deer.(none)'s avatar
hf@deer.(none) committed
8380
#endif /*HAVE_SPATIAL*/
ram@mysql.r18.ru's avatar
ram@mysql.r18.ru committed
8381

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8382 8383 8384 8385 8386 8387 8388 8389 8390 8391 8392 8393 8394 8395 8396 8397 8398 8399 8400 8401 8402 8403 8404
/****************************************************************************
** 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
kent@mysql.com's avatar
kent@mysql.com committed
8405
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8406 8407 8408 8409 8410 8411 8412 8413 8414 8415
  {
    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
kent@mysql.com's avatar
kent@mysql.com committed
8416
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8417 8418 8419 8420 8421 8422 8423 8424 8425
  {
    int4store(ptr,value);
  }
  else
#endif
    longstore(ptr,(long) value);
  break;
  case 8:
#ifdef WORDS_BIGENDIAN
kent@mysql.com's avatar
kent@mysql.com committed
8426
  if (table->s->db_low_byte_first)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8427 8428 8429 8430 8431 8432 8433 8434 8435 8436
  {
    int8store(ptr,value);
  }
  else
#endif
    longlongstore(ptr,value); break;
  }
}


8437 8438 8439 8440
/**
  @note
    Storing a empty string in a enum field gives a warning
    (if there isn't a empty value in the enum)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8441 8442
*/

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
8443
int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8444
{
8445
  ASSERT_COLUMN_MARKED_FOR_WRITE;
8446
  int err= 0;
8447
  uint32 not_used;
8448
  char buff[STRING_BUFFER_USUAL_SIZE];
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
8449
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
8450

8451
  /* Convert character set if necessary */
8452
  if (String::needs_conversion(length, cs, field_charset, &not_used))
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
8453
  { 
8454 8455
    uint dummy_errors;
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
8456 8457 8458
    from= tmpstr.ptr();
    length=  tmpstr.length();
  }
8459 8460

  /* Remove end space */
8461
  length= field_charset->cset->lengthsp(field_charset, from, length);
8462
  uint tmp=find_type2(typelib, from, length, field_charset);
8463
  if (!tmp)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8464
  {
8465
    if (length < 6) // Can't be more than 99999 enums
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8466
    {
8467
      /* This is for reading numbers with LOAD DATA INFILE */
8468
      char *end;
8469 8470
      tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
      if (err || end != from+length || tmp > typelib->count)
8471 8472
      {
	tmp=0;
8473
	set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
8474
      }
8475 8476
      if (!table->in_use->count_cuted_fields)
        err= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8477 8478
    }
    else
8479
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8480
  }
8481
  store_type((ulonglong) tmp);
8482
  return err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8483 8484 8485
}


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
8486
int Field_enum::store(double nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8487
{
8488
  return Field_enum::store((longlong) nr, FALSE);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8489 8490 8491
}


8492
int Field_enum::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8493
{
8494
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
8495
  int error= 0;
8496
  if ((ulonglong) nr > typelib->count || nr == 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8497
  {
8498
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
8499 8500 8501 8502 8503
    if (nr != 0 || table->in_use->count_cuted_fields)
    {
      nr= 0;
      error= 1;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8504 8505
  }
  store_type((ulonglong) (uint) nr);
8506
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517
}


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


longlong Field_enum::val_int(void)
{
8518
  ASSERT_COLUMN_MARKED_FOR_READ;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8519 8520
  switch (packlength) {
  case 1:
8521
    return (longlong) ptr[0];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8522
  case 2:
8523 8524
  {
    uint16 tmp;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8525
#ifdef WORDS_BIGENDIAN
8526 8527 8528
    if (table->s->db_low_byte_first)
      tmp=sint2korr(ptr);
    else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8529
#endif
8530 8531 8532
      shortget(tmp,ptr);
    return (longlong) tmp;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8533 8534 8535
  case 3:
    return (longlong) uint3korr(ptr);
  case 4:
8536 8537
  {
    uint32 tmp;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8538
#ifdef WORDS_BIGENDIAN
8539 8540 8541
    if (table->s->db_low_byte_first)
      tmp=uint4korr(ptr);
    else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8542
#endif
8543 8544 8545
      longget(tmp,ptr);
    return (longlong) tmp;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8546
  case 8:
8547 8548
  {
    longlong tmp;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8549
#ifdef WORDS_BIGENDIAN
8550 8551 8552
    if (table->s->db_low_byte_first)
      tmp=sint8korr(ptr);
    else
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8553
#endif
8554 8555 8556
      longlongget(tmp,ptr);
    return tmp;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8557 8558 8559 8560 8561
  }
  return 0;					// impossible
}


8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580
/**
   Save the field metadata for enum fields.

   Saves the real type in the first byte and the pack length in the 
   second byte of the field metadata array at index of *metadata_ptr and
   *(metadata_ptr + 1).

   @param   metadata_ptr   First byte of field metadata

   @returns number of bytes written to metadata_ptr
*/
int Field_enum::do_save_field_metadata(uchar *metadata_ptr)
{
  *metadata_ptr= real_type();
  *(metadata_ptr + 1)= pack_length();
  return 2;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
8581 8582 8583 8584 8585
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)
monty@mysql.com's avatar
monty@mysql.com committed
8586
    val_ptr->set("", 0, field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8587 8588
  else
    val_ptr->set((const char*) typelib->type_names[tmp-1],
8589
		 typelib->type_lengths[tmp-1],
8590
		 field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8591 8592 8593
  return val_ptr;
}

8594
int Field_enum::cmp(const uchar *a_ptr, const uchar *b_ptr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8595
{
8596 8597
  uchar *old= ptr;
  ptr= (uchar*) a_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8598
  ulonglong a=Field_enum::val_int();
8599
  ptr= (uchar*) b_ptr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8600
  ulonglong b=Field_enum::val_int();
8601
  ptr= old;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8602 8603 8604
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

8605
void Field_enum::sort_string(uchar *to,uint length __attribute__((unused)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8606 8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618
{
  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
{
8619 8620 8621
  char buffer[255];
  String enum_item(buffer, sizeof(buffer), res.charset());

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8622
  res.length(0);
8623
  res.append(STRING_WITH_LEN("enum("));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8624 8625

  bool flag=0;
8626 8627
  uint *len= typelib->type_lengths;
  for (const char **pos= typelib->type_names; *pos; pos++, len++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8628
  {
8629
    uint dummy_errors;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8630 8631
    if (flag)
      res.append(',');
8632
    /* convert to res.charset() == utf8, then quote */
8633
    enum_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
8634 8635
    append_unescaped(&res, enum_item.ptr(), enum_item.length());
    flag= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8636 8637 8638 8639 8640
  }
  res.append(')');
}


8641 8642 8643 8644 8645 8646 8647 8648 8649 8650
Field *Field_enum::new_field(MEM_ROOT *root, struct st_table *new_table,
                             bool keep_type)
{
  Field_enum *res= (Field_enum*) Field::new_field(root, new_table, keep_type);
  if (res)
    res->typelib= copy_typelib(root, typelib);
  return res;
}


8651 8652 8653 8654 8655 8656 8657 8658
/*
   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.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8659 8660


monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
8661
int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8662
{
8663
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@mysql.com's avatar
monty@mysql.com committed
8664
  bool got_warning= 0;
8665
  int err= 0;
8666 8667
  char *not_used;
  uint not_used2;
8668
  uint32 not_used_offset;
8669
  char buff[STRING_BUFFER_USUAL_SIZE];
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
8670
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8671

8672
  /* Convert character set if necessary */
8673
  if (String::needs_conversion(length, cs, field_charset, &not_used_offset))
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
8674
  { 
8675 8676
    uint dummy_errors;
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
8677 8678 8679
    from= tmpstr.ptr();
    length=  tmpstr.length();
  }
8680 8681
  ulonglong tmp= find_set(typelib, from, length, field_charset,
                          &not_used, &not_used2, &got_warning);
8682 8683 8684
  if (!tmp && length && length < 22)
  {
    /* This is for reading numbers with LOAD DATA INFILE */
8685
    char *end;
8686 8687
    tmp=my_strntoull(cs,from,length,10,&end,&err);
    if (err || end != from+length ||
8688
	tmp > (ulonglong) (((longlong) 1 << typelib->count) - (longlong) 1))
8689
    {
8690
      tmp=0;      
8691
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
8692
    }
8693
  }
monty@mysql.com's avatar
monty@mysql.com committed
8694
  else if (got_warning)
8695
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
8696
  store_type(tmp);
8697
  return err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8698 8699 8700
}


8701
int Field_set::store(longlong nr, bool unsigned_val)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8702
{
8703
  ASSERT_COLUMN_MARKED_FOR_WRITE;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
8704
  int error= 0;
8705 8706
  ulonglong max_nr= set_bits(ulonglong, typelib->count);
  if ((ulonglong) nr > max_nr)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8707
  {
8708
    nr&= max_nr;
8709
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
8710
    error=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8711 8712
  }
  store_type((ulonglong) nr);
8713
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8714 8715 8716 8717 8718 8719 8720 8721 8722 8723
}


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);
8724
  val_buffer->set_charset(field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8725 8726 8727 8728 8729
  while (tmp && bitnr < (uint) typelib->count)
  {
    if (tmp & 1)
    {
      if (val_buffer->length())
8730
	val_buffer->append(&field_separator, 1, &my_charset_latin1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8731
      String str(typelib->type_names[bitnr],
8732
		 typelib->type_lengths[bitnr],
8733
		 field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8734 8735 8736 8737 8738 8739 8740 8741 8742 8743 8744
      val_buffer->append(str);
    }
    tmp>>=1;
    bitnr++;
  }
  return val_buffer;
}


void Field_set::sql_type(String &res) const
{
8745 8746 8747
  char buffer[255];
  String set_item(buffer, sizeof(buffer), res.charset());

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8748
  res.length(0);
8749
  res.append(STRING_WITH_LEN("set("));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8750 8751

  bool flag=0;
8752 8753
  uint *len= typelib->type_lengths;
  for (const char **pos= typelib->type_names; *pos; pos++, len++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8754
  {
8755
    uint dummy_errors;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8756 8757
    if (flag)
      res.append(',');
8758
    /* convert to res.charset() == utf8, then quote */
8759
    set_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
8760 8761
    append_unescaped(&res, set_item.ptr(), set_item.length());
    flag= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8762 8763 8764 8765
  }
  res.append(')');
}

8766 8767 8768 8769 8770 8771
/**
  @retval
    1  if the fields are equally defined
  @retval
    0  if the fields are unequally defined
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8772 8773 8774

bool Field::eq_def(Field *field)
{
8775
  if (real_type() != field->real_type() || charset() != field->charset() ||
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8776 8777 8778 8779 8780
      pack_length() != field->pack_length())
    return 0;
  return 1;
}

8781

8782 8783 8784 8785 8786 8787 8788 8789 8790 8791 8792 8793 8794 8795 8796 8797 8798 8799
/**
  Compare the first t1::count type names.

  @return TRUE if the type names of t1 match those of t2. FALSE otherwise.
*/

static bool compare_type_names(CHARSET_INFO *charset, TYPELIB *t1, TYPELIB *t2)
{
  for (uint i= 0; i < t1->count; i++)
    if (my_strnncoll(charset,
                     (const uchar*) t1->type_names[i],
                     t1->type_lengths[i],
                     (const uchar*) t2->type_names[i],
                     t2->type_lengths[i]))
      return FALSE;
  return TRUE;
}

8800 8801 8802 8803
/**
  @return
  returns 1 if the fields are equally defined
*/
8804

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8805 8806
bool Field_enum::eq_def(Field *field)
{
8807 8808
  TYPELIB *values;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8809
  if (!Field::eq_def(field))
8810
    return FALSE;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
8811

8812
  values= ((Field_enum*) field)->typelib;
8813

8814
  /* Definition must be strictly equal. */
8815 8816
  if (typelib->count != values->count)
    return FALSE;
8817 8818

  return compare_type_names(field_charset, typelib, values);
8819 8820 8821
}


8822 8823 8824 8825 8826 8827 8828 8829 8830
/**
  Check whether two fields can be considered 'equal' for table
  alteration purposes. Fields are equal if they retain the same
  pack length and if new members are added to the end of the list.

  @return IS_EQUAL_YES if fields are compatible.
          IS_EQUAL_NO otherwise.
*/

8831 8832
uint Field_enum::is_equal(Create_field *new_field)
{
8833 8834 8835 8836 8837 8838
  TYPELIB *values= new_field->interval;

  /*
    The fields are compatible if they have the same flags,
    type, charset and have the same underlying length.
  */
8839
  if (new_field->field_flags_are_binary() != field_flags_are_binary() ||
8840 8841 8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856 8857
      new_field->sql_type != real_type() ||
      new_field->charset != field_charset ||
      new_field->pack_length != pack_length())
    return IS_EQUAL_NO;

  /*
    Changing the definition of an ENUM or SET column by adding a new
    enumeration or set members to the end of the list of valid member
    values only alters table metadata and not table data.
  */
  if (typelib->count > values->count)
    return IS_EQUAL_NO;

  /* Check whether there are modification before the end. */
  if (! compare_type_names(field_charset, typelib, new_field->interval))
    return IS_EQUAL_NO;

  return IS_EQUAL_YES;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8858 8859
}

8860

8861 8862 8863 8864
/**
  @return
  returns 1 if the fields are equally defined
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8865
bool Field_num::eq_def(Field *field)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
8866
{
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8867 8868 8869 8870 8871
  if (!Field::eq_def(field))
    return 0;
  Field_num *from_num= (Field_num*) field;

  if (unsigned_flag != from_num->unsigned_flag ||
8872
      (zerofill && !from_num->zerofill && !zero_pack()) ||
bk@work.mysql.com's avatar
bk@work.mysql.com committed
8873 8874 8875 8876 8877 8878
      dec != from_num->dec)
    return 0;
  return 1;
}


8879
uint Field_num::is_equal(Create_field *new_field)
8880
{
8881
  return ((new_field->sql_type == real_type()) &&
8882 8883 8884 8885
	  ((new_field->flags & UNSIGNED_FLAG) == (uint) (flags &
							 UNSIGNED_FLAG)) &&
	  ((new_field->flags & AUTO_INCREMENT_FLAG) ==
	   (uint) (flags & AUTO_INCREMENT_FLAG)) &&
8886
	  (new_field->length <= max_display_length()));
8887 8888 8889
}


ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
8890 8891 8892 8893 8894 8895 8896 8897 8898 8899 8900 8901 8902 8903 8904 8905 8906 8907 8908 8909 8910 8911 8912 8913 8914 8915 8916 8917 8918
/*
  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'
*/

8919
Field_bit::Field_bit(uchar *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
monty@mysql.com's avatar
monty@mysql.com committed
8920
                     uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg,
8921
                     enum utype unireg_check_arg, const char *field_name_arg)
8922
  : Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
8923
          unireg_check_arg, field_name_arg),
8924 8925
    bit_ptr(bit_ptr_arg), bit_ofs(bit_ofs_arg), bit_len(len_arg & 7),
    bytes_in_rec(len_arg / 8)
monty@mysql.com's avatar
monty@mysql.com committed
8926
{
8927
  flags|= UNSIGNED_FLAG;
monty@mysql.com's avatar
monty@mysql.com committed
8928 8929 8930 8931 8932 8933 8934 8935 8936
  /*
    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;
}


8937 8938 8939 8940 8941 8942 8943 8944 8945 8946 8947 8948 8949 8950 8951 8952 8953
void Field_bit::hash(ulong *nr, ulong *nr2)
{
  if (is_null())
  {
    *nr^= (*nr << 1) | 1;
  }
  else
  {
    CHARSET_INFO *cs= &my_charset_bin;
    longlong value= Field_bit::val_int();
    uchar tmp[8];
    mi_int8store(tmp,value);
    cs->coll->hash_sort(cs, tmp, 8, nr, nr2);
  }
}


8954
size_t
8955 8956 8957 8958 8959 8960 8961 8962 8963 8964
Field_bit::do_last_null_byte() const
{
  /*
    Code elsewhere is assuming that bytes are 8 bits, so I'm using
    that value instead of the correct one: CHAR_BIT.

    REFACTOR SUGGESTION (Matz): Change to use the correct number of
    bits. On systems with CHAR_BIT > 8 (not very common), the storage
    will lose the extra bits.
  */
8965 8966
  DBUG_PRINT("test", ("bit_ofs: %d, bit_len: %d  bit_ptr: 0x%lx",
                      bit_ofs, bit_len, (long) bit_ptr));
8967 8968 8969 8970 8971 8972 8973 8974
  uchar *result;
  if (bit_len == 0)
    result= null_ptr;
  else if (bit_ofs + bit_len > 8)
    result= bit_ptr + 1;
  else
    result= bit_ptr;

8975
  if (result)
8976 8977
    return (size_t) (result - table->record[0]) + 1;
  return LAST_NULL_BYTE_UNDEF;
8978 8979
}

8980

monty@mysql.com's avatar
monty@mysql.com committed
8981 8982
Field *Field_bit::new_key_field(MEM_ROOT *root,
                                struct st_table *new_table,
8983
                                uchar *new_ptr, uchar *new_null_ptr,
monty@mysql.com's avatar
monty@mysql.com committed
8984 8985 8986 8987 8988 8989 8990 8991
                                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 */
8992
    res->bit_ptr= new_ptr;
monty@mysql.com's avatar
monty@mysql.com committed
8993 8994 8995 8996 8997 8998 8999 9000
    res->bit_ofs= 0;
    if (bit_len)
      res->ptr++;                               // Store rest of data here
  }
  return res;
}


9001
uint Field_bit::is_equal(Create_field *new_field) 
9002 9003 9004 9005 9006 9007
{
  return (new_field->sql_type == real_type() &&
          new_field->length == max_display_length());
}

                       
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9008 9009
int Field_bit::store(const char *from, uint length, CHARSET_INFO *cs)
{
9010
  ASSERT_COLUMN_MARKED_FOR_WRITE;
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9011 9012
  int delta;

9013
  for (; length && !*from; from++, length--) ;         // skip left 0's
9014
  delta= bytes_in_rec - length;
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9015 9016 9017 9018 9019

  if (delta < -1 ||
      (delta == -1 && (uchar) *from > ((1 << bit_len) - 1)) ||
      (!bit_len && delta < 0))
  {
9020
    set_rec_bits((1 << bit_len) - 1, bit_ptr, bit_ofs, bit_len);
9021
    memset(ptr, 0xff, bytes_in_rec);
9022 9023 9024 9025
    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);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9026 9027 9028 9029 9030 9031 9032 9033 9034 9035 9036 9037 9038 9039 9040 9041 9042 9043 9044 9045 9046 9047 9048
    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++;
    }
9049
    memcpy(ptr, from, bytes_in_rec);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9050 9051 9052 9053 9054 9055 9056
  }
  return 0;
}


int Field_bit::store(double nr)
{
9057
  return Field_bit::store((longlong) nr, FALSE);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9058 9059 9060
}


9061
int Field_bit::store(longlong nr, bool unsigned_val)
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9062 9063 9064 9065 9066 9067 9068 9069
{
  char buf[8];

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


9070 9071 9072 9073
int Field_bit::store_decimal(const my_decimal *val)
{
  int err= 0;
  longlong i= convert_decimal2longlong(val, 1, &err);
9074
  return test(err | store(i, TRUE));
9075 9076 9077
}


ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9078 9079 9080 9081 9082 9083 9084 9085
double Field_bit::val_real(void)
{
  return (double) Field_bit::val_int();
}


longlong Field_bit::val_int(void)
{
9086
  ASSERT_COLUMN_MARKED_FOR_READ;
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9087 9088
  ulonglong bits= 0;
  if (bit_len)
9089
  {
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9090
    bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
9091
    bits<<= (bytes_in_rec * 8);
9092
  }
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9093

9094
  switch (bytes_in_rec) {
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9095
  case 0: return bits;
9096
  case 1: return bits | (ulonglong) ptr[0];
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9097 9098 9099 9100 9101 9102
  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);
9103
  default: return mi_uint8korr(ptr + bytes_in_rec - sizeof(longlong));
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9104 9105 9106 9107 9108 9109 9110
  }
}  


String *Field_bit::val_str(String *val_buffer,
                           String *val_ptr __attribute__((unused)))
{
9111
  ASSERT_COLUMN_MARKED_FOR_READ;
monty@mysql.com's avatar
monty@mysql.com committed
9112
  char buff[sizeof(longlong)];
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9113 9114
  uint length= min(pack_length(), sizeof(longlong));
  ulonglong bits= val_int();
monty@mysql.com's avatar
monty@mysql.com committed
9115
  mi_int8store(buff,bits);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9116 9117

  val_buffer->alloc(length);
monty@mysql.com's avatar
monty@mysql.com committed
9118
  memcpy_fixed((char*) val_buffer->ptr(), buff+8-length, length);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9119 9120 9121 9122 9123 9124
  val_buffer->length(length);
  val_buffer->set_charset(&my_charset_bin);
  return val_buffer;
}


9125 9126
my_decimal *Field_bit::val_decimal(my_decimal *deciaml_value)
{
9127
  ASSERT_COLUMN_MARKED_FOR_READ;
9128 9129 9130 9131 9132
  int2my_decimal(E_DEC_FATAL_ERROR, val_int(), 1, deciaml_value);
  return deciaml_value;
}


9133 9134 9135 9136 9137 9138 9139 9140 9141 9142 9143 9144 9145
/*
  Compare two bit fields using pointers within the record.
  SYNOPSIS
    cmp_max()
    a                 Pointer to field->ptr in first record
    b                 Pointer to field->ptr in second record
    max_len           Maximum length used in index
  DESCRIPTION
    This method is used from key_rec_cmp used by merge sorts used
    by partitioned index read and later other similar places.
    The a and b pointer must be pointers to the field in a record
    (not the table->record[0] necessarily)
*/
9146
int Field_bit::cmp_max(const uchar *a, const uchar *b, uint max_len)
9147 9148 9149 9150 9151 9152 9153 9154 9155 9156 9157 9158 9159 9160 9161
{
  my_ptrdiff_t a_diff= a - ptr;
  my_ptrdiff_t b_diff= b - ptr;
  if (bit_len)
  {
    int flag;
    uchar bits_a= get_rec_bits(bit_ptr+a_diff, bit_ofs, bit_len);
    uchar bits_b= get_rec_bits(bit_ptr+b_diff, bit_ofs, bit_len);
    if ((flag= (int) (bits_a - bits_b)))
      return flag;
  }
  return memcmp(a, b, field_length);
}


9162
int Field_bit::key_cmp(const uchar *str, uint length)
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9163 9164 9165 9166 9167
{
  if (bit_len)
  {
    int flag;
    uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
9168
    if ((flag= (int) (bits - *str)))
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9169 9170 9171 9172
      return flag;
    str++;
    length--;
  }
ramil@mysql.com's avatar
ramil@mysql.com committed
9173
  return memcmp(ptr, str, length);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9174 9175 9176 9177 9178 9179 9180 9181 9182 9183 9184 9185 9186
}


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;
  }
9187
  return memcmp(ptr, ptr + row_offset, bytes_in_rec);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9188 9189 9190
}


9191
uint Field_bit::get_key_image(uchar *buff, uint length, imagetype type_arg)
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9192 9193 9194 9195 9196 9197 9198
{
  if (bit_len)
  {
    uchar bits= get_rec_bits(bit_ptr, bit_ofs, bit_len);
    *buff++= bits;
    length--;
  }
9199 9200 9201
  uint data_length = min(length, bytes_in_rec);
  memcpy(buff, ptr, data_length);
  return data_length + 1;
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9202 9203 9204
}


9205 9206 9207 9208 9209 9210 9211 9212 9213 9214 9215 9216 9217 9218 9219 9220 9221 9222 9223 9224 9225 9226 9227 9228 9229 9230 9231 9232 9233 9234 9235 9236 9237 9238 9239 9240 9241 9242 9243 9244 9245 9246 9247 9248 9249 9250 9251 9252 9253 9254 9255 9256 9257
/**
   Save the field metadata for bit fields.

   Saves the bit length in the first byte and bytes in record in the
   second byte of the field metadata array at index of *metadata_ptr and
   *(metadata_ptr + 1).

   @param   metadata_ptr   First byte of field metadata

   @returns number of bytes written to metadata_ptr
*/
int Field_bit::do_save_field_metadata(uchar *metadata_ptr)
{
  *metadata_ptr= bit_len;
  *(metadata_ptr + 1)= bytes_in_rec;
  return 2;
}


/**
   Returns the number of bytes field uses in row-based replication 
   row packed size.

   This method is used in row-based replication to determine the number
   of bytes that the field consumes in the row record format. This is
   used to skip fields in the master that do not exist on the slave.

   @param   field_metadata   Encoded size in field metadata

   @returns The size of the field based on the field metadata.
*/
uint Field_bit::pack_length_from_metadata(uint field_metadata)
{
  uint const from_len= (field_metadata >> 8U) & 0x00ff;
  uint const from_bit_len= field_metadata & 0x00ff;
  uint const source_size= from_len + ((from_bit_len > 0) ? 1 : 0);
  return (source_size);
}


/**
   Check to see if field size is compatible with destination.

   This method is used in row-based replication to verify that the slave's
   field size is less than or equal to the master's field size. The 
   encoded field metadata (from the master or source) is decoded and compared
   to the size of this field (the slave or destination). 

   @param   field_metadata   Encoded size in field metadata

   @retval 0 if this field's size is < the source field's size
   @retval 1 if this field's size is >= the source field's size
*/
9258 9259
int Field_bit::compatible_field_size(uint field_metadata,
                                     const Relay_log_info * __attribute__((unused)))
9260 9261 9262 9263 9264 9265 9266 9267 9268 9269 9270 9271 9272 9273 9274 9275 9276
{
  int compatible= 0;
  uint const source_size= pack_length_from_metadata(field_metadata);
  uint const destination_size= row_pack_length();
  uint const from_bit_len= field_metadata & 0x00ff;
  uint const from_len= (field_metadata >> 8U) & 0x00ff;
  if ((bit_len == 0) || (from_bit_len == 0))
    compatible= (source_size <= destination_size);
  else if (from_bit_len > bit_len)
    compatible= (from_len < bytes_in_rec);
  else
    compatible= ((from_bit_len <= bit_len) && (from_len <= bytes_in_rec));
  return (compatible);
}



ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9277 9278 9279 9280
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(),
9281
                                   "bit(%d)", (int) field_length);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9282 9283 9284 9285
  res.length((uint) length);
}


9286 9287 9288
uchar *
Field_bit::pack(uchar *to, const uchar *from, uint max_length,
                bool low_byte_first __attribute__((unused)))
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9289
{
9290
  DBUG_ASSERT(max_length > 0);
9291
  uint length;
mats@romeo.(none)'s avatar
mats@romeo.(none) committed
9292
  if (bit_len > 0)
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9293
  {
mats@romeo.(none)'s avatar
mats@romeo.(none) committed
9294 9295 9296 9297 9298 9299 9300 9301 9302 9303 9304 9305 9306 9307 9308 9309 9310 9311 9312 9313
    /*
      We have the following:

      ptr        Points into a field in record R1
      from       Points to a field in a record R2
      bit_ptr    Points to the byte (in the null bytes) that holds the
                 odd bits of R1
      from_bitp  Points to the byte that holds the odd bits of R2

      We have the following:

          ptr - bit_ptr = from - from_bitp

      We want to isolate 'from_bitp', so this gives:

          ptr - bit_ptr - from = - from_bitp
          - ptr + bit_ptr + from = from_bitp
          bit_ptr + from - ptr = from_bitp
     */
    uchar bits= get_rec_bits(bit_ptr + (from - ptr), bit_ofs, bit_len);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9314 9315
    *to++= bits;
  }
9316 9317
  length= min(bytes_in_rec, max_length - (bit_len > 0));
  memcpy(to, from, length);
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
9318 9319 9320 9321
  return to + length;
}


9322 9323 9324
/**
   Unpack a bit field from row data.

9325
   This method is used to unpack a bit field from a master whose size
9326
   of the field is less than that of the slave.
9327

9328 9329 9330 9331 9332 9333
   @param   to         Destination of the data
   @param   from       Source of the data
   @param   param_data Bit length (upper) and length (lower) values

   @return  New pointer into memory based on from + length of the data
*/
9334 9335 9336
const uchar *
Field_bit::unpack(uchar *to, const uchar *from, uint param_data,
                  bool low_byte_first __attribute__((unused)))
9337 9338 9339 9340
{
  uint const from_len= (param_data >> 8U) & 0x00ff;
  uint const from_bit_len= param_data & 0x00ff;
  /*
9341 9342
    If the parameter data is zero (i.e., undefined), or if the master
    and slave have the same sizes, then use the old unpack() method.
9343
  */
9344
  if (param_data == 0 ||
9345
      ((from_bit_len == bit_len) && (from_len == bytes_in_rec)))
9346 9347 9348 9349 9350 9351 9352 9353 9354 9355 9356 9357 9358 9359 9360 9361 9362
  {
    if (bit_len > 0)
    {
      /*
        set_rec_bits is a macro, don't put the post-increment in the
        argument since that might cause strange side-effects.

        For the choice of the second argument, see the explanation for
        Field_bit::pack().
      */
      set_rec_bits(*from, bit_ptr + (to - ptr), bit_ofs, bit_len);
      from++;
    }
    memcpy(to, from, bytes_in_rec);
    return from + bytes_in_rec;
  }

9363 9364 9365 9366 9367 9368 9369 9370 9371 9372 9373 9374 9375 9376 9377 9378 9379 9380 9381 9382 9383 9384 9385 9386 9387 9388 9389
  /*
    We are converting a smaller bit field to a larger one here.
    To do that, we first need to construct a raw value for the original
    bit value stored in the from buffer. Then that needs to be converted
    to the larger field then sent to store() for writing to the field.
    Lastly the odd bits need to be masked out if the bytes_in_rec > 0.
    Otherwise stray bits can cause spurious values.
  */
  uint new_len= (field_length + 7) / 8;
  char *value= (char *)my_alloca(new_len);
  bzero(value, new_len);
  uint len= from_len + ((from_bit_len > 0) ? 1 : 0);
  memcpy(value + (new_len - len), from, len);
  /*
    Mask out the unused bits in the partial byte. 
    TODO: Add code to the master to always mask these bits and remove
          the following.
  */
  if ((from_bit_len > 0) && (from_len > 0))
    value[new_len - len]= value[new_len - len] & ((1U << from_bit_len) - 1);
  bitmap_set_bit(table->write_set,field_index);
  store(value, new_len, system_charset_info);
  my_afree(value);
  return from + len;
}


9390 9391
void Field_bit::set_default()
{
9392 9393 9394 9395 9396 9397
  if (bit_len > 0)
  {
    my_ptrdiff_t const offset= table->s->default_values - table->record[0];
    uchar bits= get_rec_bits(bit_ptr + offset, bit_ofs, bit_len);
    set_rec_bits(bits, bit_ptr, bit_ofs, bit_len);
  }
9398 9399 9400
  Field::set_default();
}

9401 9402 9403 9404
/*
  Bit field support for non-MyISAM tables.
*/

9405
Field_bit_as_char::Field_bit_as_char(uchar *ptr_arg, uint32 len_arg,
9406 9407
                                     uchar *null_ptr_arg, uchar null_bit_arg,
                                     enum utype unireg_check_arg,
9408
                                     const char *field_name_arg)
9409
  :Field_bit(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, 0, 0,
msvensson@neptunus.(none)'s avatar
msvensson@neptunus.(none) committed
9410
             unireg_check_arg, field_name_arg)
9411
{
9412
  flags|= UNSIGNED_FLAG;
9413
  bit_len= 0;
9414
  bytes_in_rec= (len_arg + 7) / 8;
9415 9416 9417 9418 9419
}


int Field_bit_as_char::store(const char *from, uint length, CHARSET_INFO *cs)
{
9420
  ASSERT_COLUMN_MARKED_FOR_WRITE;
9421
  int delta;
9422
  uchar bits= (uchar) (field_length & 7);
9423

9424
  for (; length && !*from; from++, length--) ;         // skip left 0's
9425
  delta= bytes_in_rec - length;
9426 9427 9428 9429

  if (delta < 0 ||
      (delta == 0 && bits && (uint) (uchar) *from >= (uint) (1 << bits)))
  {
9430
    memset(ptr, 0xff, bytes_in_rec);
9431
    if (bits)
9432
      *ptr&= ((1 << bits) - 1); /* set first uchar */
9433 9434 9435 9436
    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);
9437 9438 9439 9440 9441 9442 9443 9444 9445 9446 9447 9448
    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(),
9449
                                   "bit(%d)", (int) field_length);
9450 9451 9452 9453
  res.length((uint) length);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
9454
/*****************************************************************************
9455
  Handling of field and Create_field
bk@work.mysql.com's avatar
bk@work.mysql.com committed
9456 9457
*****************************************************************************/

9458 9459
/**
  Convert create_field::length from number of characters to number of bytes.
9460 9461
*/

9462
void Create_field::create_length_to_internal_length(void)
9463
{
9464 9465 9466 9467 9468 9469 9470
  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:
9471
  case MYSQL_TYPE_VARCHAR:
9472
    length*= charset->mbmaxlen;
9473
    key_length= length;
9474
    pack_length= calc_pack_length(sql_type, length);
9475 9476 9477
    break;
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_SET:
9478
    /* Pack_length already calculated in sql_parse.cc */
9479
    length*= charset->mbmaxlen;
9480
    key_length= pack_length;
9481
    break;
monty@mysql.com's avatar
monty@mysql.com committed
9482
  case MYSQL_TYPE_BIT:
9483 9484 9485 9486 9487 9488 9489 9490 9491 9492
    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);
    }
monty@mysql.com's avatar
monty@mysql.com committed
9493
    break;
9494
  case MYSQL_TYPE_NEWDECIMAL:
9495 9496 9497 9498 9499 9500
    key_length= pack_length=
      my_decimal_get_binary_size(my_decimal_length_to_precision(length,
								decimals,
								flags &
								UNSIGNED_FLAG),
				 decimals);
9501
    break;
9502
  default:
9503
    key_length= pack_length= calc_pack_length(sql_type, length);
9504
    break;
9505 9506 9507
  }
}

9508

9509 9510 9511
/**
  Init for a tmp table field. To be extended if need be.
*/
9512
void Create_field::init_for_tmp_table(enum_field_types sql_type_arg,
9513
                                      uint32 length_arg, uint32 decimals_arg,
9514 9515 9516 9517
                                      bool maybe_null, bool is_unsigned)
{
  field_name= "";
  sql_type= sql_type_arg;
9518
  char_length= length= length_arg;;
9519 9520 9521 9522 9523
  unireg_check= Field::NONE;
  interval= 0;
  charset= &my_charset_bin;
  geom_type= Field::GEOM_GEOMETRY;
  pack_flag= (FIELDFLAG_NUMBER |
9524
              ((decimals_arg & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
9525 9526 9527 9528 9529
              (maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
              (is_unsigned ? 0 : FIELDFLAG_DECIMAL));
}


9530 9531 9532 9533 9534 9535 9536 9537 9538 9539 9540 9541 9542 9543 9544 9545 9546 9547
/**
  Initialize field definition for create.

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

  @retval
9548
    FALSE on success
9549
  @retval
9550 9551 9552
    TRUE  on error
*/

9553
bool Create_field::init(THD *thd, char *fld_name, enum_field_types fld_type,
9554 9555 9556 9557 9558 9559 9560 9561 9562
                        char *fld_length, char *fld_decimals,
                        uint fld_type_modifier, Item *fld_default_value,
                        Item *fld_on_update_value, LEX_STRING *fld_comment,
                        char *fld_change, List<String> *fld_interval_list,
                        CHARSET_INFO *fld_charset, uint fld_geom_type)
{
  uint sign_len, allowed_type_modifier= 0;
  ulong max_field_charlength= MAX_FIELD_CHARLENGTH;

9563
  DBUG_ENTER("Create_field::init()");
9564 9565 9566 9567 9568 9569 9570 9571 9572 9573 9574 9575 9576 9577 9578 9579 9580 9581 9582 9583 9584 9585 9586 9587 9588 9589
  
  field= 0;
  field_name= fld_name;
  def= fld_default_value;
  flags= fld_type_modifier;
  unireg_check= (fld_type_modifier & AUTO_INCREMENT_FLAG ?
                 Field::NEXT_NUMBER : Field::NONE);
  decimals= fld_decimals ? (uint)atoi(fld_decimals) : 0;
  if (decimals >= NOT_FIXED_DEC)
  {
    my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
             NOT_FIXED_DEC-1);
    DBUG_RETURN(TRUE);
  }

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

  comment= *fld_comment;
  /*
9590 9591
    Set NO_DEFAULT_VALUE_FLAG if this field doesn't have a default value and
    it is NOT NULL, not an AUTO_INCREMENT field and not a TIMESTAMP.
9592 9593
  */
  if (!fld_default_value && !(fld_type_modifier & AUTO_INCREMENT_FLAG) &&
9594
      (fld_type_modifier & NOT_NULL_FLAG) && fld_type != MYSQL_TYPE_TIMESTAMP)
9595 9596
    flags|= NO_DEFAULT_VALUE_FLAG;

9597
  if (fld_length != NULL)
9598 9599 9600
  {
    errno= 0;
    length= strtoul(fld_length, NULL, 10);
9601
    if ((errno != 0) || (length > MAX_FIELD_BLOBLENGTH))
9602 9603 9604 9605 9606 9607
    {
      my_error(ER_TOO_BIG_DISPLAYWIDTH, MYF(0), fld_name, MAX_FIELD_BLOBLENGTH);
      DBUG_RETURN(TRUE);
    }

    if (length == 0)
9608
      fld_length= NULL; /* purecov: inspected */
9609 9610
  }

9611 9612 9613
  sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1;

  switch (fld_type) {
9614
  case MYSQL_TYPE_TINY:
9615 9616 9617 9618
    if (!fld_length)
      length= MAX_TINYINT_WIDTH+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
9619
  case MYSQL_TYPE_SHORT:
9620 9621 9622 9623
    if (!fld_length)
      length= MAX_SMALLINT_WIDTH+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
9624
  case MYSQL_TYPE_INT24:
9625 9626 9627 9628
    if (!fld_length)
      length= MAX_MEDIUMINT_WIDTH+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
9629
  case MYSQL_TYPE_LONG:
9630 9631 9632 9633
    if (!fld_length)
      length= MAX_INT_WIDTH+sign_len;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
9634
  case MYSQL_TYPE_LONGLONG:
9635 9636 9637 9638
    if (!fld_length)
      length= MAX_BIGINT_WIDTH;
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
9639
  case MYSQL_TYPE_NULL:
9640
    break;
9641
  case MYSQL_TYPE_NEWDECIMAL:
9642
    my_decimal_trim(&length, &decimals);
9643 9644 9645 9646 9647 9648 9649 9650 9651 9652 9653 9654 9655 9656 9657 9658 9659 9660 9661 9662 9663 9664 9665 9666 9667 9668
    if (length > DECIMAL_MAX_PRECISION)
    {
      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, fld_name,
               DECIMAL_MAX_PRECISION);
      DBUG_RETURN(TRUE);
    }
    if (length < decimals)
    {
      my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
      DBUG_RETURN(TRUE);
    }
    length=
      my_decimal_precision_to_length(length, decimals,
                                     fld_type_modifier & UNSIGNED_FLAG);
    pack_length=
      my_decimal_get_binary_size(length, decimals);
    break;
  case MYSQL_TYPE_VARCHAR:
    /*
      Long VARCHAR's are automaticly converted to blobs in mysql_prepare_table
      if they don't have a default value
    */
    max_field_charlength= MAX_FIELD_VARCHARLENGTH;
    break;
  case MYSQL_TYPE_STRING:
    break;
9669 9670 9671 9672 9673
  case MYSQL_TYPE_BLOB:
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_GEOMETRY:
9674 9675 9676 9677 9678
    if (fld_default_value)
    {
      /* Allow empty as default value. */
      String str,*res;
      res= fld_default_value->val_str(&str);
9679 9680 9681 9682 9683 9684 9685
      /*
        A default other than '' is always an error, and any non-NULL
        specified default is an error in strict mode.
      */
      if (res->length() || (thd->variables.sql_mode &
                            (MODE_STRICT_TRANS_TABLES |
                             MODE_STRICT_ALL_TABLES)))
9686 9687 9688 9689 9690
      {
        my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
                 fld_name); /* purecov: inspected */
        DBUG_RETURN(TRUE);
      }
9691 9692 9693 9694 9695 9696 9697 9698 9699 9700
      else
      {
        /*
          Otherwise a default of '' is just a warning.
        */
        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                            ER_BLOB_CANT_HAVE_DEFAULT,
                            ER(ER_BLOB_CANT_HAVE_DEFAULT),
                            fld_name);
      }
9701 9702 9703 9704
      def= 0;
    }
    flags|= BLOB_FLAG;
    break;
9705
  case MYSQL_TYPE_YEAR:
9706 9707 9708 9709
    if (!fld_length || length != 2)
      length= 4; /* Default length */
    flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
    break;
9710
  case MYSQL_TYPE_FLOAT:
9711 9712 9713 9714 9715 9716 9717 9718 9719 9720 9721 9722
    /* change FLOAT(precision) to FLOAT or DOUBLE */
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    if (fld_length && !fld_decimals)
    {
      uint tmp_length= length;
      if (tmp_length > PRECISION_FOR_DOUBLE)
      {
        my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
        DBUG_RETURN(TRUE);
      }
      else if (tmp_length > PRECISION_FOR_FLOAT)
      {
9723
        sql_type= MYSQL_TYPE_DOUBLE;
9724
        length= MAX_DOUBLE_STR_LENGTH; 
9725 9726
      }
      else
9727
        length= MAX_FLOAT_STR_LENGTH; 
9728 9729 9730 9731 9732
      decimals= NOT_FIXED_DEC;
      break;
    }
    if (!fld_length && !fld_decimals)
    {
9733
      length=  MAX_FLOAT_STR_LENGTH;
9734 9735 9736 9737 9738 9739 9740 9741 9742
      decimals= NOT_FIXED_DEC;
    }
    if (length < decimals &&
        decimals != NOT_FIXED_DEC)
    {
      my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
      DBUG_RETURN(TRUE);
    }
    break;
9743
  case MYSQL_TYPE_DOUBLE:
9744 9745 9746 9747 9748 9749 9750 9751 9752 9753 9754 9755 9756
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    if (!fld_length && !fld_decimals)
    {
      length= DBL_DIG+7;
      decimals= NOT_FIXED_DEC;
    }
    if (length < decimals &&
        decimals != NOT_FIXED_DEC)
    {
      my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
      DBUG_RETURN(TRUE);
    }
    break;
9757
  case MYSQL_TYPE_TIMESTAMP:
9758
    if (fld_length == NULL)
9759
    {
9760
      length= MAX_DATETIME_WIDTH;
9761 9762
    }
    else if (length != MAX_DATETIME_WIDTH)
9763 9764 9765
    {
      /*
        We support only even TIMESTAMP lengths less or equal than 14
9766 9767
        and 19 as length of 4.1 compatible representation.  Silently 
        shrink it to MAX_DATETIME_COMPRESSED_WIDTH.
9768
      */
cmiller@zippy.cornsilk.net's avatar
cmiller@zippy.cornsilk.net committed
9769
      DBUG_ASSERT(MAX_DATETIME_COMPRESSED_WIDTH < UINT_MAX);
9770 9771 9772
      if (length != UINT_MAX)  /* avoid overflow; is safe because of min() */
        length= ((length+1)/2)*2;
      length= min(length, MAX_DATETIME_COMPRESSED_WIDTH);
9773 9774
    }
    flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
9775 9776 9777 9778 9779 9780
    /*
      Since we silently rewrite down to MAX_DATETIME_COMPRESSED_WIDTH bytes,
      the parser should not raise errors unless bizzarely large. 
     */
    max_field_charlength= UINT_MAX;

9781 9782 9783 9784 9785 9786 9787 9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798 9799 9800 9801 9802 9803 9804 9805 9806 9807 9808 9809 9810 9811 9812 9813 9814 9815 9816 9817 9818
    if (fld_default_value)
    {
      /* Grammar allows only NOW() value for ON UPDATE clause */
      if (fld_default_value->type() == Item::FUNC_ITEM && 
          ((Item_func*)fld_default_value)->functype() == Item_func::NOW_FUNC)
      {
        unireg_check= (fld_on_update_value ? Field::TIMESTAMP_DNUN_FIELD:
                                             Field::TIMESTAMP_DN_FIELD);
        /*
          We don't need default value any longer moreover it is dangerous.
          Everything handled by unireg_check further.
        */
        def= 0;
      }
      else
        unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD:
                                             Field::NONE);
    }
    else
    {
      /*
        If we have default TIMESTAMP NOT NULL column without explicit DEFAULT
        or ON UPDATE values then for the sake of compatiblity we should treat
        this column as having DEFAULT NOW() ON UPDATE NOW() (when we don't
        have another TIMESTAMP column with auto-set option before this one)
        or DEFAULT 0 (in other cases).
        So here we are setting TIMESTAMP_OLD_FIELD only temporary, and will
        replace this value by TIMESTAMP_DNUN_FIELD or NONE later when
        information about all TIMESTAMP fields in table will be availiable.

        If we have TIMESTAMP NULL column without explicit DEFAULT value
        we treat it as having DEFAULT NULL attribute.
      */
      unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD :
                     (flags & NOT_NULL_FLAG ? Field::TIMESTAMP_OLD_FIELD :
                                              Field::NONE));
    }
    break;
9819
  case MYSQL_TYPE_DATE:
9820 9821
    /* Old date type. */
    if (protocol_version != PROTOCOL_VERSION-1)
9822
      sql_type= MYSQL_TYPE_NEWDATE;
9823
    /* fall trough */
9824
  case MYSQL_TYPE_NEWDATE:
9825
    length= MAX_DATE_WIDTH;
9826
    break;
9827
  case MYSQL_TYPE_TIME:
9828 9829
    length= 10;
    break;
9830
  case MYSQL_TYPE_DATETIME:
9831
    length= MAX_DATETIME_WIDTH;
9832
    break;
9833
  case MYSQL_TYPE_SET:
9834 9835 9836 9837 9838 9839 9840 9841 9842 9843 9844 9845 9846 9847 9848
    {
      pack_length= get_set_pack_length(fld_interval_list->elements);

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

      List_iterator<String> it(*fld_interval_list);
      String *tmp;
      while ((tmp= it++))
        interval_list.push_back(tmp);
9858
      length= 1; /* See comment for MYSQL_TYPE_SET above. */
9859 9860 9861 9862 9863 9864 9865 9866 9867 9868 9869 9870 9871 9872 9873 9874 9875 9876
      break;
   }
  case MYSQL_TYPE_VAR_STRING:
    DBUG_ASSERT(0);  /* Impossible. */
    break;
  case MYSQL_TYPE_BIT:
    {
      if (!fld_length)
        length= 1;
      if (length > MAX_BIT_FIELD_LENGTH)
      {
        my_error(ER_TOO_BIG_DISPLAYWIDTH, MYF(0), fld_name,
                 MAX_BIT_FIELD_LENGTH);
        DBUG_RETURN(TRUE);
      }
      pack_length= (length + 7) / 8;
      break;
    }
9877
  case MYSQL_TYPE_DECIMAL:
9878 9879
    DBUG_ASSERT(0); /* Was obsolete */
  }
9880 9881
  /* Remember the value of length */
  char_length= length;
9882 9883

  if (!(flags & BLOB_FLAG) &&
9884 9885
      ((length > max_field_charlength && fld_type != MYSQL_TYPE_SET &&
        fld_type != MYSQL_TYPE_ENUM &&
9886
        (fld_type != MYSQL_TYPE_VARCHAR || fld_default_value)) ||
9887
       ((length == 0) &&
9888
        fld_type != MYSQL_TYPE_STRING &&
9889
        fld_type != MYSQL_TYPE_VARCHAR && fld_type != MYSQL_TYPE_GEOMETRY)))
9890 9891 9892 9893 9894 9895 9896 9897 9898 9899 9900 9901 9902 9903 9904 9905
  {
    my_error((fld_type == MYSQL_TYPE_VAR_STRING ||
              fld_type == MYSQL_TYPE_VARCHAR ||
              fld_type == MYSQL_TYPE_STRING) ?  ER_TOO_BIG_FIELDLENGTH :
                                                ER_TOO_BIG_DISPLAYWIDTH,
              MYF(0),
              fld_name, max_field_charlength); /* purecov: inspected */
    DBUG_RETURN(TRUE);
  }
  fld_type_modifier&= AUTO_INCREMENT_FLAG;
  if ((~allowed_type_modifier) & fld_type_modifier)
  {
    my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
    DBUG_RETURN(TRUE);
  }

9906 9907 9908 9909 9910 9911 9912 9913 9914 9915 9916
  switch (fld_type) {
  case MYSQL_TYPE_DATE:
  case MYSQL_TYPE_NEWDATE:
  case MYSQL_TYPE_TIME:
  case MYSQL_TYPE_DATETIME:
  case MYSQL_TYPE_TIMESTAMP:
    charset= &my_charset_bin;
    flags|= BINCMP_FLAG;
  default: break;
  }

9917 9918 9919 9920
  DBUG_RETURN(FALSE); /* success */
}


9921 9922 9923 9924
enum_field_types get_blob_type_from_length(ulong length)
{
  enum_field_types type;
  if (length < 256)
9925
    type= MYSQL_TYPE_TINY_BLOB;
9926
  else if (length < 65536)
9927
    type= MYSQL_TYPE_BLOB;
9928
  else if (length < 256L*256L*256L)
9929
    type= MYSQL_TYPE_MEDIUM_BLOB;
9930
  else
9931
    type= MYSQL_TYPE_LONG_BLOB;
9932 9933 9934 9935
  return type;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
9936
/*
9937
  Make a field from the .frm file info
bk@work.mysql.com's avatar
bk@work.mysql.com committed
9938 9939 9940 9941 9942
*/

uint32 calc_pack_length(enum_field_types type,uint32 length)
{
  switch (type) {
9943
  case MYSQL_TYPE_VAR_STRING:
9944
  case MYSQL_TYPE_STRING:
9945
  case MYSQL_TYPE_DECIMAL:     return (length);
9946
  case MYSQL_TYPE_VARCHAR:     return (length + (length < 256 ? 1: 2));
9947 9948 9949 9950 9951 9952 9953 9954 9955 9956 9957 9958 9959 9960 9961 9962 9963 9964 9965 9966 9967 9968
  case MYSQL_TYPE_YEAR:
  case MYSQL_TYPE_TINY	: return 1;
  case MYSQL_TYPE_SHORT : return 2;
  case MYSQL_TYPE_INT24:
  case MYSQL_TYPE_NEWDATE:
  case MYSQL_TYPE_TIME:   return 3;
  case MYSQL_TYPE_TIMESTAMP:
  case MYSQL_TYPE_DATE:
  case MYSQL_TYPE_LONG	: return 4;
  case MYSQL_TYPE_FLOAT : return sizeof(float);
  case MYSQL_TYPE_DOUBLE: return sizeof(double);
  case MYSQL_TYPE_DATETIME:
  case MYSQL_TYPE_LONGLONG: return 8;	/* Don't crash if no longlong */
  case MYSQL_TYPE_NULL	: return 0;
  case MYSQL_TYPE_TINY_BLOB:	return 1+portable_sizeof_char_ptr;
  case MYSQL_TYPE_BLOB:		return 2+portable_sizeof_char_ptr;
  case MYSQL_TYPE_MEDIUM_BLOB:	return 3+portable_sizeof_char_ptr;
  case MYSQL_TYPE_LONG_BLOB:	return 4+portable_sizeof_char_ptr;
  case MYSQL_TYPE_GEOMETRY:	return 4+portable_sizeof_char_ptr;
  case MYSQL_TYPE_SET:
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_NEWDECIMAL:
9969
    abort(); return 0;                          // This shouldn't happen
9970
  case MYSQL_TYPE_BIT: return length / 8;
9971 9972
  default:
    return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
9973 9974 9975 9976 9977 9978 9979
  }
}


uint pack_length_to_packflag(uint type)
{
  switch (type) {
9980 9981 9982 9983 9984
    case 1: return f_settype((uint) MYSQL_TYPE_TINY);
    case 2: return f_settype((uint) MYSQL_TYPE_SHORT);
    case 3: return f_settype((uint) MYSQL_TYPE_INT24);
    case 4: return f_settype((uint) MYSQL_TYPE_LONG);
    case 8: return f_settype((uint) MYSQL_TYPE_LONGLONG);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
9985 9986 9987 9988 9989
  }
  return 0;					// This shouldn't happen
}


9990
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length,
9991
		  uchar *null_pos, uchar null_bit,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
9992
		  uint pack_flag,
9993
		  enum_field_types field_type,
9994
		  CHARSET_INFO *field_charset,
9995
		  Field::geometry_type geom_type,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
9996 9997
		  Field::utype unireg_check,
		  TYPELIB *interval,
9998
		  const char *field_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
9999
{
10000 10001
  uchar *UNINIT_VAR(bit_ptr);
  uchar UNINIT_VAR(bit_offset);
10002
  if (field_type == MYSQL_TYPE_BIT && !f_bit_as_char(pack_flag))
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
10003 10004 10005 10006 10007 10008 10009 10010 10011 10012
  {
    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;
    }
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
10013 10014 10015 10016 10017
  if (!f_maybe_null(pack_flag))
  {
    null_pos=0;
    null_bit=0;
  }
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
10018 10019 10020 10021
  else
  {
    null_bit= ((uchar) 1) << null_bit;
  }
10022

10023
  switch (field_type) {
10024 10025 10026 10027 10028
  case MYSQL_TYPE_DATE:
  case MYSQL_TYPE_NEWDATE:
  case MYSQL_TYPE_TIME:
  case MYSQL_TYPE_DATETIME:
  case MYSQL_TYPE_TIMESTAMP:
10029 10030
    field_charset= &my_charset_bin;
  default: break;
10031 10032
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
10033 10034 10035
  if (f_is_alpha(pack_flag))
  {
    if (!f_is_packed(pack_flag))
monty@mysql.com's avatar
monty@mysql.com committed
10036
    {
10037
      if (field_type == MYSQL_TYPE_STRING ||
10038
          field_type == MYSQL_TYPE_DECIMAL ||   // 3.23 or 4.0 string
10039
          field_type == MYSQL_TYPE_VAR_STRING)
monty@mysql.com's avatar
monty@mysql.com committed
10040
        return new Field_string(ptr,field_length,null_pos,null_bit,
10041
                                unireg_check, field_name,
monty@mysql.com's avatar
monty@mysql.com committed
10042
                                field_charset);
10043
      if (field_type == MYSQL_TYPE_VARCHAR)
10044 10045 10046
        return new Field_varstring(ptr,field_length,
                                   HA_VARCHAR_PACKLENGTH(field_length),
                                   null_pos,null_bit,
10047 10048
                                   unireg_check, field_name,
                                   share,
10049
                                   field_charset);
monty@mysql.com's avatar
monty@mysql.com committed
10050 10051
      return 0;                                 // Error
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10052 10053 10054 10055 10056

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

hf@deer.(none)'s avatar
hf@deer.(none) committed
10057
#ifdef HAVE_SPATIAL
10058 10059
    if (f_is_geom(pack_flag))
      return new Field_geom(ptr,null_pos,null_bit,
10060
			    unireg_check, field_name, share,
10061
			    pack_length, geom_type);
hf@deer.(none)'s avatar
hf@deer.(none) committed
10062
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10063 10064
    if (f_is_blob(pack_flag))
      return new Field_blob(ptr,null_pos,null_bit,
10065
			    unireg_check, field_name, share,
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
10066
			    pack_length, field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10067 10068 10069 10070
    if (interval)
    {
      if (f_is_enum(pack_flag))
	return new Field_enum(ptr,field_length,null_pos,null_bit,
10071
				  unireg_check, field_name,
10072
				  pack_length, interval, field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10073 10074
      else
	return new Field_set(ptr,field_length,null_pos,null_bit,
10075
			     unireg_check, field_name,
10076
			     pack_length, interval, field_charset);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10077 10078 10079
    }
  }

10080
  switch (field_type) {
10081
  case MYSQL_TYPE_DECIMAL:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10082
    return new Field_decimal(ptr,field_length,null_pos,null_bit,
10083
			     unireg_check, field_name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10084 10085 10086
			     f_decimals(pack_flag),
			     f_is_zerofill(pack_flag) != 0,
			     f_is_dec(pack_flag) == 0);
10087
  case MYSQL_TYPE_NEWDECIMAL:
10088
    return new Field_new_decimal(ptr,field_length,null_pos,null_bit,
10089
                                 unireg_check, field_name,
10090 10091 10092
                                 f_decimals(pack_flag),
                                 f_is_zerofill(pack_flag) != 0,
                                 f_is_dec(pack_flag) == 0);
10093
  case MYSQL_TYPE_FLOAT:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10094
    return new Field_float(ptr,field_length,null_pos,null_bit,
10095
			   unireg_check, field_name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10096 10097 10098
			   f_decimals(pack_flag),
			   f_is_zerofill(pack_flag) != 0,
			   f_is_dec(pack_flag)== 0);
10099
  case MYSQL_TYPE_DOUBLE:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10100
    return new Field_double(ptr,field_length,null_pos,null_bit,
10101
			    unireg_check, field_name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10102 10103 10104
			    f_decimals(pack_flag),
			    f_is_zerofill(pack_flag) != 0,
			    f_is_dec(pack_flag)== 0);
10105
  case MYSQL_TYPE_TINY:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10106
    return new Field_tiny(ptr,field_length,null_pos,null_bit,
10107
			  unireg_check, field_name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10108 10109
			  f_is_zerofill(pack_flag) != 0,
			  f_is_dec(pack_flag) == 0);
10110
  case MYSQL_TYPE_SHORT:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10111
    return new Field_short(ptr,field_length,null_pos,null_bit,
10112
			   unireg_check, field_name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10113 10114
			   f_is_zerofill(pack_flag) != 0,
			   f_is_dec(pack_flag) == 0);
10115
  case MYSQL_TYPE_INT24:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10116
    return new Field_medium(ptr,field_length,null_pos,null_bit,
10117
			    unireg_check, field_name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10118 10119
			    f_is_zerofill(pack_flag) != 0,
			    f_is_dec(pack_flag) == 0);
10120
  case MYSQL_TYPE_LONG:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10121
    return new Field_long(ptr,field_length,null_pos,null_bit,
10122
			   unireg_check, field_name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10123 10124
			   f_is_zerofill(pack_flag) != 0,
			   f_is_dec(pack_flag) == 0);
10125
  case MYSQL_TYPE_LONGLONG:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10126
    return new Field_longlong(ptr,field_length,null_pos,null_bit,
10127
			      unireg_check, field_name,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10128 10129
			      f_is_zerofill(pack_flag) != 0,
			      f_is_dec(pack_flag) == 0);
10130
  case MYSQL_TYPE_TIMESTAMP:
10131
    return new Field_timestamp(ptr,field_length, null_pos, null_bit,
10132
                               unireg_check, field_name, share,
10133
                               field_charset);
10134
  case MYSQL_TYPE_YEAR:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10135
    return new Field_year(ptr,field_length,null_pos,null_bit,
10136
			  unireg_check, field_name);
10137
  case MYSQL_TYPE_DATE:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10138
    return new Field_date(ptr,null_pos,null_bit,
10139
			  unireg_check, field_name, field_charset);
10140
  case MYSQL_TYPE_NEWDATE:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10141
    return new Field_newdate(ptr,null_pos,null_bit,
10142
			     unireg_check, field_name, field_charset);
10143
  case MYSQL_TYPE_TIME:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10144
    return new Field_time(ptr,null_pos,null_bit,
10145
			  unireg_check, field_name, field_charset);
10146
  case MYSQL_TYPE_DATETIME:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10147
    return new Field_datetime(ptr,null_pos,null_bit,
10148
			      unireg_check, field_name, field_charset);
10149
  case MYSQL_TYPE_NULL:
10150 10151
    return new Field_null(ptr, field_length, unireg_check, field_name,
                          field_charset);
10152
  case MYSQL_TYPE_BIT:
10153
    return f_bit_as_char(pack_flag) ?
10154
           new Field_bit_as_char(ptr, field_length, null_pos, null_bit,
10155
                                 unireg_check, field_name) :
10156
           new Field_bit(ptr, field_length, null_pos, null_bit, bit_ptr,
10157
                         bit_offset, unireg_check, field_name);
10158

10159 10160
  default:					// Impossible (Wrong version)
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10161
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
10162
  return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10163 10164 10165
}


10166
/** Create a field suitable for create of table. */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10167

10168
Create_field::Create_field(Field *old_field,Field *orig_field)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10169 10170 10171 10172 10173 10174 10175
{
  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();
10176
  key_length= old_field->key_length();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10177
  sql_type=   old_field->real_type();
10178 10179
  charset=    old_field->charset();		// May be NULL ptr
  comment=    old_field->comment;
10180
  decimals=   old_field->decimals();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10181 10182 10183

  /* Fix if the original table had 4 byte pointer blobs */
  if (flags & BLOB_FLAG)
10184
    pack_length= (pack_length- old_field->table->s->blob_ptr_size +
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10185
		  portable_sizeof_char_ptr);
10186

10187
  switch (sql_type) {
10188
  case MYSQL_TYPE_BLOB:
10189
    switch (pack_length - portable_sizeof_char_ptr) {
10190 10191 10192 10193
    case  1: sql_type= MYSQL_TYPE_TINY_BLOB; break;
    case  2: sql_type= MYSQL_TYPE_BLOB; break;
    case  3: sql_type= MYSQL_TYPE_MEDIUM_BLOB; break;
    default: sql_type= MYSQL_TYPE_LONG_BLOB; break;
10194
    }
10195
    length/= charset->mbmaxlen;
10196 10197
    key_length/= charset->mbmaxlen;
    break;
10198
  case MYSQL_TYPE_STRING:
10199
    /* Change CHAR -> VARCHAR if dynamic record length */
10200 10201 10202 10203 10204 10205 10206 10207
    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:
10208
    /* This is corrected in create_length_to_internal_length */
10209 10210 10211
    length= (length+charset->mbmaxlen-1) / charset->mbmaxlen;
    break;
#ifdef HAVE_SPATIAL
10212
  case MYSQL_TYPE_GEOMETRY:
10213 10214 10215 10216 10217
    geom_type= ((Field_geom*)old_field)->geom_type;
    break;
#endif
  default:
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10218
  }
10219

bk@work.mysql.com's avatar
bk@work.mysql.com committed
10220 10221 10222 10223
  if (flags & (ENUM_FLAG | SET_FLAG))
    interval= ((Field_enum*) old_field)->typelib;
  else
    interval=0;
10224
  def=0;
10225
  char_length= length;
10226

10227
  if (!(flags & (NO_DEFAULT_VALUE_FLAG | BLOB_FLAG)) &&
10228
      old_field->ptr && orig_field &&
10229
      (sql_type != MYSQL_TYPE_TIMESTAMP ||                /* set def only if */
10230 10231
       old_field->table->timestamp_field != old_field ||  /* timestamp field */ 
       unireg_check == Field::TIMESTAMP_UN_FIELD))        /* has default val */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10232
  {
10233 10234
    char buff[MAX_FIELD_WIDTH];
    String tmp(buff,sizeof(buff), charset);
10235
    my_ptrdiff_t diff;
10236

10237
    /* Get the value from default_values */
10238 10239
    diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
                          orig_field->table->record[0]);
10240
    orig_field->move_field_offset(diff);	// Points now at default_values
10241
    if (!orig_field->is_real_null())
10242
    {
10243 10244
      char buff[MAX_FIELD_WIDTH], *pos;
      String tmp(buff, sizeof(buff), charset), *res;
10245
      res= orig_field->val_str(&tmp);
10246 10247
      pos= (char*) sql_strmake(res->ptr(), res->length());
      def= new Item_string(pos, res->length(), charset);
10248
    }
10249
    orig_field->move_field_offset(-diff);	// Back to record[0]
bk@work.mysql.com's avatar
bk@work.mysql.com committed
10250 10251
  }
}
10252 10253


10254 10255
/**
  maximum possible display length for blob.
10256

10257
  @return
10258 10259
    length
*/
10260 10261

uint32 Field_blob::max_display_length()
10262 10263 10264 10265
{
  switch (packlength)
  {
  case 1:
10266
    return 255 * field_charset->mbmaxlen;
10267
  case 2:
10268
    return 65535 * field_charset->mbmaxlen;
10269
  case 3:
10270
    return 16777215 * field_charset->mbmaxlen;
10271 10272 10273 10274 10275 10276 10277 10278 10279 10280 10281 10282
  case 4:
    return (uint32) 4294967295U;
  default:
    DBUG_ASSERT(0); // we should never go here
    return 0;
  }
}


/*****************************************************************************
 Warning handling
*****************************************************************************/
10283

10284 10285
/**
  Produce warning or note about data saved into field.
10286

10287 10288 10289
  @param level            - level of message (Note/Warning/Error)
  @param code             - error code of message to be produced
  @param cuted_increment  - whenever we should increase cut fields count or not
10290

10291
  @note
10292
    This function won't produce warning and increase cut fields counter
10293 10294 10295 10296
    if count_cuted_fields == CHECK_FIELD_IGNORE for current thread.

    if count_cuted_fields == CHECK_FIELD_IGNORE then we ignore notes.
    This allows us to avoid notes in optimisation, like convert_constant_item().
10297

10298
  @retval
10299
    1 if count_cuted_fields == CHECK_FIELD_IGNORE and error level is not NOTE
10300
  @retval
10301
    0 otherwise
10302
*/
10303

10304
bool 
10305 10306
Field::set_warning(MYSQL_ERROR::enum_warning_level level, uint code,
                   int cuted_increment)
10307
{
10308 10309 10310 10311 10312
  /*
    If this field was created only for type conversion purposes it
    will have table == NULL.
  */
  THD *thd= table ? table->in_use : current_thd;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
10313 10314
  if (thd->count_cuted_fields)
  {
10315
    thd->cuted_fields+= cuted_increment;
10316 10317
    push_warning_printf(thd, level, code, ER(code), field_name,
                        thd->row_count);
10318 10319
    return 0;
  }
10320
  return level >= MYSQL_ERROR::WARN_LEVEL_WARN;
10321 10322 10323
}


10324 10325 10326 10327 10328 10329 10330 10331 10332 10333 10334 10335 10336
/**
  Produce warning or note about datetime string data saved into field.

  @param level            level of message (Note/Warning/Error)
  @param code             error code of message to be produced
  @param str              string value which we tried to save
  @param str_length       length of string which we tried to save
  @param ts_type          type of datetime value (datetime/date/time)
  @param 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
10337 10338
    thread.
*/
10339

10340
void 
10341
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
10342 10343 10344
                            const char *str, uint str_length, 
                            timestamp_type ts_type, int cuted_increment)
{
evgen@moonbone.local's avatar
evgen@moonbone.local committed
10345
  THD *thd= table ? table->in_use : current_thd;
10346 10347
  if ((thd->really_abort_on_warning() &&
       level >= MYSQL_ERROR::WARN_LEVEL_WARN) ||
10348
      set_warning(level, code, cuted_increment))
10349
    make_truncated_value_warning(thd, level, str, str_length, ts_type,
10350
                                 field_name);
10351 10352 10353
}


10354 10355
/**
  Produce warning or note about integer datetime value saved into field.
10356

10357 10358 10359 10360 10361 10362 10363 10364 10365
  @param level            level of message (Note/Warning/Error)
  @param code             error code of message to be produced
  @param nr               numeric value which we tried to save
  @param ts_type          type of datetime value (datetime/date/time)
  @param 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
10366 10367
    thread.
*/
10368

10369
void 
10370
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
10371 10372 10373
                            longlong nr, timestamp_type ts_type,
                            int cuted_increment)
{
evgen@moonbone.local's avatar
evgen@moonbone.local committed
10374 10375
  THD *thd= table ? table->in_use : current_thd;
  if (thd->really_abort_on_warning() ||
10376
      set_warning(level, code, cuted_increment))
10377 10378 10379
  {
    char str_nr[22];
    char *str_end= longlong10_to_str(nr, str_nr, -10);
10380
    make_truncated_value_warning(thd, level, str_nr, (uint) (str_end - str_nr), 
10381
                                 ts_type, field_name);
10382 10383 10384 10385
  }
}


10386 10387
/**
  Produce warning or note about double datetime data saved into field.
10388

10389 10390 10391 10392 10393 10394 10395 10396
  @param level            level of message (Note/Warning/Error)
  @param code             error code of message to be produced
  @param nr               double value which we tried to save
  @param 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
10397 10398
    thread.
*/
10399

10400
void 
10401
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
10402 10403
                            double nr, timestamp_type ts_type)
{
evgen@moonbone.local's avatar
evgen@moonbone.local committed
10404 10405
  THD *thd= table ? table->in_use : current_thd;
  if (thd->really_abort_on_warning() ||
10406
      set_warning(level, code, 1))
10407 10408 10409 10410
  {
    /* 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));
10411
    make_truncated_value_warning(thd, level, str_nr, str_len, ts_type,
10412
                                 field_name);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
10413
  }
10414
}