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

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


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

#ifdef __GNUC__
#pragma implementation				// gcc: Class implementation
#endif

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

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

unknown's avatar
unknown committed
37
/*****************************************************************************
38
  Instansiate templates and static variables
unknown's avatar
unknown committed
39 40 41 42 43 44 45 46 47 48
*****************************************************************************/

#ifdef __GNUC__
template class List<create_field>;
template class List_iterator<create_field>;
#endif

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

49 50
#define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE 320

unknown's avatar
unknown committed
51
/*****************************************************************************
52
  Static help functions
unknown's avatar
unknown committed
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
*****************************************************************************/

void Field_num::prepend_zeros(String *value)
{
  int diff;
  if ((diff= (int) (field_length - value->length())) > 0)
  {
    bmove_upp((char*) value->ptr()+field_length,value->ptr()+value->length(),
	      value->length());
    bfill((char*) value->ptr(),diff,'0');
    value->length(field_length);
    (void) value->c_ptr_quick();		// Avoid warnings in purify
  }
}

/*
69
  Test if given number is a int (or a fixed format float with .000)
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

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

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

  TODO
    Make this multi-byte-character safe

  RETURN
    0	ok
    1	error
unknown's avatar
unknown committed
87 88
*/

89 90
bool test_if_int(const char *str, int length, const char *int_end,
		 CHARSET_INFO *cs)
unknown's avatar
unknown committed
91
{
92 93
  if (str == int_end)
    return 0;					// Empty string
unknown's avatar
unknown committed
94
  const char *end=str+length;
95 96
  if ((str= int_end) == end)
    return 1;					// All digits was used
unknown's avatar
unknown committed
97

98 99
  /* Allow end .0000 */
  if (*str == '.')
unknown's avatar
unknown committed
100
  {
101 102 103 104 105 106 107
    for (str++ ; str != end && *str == '0'; str++) ;
  }
  /* Allow end space */
  for (str++ ; str != end ; str++)
  {
    if (!my_isspace(cs,*str))
      return 0;
unknown's avatar
unknown committed
108 109 110 111
  }
  return 1;
}

unknown's avatar
unknown committed
112
#ifdef NOT_USED
113
static bool test_if_real(const char *str,int length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
114
{
115
  cs= system_charset_info; // QQ move test_if_real into CHARSET_INFO struct
116 117

  while (length && my_isspace(cs,*str))
unknown's avatar
unknown committed
118 119 120 121 122 123 124 125
  {						// Allow start space
    length--; str++;
  }
  if (!length)
    return 0;
  if (*str == '+' || *str == '-')
  {
    length--; str++;
126
    if (!length || !(my_isdigit(cs,*str) || *str == '.'))
unknown's avatar
unknown committed
127 128
      return 0;
  }
129
  while (length && my_isdigit(cs,*str))
unknown's avatar
unknown committed
130 131 132 133 134 135 136 137
  {
    length--; str++;
  }
  if (!length)
    return 1;
  if (*str == '.')
  {
    length--; str++;
138
    while (length && my_isdigit(cs,*str))
unknown's avatar
unknown committed
139 140 141 142 143 144 145 146
    {
      length--; str++;
    }
  }
  if (!length)
    return 1;
  if (*str == 'E' || *str == 'e')
  {
147
    if (length < 3 || (str[1] != '+' && str[1] != '-') || 
148
        !my_isdigit(cs,str[2]))
unknown's avatar
unknown committed
149 150 151
      return 0;
    length-=3;
    str+=3;
152
    while (length && my_isdigit(cs,*str))
unknown's avatar
unknown committed
153 154 155 156
    {
      length--; str++;
    }
  }
157
  for (; length ; length--, str++)
unknown's avatar
unknown committed
158
  {						// Allow end space
159
    if (!my_isspace(cs,*str))
unknown's avatar
unknown committed
160 161 162 163
      return 0;
  }
  return 1;
}
unknown's avatar
unknown committed
164
#endif
unknown's avatar
unknown committed
165

166

unknown's avatar
unknown committed
167 168 169 170 171 172 173 174
/*
 Tables of filed type compatibility.

 There are tables for every type, table consist of list of types in which
 given type can be converted without data lost, list should be ended with
 FIELD_CAST_STOP
*/
static Field::field_cast_enum field_cast_decimal[]=
175 176
{Field::FIELD_CAST_DECIMAL,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
unknown's avatar
unknown committed
177 178
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_tiny[]=
179 180
{Field::FIELD_CAST_TINY,
 Field::FIELD_CAST_SHORT, Field::FIELD_CAST_MEDIUM, Field::FIELD_CAST_LONG,
unknown's avatar
unknown committed
181 182 183 184 185
 Field::FIELD_CAST_LONGLONG,
 Field::FIELD_CAST_FLOAT, Field::FIELD_CAST_DOUBLE,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_short[]=
186 187
{Field::FIELD_CAST_SHORT,
 Field::FIELD_CAST_MEDIUM, Field::FIELD_CAST_LONG, Field::FIELD_CAST_LONGLONG,
unknown's avatar
unknown committed
188 189 190 191
 Field::FIELD_CAST_FLOAT, Field::FIELD_CAST_DOUBLE,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_medium[]=
192 193
{Field::FIELD_CAST_MEDIUM,
 Field::FIELD_CAST_LONG, Field::FIELD_CAST_LONGLONG,
unknown's avatar
unknown committed
194 195 196 197
 Field::FIELD_CAST_DOUBLE,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_long[]=
198 199
{Field::FIELD_CAST_LONG,
 Field::FIELD_CAST_LONGLONG,
unknown's avatar
unknown committed
200 201 202 203
 Field::FIELD_CAST_DOUBLE,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_longlong[]=
204 205
{Field::FIELD_CAST_LONGLONG,
 Field::FIELD_CAST_DOUBLE,
unknown's avatar
unknown committed
206 207 208
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_float[]=
209 210
{Field::FIELD_CAST_FLOAT,
 Field::FIELD_CAST_DOUBLE,
unknown's avatar
unknown committed
211 212 213
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_double[]=
214 215
{Field::FIELD_CAST_DOUBLE,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
unknown's avatar
unknown committed
216 217
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_null[]=
218 219
{Field::FIELD_CAST_NULL,
 Field::FIELD_CAST_DECIMAL, Field::FIELD_CAST_TINY, Field::FIELD_CAST_SHORT,
unknown's avatar
unknown committed
220 221 222 223 224 225 226 227 228 229
 Field::FIELD_CAST_MEDIUM, Field::FIELD_CAST_LONG, Field::FIELD_CAST_LONGLONG,
 Field::FIELD_CAST_FLOAT, Field::FIELD_CAST_DOUBLE,
 Field::FIELD_CAST_TIMESTAMP, Field::FIELD_CAST_YEAR,
 Field::FIELD_CAST_DATE, Field::FIELD_CAST_NEWDATE,
 Field::FIELD_CAST_TIME, Field::FIELD_CAST_DATETIME,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB,
 Field::FIELD_CAST_GEOM, Field::FIELD_CAST_ENUM, Field::FIELD_CAST_SET,
 Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_timestamp[]=
230 231
{Field::FIELD_CAST_TIMESTAMP,
 Field::FIELD_CAST_DATETIME,
unknown's avatar
unknown committed
232 233 234
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_year[]=
235 236
{Field::FIELD_CAST_YEAR,
 Field::FIELD_CAST_SHORT, Field::FIELD_CAST_MEDIUM, Field::FIELD_CAST_LONG,
unknown's avatar
unknown committed
237 238 239 240 241
 Field::FIELD_CAST_LONGLONG,
 Field::FIELD_CAST_FLOAT, Field::FIELD_CAST_DOUBLE,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_date[]=
242 243
{Field::FIELD_CAST_DATE,
 Field::FIELD_CAST_DATETIME,
unknown's avatar
unknown committed
244 245 246
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_newdate[]=
247 248
{Field::FIELD_CAST_NEWDATE,
 Field::FIELD_CAST_DATETIME,
unknown's avatar
unknown committed
249 250 251
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_time[]=
252 253
{Field::FIELD_CAST_TIME,
 Field::FIELD_CAST_DATETIME,
unknown's avatar
unknown committed
254 255 256
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_datetime[]=
257 258
{Field::FIELD_CAST_DATETIME,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
unknown's avatar
unknown committed
259 260
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_string[]=
261 262
{Field::FIELD_CAST_STRING,
 Field::FIELD_CAST_VARSTRING, Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
unknown's avatar
unknown committed
263
static Field::field_cast_enum field_cast_varstring[]=
264 265
{Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
unknown's avatar
unknown committed
266
static Field::field_cast_enum field_cast_blob[]=
267 268 269 270 271
{Field::FIELD_CAST_BLOB,
 Field::FIELD_CAST_STOP};
/*
  Geometrical, enum and set fields can be casted only to expressions
*/
unknown's avatar
unknown committed
272 273 274
static Field::field_cast_enum field_cast_geom[]=
{Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_enum[]=
275
{Field::FIELD_CAST_STOP};
unknown's avatar
unknown committed
276
static Field::field_cast_enum field_cast_set[]=
277
{Field::FIELD_CAST_STOP};
unknown's avatar
unknown committed
278 279 280 281 282 283 284 285 286 287 288 289 290 291
// Array of pointers on conversion table for all fields types casting
static Field::field_cast_enum *field_cast_array[]=
{0, //FIELD_CAST_STOP
 field_cast_decimal, field_cast_tiny, field_cast_short,
 field_cast_medium, field_cast_long, field_cast_longlong,
 field_cast_float, field_cast_double,
 field_cast_null,
 field_cast_timestamp, field_cast_year, field_cast_date, field_cast_newdate,
 field_cast_time, field_cast_datetime,
 field_cast_string, field_cast_varstring, field_cast_blob,
 field_cast_geom, field_cast_enum, field_cast_set
};


unknown's avatar
unknown committed
292 293 294 295 296 297 298 299 300 301 302
/*
  Check if field of given type can store a value of this field.

  SYNOPSIS
    type   type for test

  RETURN
    1 can
    0 can not
*/

unknown's avatar
unknown committed
303 304 305 306
bool Field::field_cast_compatible(Field::field_cast_enum type)
{
  DBUG_ASSERT(type != FIELD_CAST_STOP);
  Field::field_cast_enum *array= field_cast_array[field_cast_type()];
307
  while (*array != FIELD_CAST_STOP)
unknown's avatar
unknown committed
308
  {
309
    if (*(array++) == type)
unknown's avatar
unknown committed
310
      return 1;
311
  }
unknown's avatar
unknown committed
312 313 314 315
  return 0;
}


unknown's avatar
unknown committed
316 317
/****************************************************************************
** Functions for the base classes
unknown's avatar
unknown committed
318
** This is an unpacked number.
unknown's avatar
unknown committed
319 320 321
****************************************************************************/

Field::Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
unknown's avatar
unknown committed
322
	     uchar null_bit_arg,
unknown's avatar
unknown committed
323 324
	     utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg)
unknown's avatar
unknown committed
325
  :ptr(ptr_arg),null_ptr(null_ptr_arg),
326 327
   table(table_arg),orig_table(table_arg),
   table_name(table_arg ? table_arg->table_name : 0),
unknown's avatar
unknown committed
328
   field_name(field_name_arg),
unknown's avatar
unknown committed
329 330
   query_id(0), key_start(0), part_of_key(0), part_of_sortkey(0),
   unireg_check(unireg_check_arg),
unknown's avatar
unknown committed
331
   field_length(length_arg),null_bit(null_bit_arg)
unknown's avatar
unknown committed
332 333
{
  flags=null_ptr ? 0: NOT_NULL_FLAG;
unknown's avatar
unknown committed
334 335
  comment.str= (char*) "";
  comment.length=0;
unknown's avatar
unknown committed
336 337 338 339 340 341 342 343 344 345 346 347 348
}

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


void Field::copy_from_tmp(int row_offset)
{
  memcpy(ptr,ptr+row_offset,pack_length());
  if (null_ptr)
  {
unknown's avatar
unknown committed
349 350
    *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) |
			null_ptr[row_offset] & (uchar) null_bit);
unknown's avatar
unknown committed
351 352 353 354
  }
}


355
bool Field::send_binary(Protocol *protocol)
unknown's avatar
unknown committed
356 357
{
  char buff[MAX_FIELD_WIDTH];
358
  String tmp(buff,sizeof(buff),charset());
359
  val_str(&tmp);
360
  return protocol->store(tmp.ptr(), tmp.length(), tmp.charset());
unknown's avatar
unknown committed
361 362 363 364 365
}


void Field_num::add_zerofill_and_unsigned(String &res) const
{
366 367 368 369
  if (unsigned_flag)
    res.append(" unsigned");
  if (zerofill)
    res.append(" zerofill");
unknown's avatar
unknown committed
370 371 372 373
}

void Field_num::make_field(Send_field *field)
{
unknown's avatar
unknown committed
374
  /* table_cache_key is not set for temp tables */
375 376 377 378
  field->db_name= (orig_table->table_cache_key ? orig_table->table_cache_key :
		   "");
  field->org_table_name= orig_table->real_name;
  field->table_name= orig_table->table_name;
unknown's avatar
unknown committed
379
  field->col_name=field->org_col_name=field_name;
380
  field->charsetnr= charset()->number;
unknown's avatar
unknown committed
381 382 383 384 385 386 387 388 389
  field->length=field_length;
  field->type=type();
  field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
  field->decimals=dec;
}


void Field_str::make_field(Send_field *field)
{
unknown's avatar
unknown committed
390
  /* table_cache_key is not set for temp tables */
391 392 393 394
  field->db_name= (orig_table->table_cache_key ? orig_table->table_cache_key :
		   "");
  field->org_table_name= orig_table->real_name;
  field->table_name= orig_table->table_name;
unknown's avatar
unknown committed
395
  field->col_name=field->org_col_name=field_name;
396
  field->charsetnr= charset()->number;
unknown's avatar
unknown committed
397 398 399 400 401 402
  field->length=field_length;
  field->type=type();
  field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
  field->decimals=0;
}

403

unknown's avatar
unknown committed
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
uint Field::fill_cache_field(CACHE_FIELD *copy)
{
  copy->str=ptr;
  copy->length=pack_length();
  copy->blob_field=0;
  if (flags & BLOB_FLAG)
  {
    copy->blob_field=(Field_blob*) this;
    copy->strip=0;
    copy->length-=table->blob_ptr_size;
    return copy->length;
  }
  else if (!zero_pack() && (type() == FIELD_TYPE_STRING && copy->length > 4 ||
			    type() == FIELD_TYPE_VAR_STRING))
    copy->strip=1;				/* Remove end space */
  else
    copy->strip=0;
  return copy->length+(int) copy->strip;
}

424 425

bool Field::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
426 427
{
  char buff[40];
428 429
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  if (!(res=val_str(&tmp)) ||
430 431
      str_to_datetime_with_warn(res->ptr(), res->length(),
                                ltime, fuzzydate) <= MYSQL_TIMESTAMP_ERROR)
unknown's avatar
unknown committed
432 433 434 435 436 437 438
    return 1;
  return 0;
}

bool Field::get_time(TIME *ltime)
{
  char buff[40];
439 440
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  if (!(res=val_str(&tmp)) ||
441
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
unknown's avatar
unknown committed
442 443 444 445
    return 1;
  return 0;
}

446 447 448 449 450 451
/*
  This is called when storing a date in a string

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

void Field::store_time(TIME *ltime,timestamp_type type)
{
455 456 457
  char buff[MAX_DATE_STRING_REP_LENGTH];
  uint length= (uint) my_TIME_to_str(ltime, buff);
  store(buff, length, &my_charset_bin);
unknown's avatar
unknown committed
458 459 460
}


461
bool Field::optimize_range(uint idx, uint part)
unknown's avatar
unknown committed
462
{
463
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
unknown's avatar
unknown committed
464 465
}

466
/****************************************************************************
467
  Field_null, a field that always return NULL
468 469 470 471
****************************************************************************/

void Field_null::sql_type(String &res) const
{
472
  res.set_ascii("null", 4);
473 474 475
}


unknown's avatar
unknown committed
476
/****************************************************************************
unknown's avatar
unknown committed
477 478
  Functions for the Field_decimal class
  This is an number stored as a pre-space (or pre-zero) string
unknown's avatar
unknown committed
479 480 481 482 483
****************************************************************************/

void
Field_decimal::reset(void)
{
unknown's avatar
unknown committed
484
  Field_decimal::store("0",1,&my_charset_bin);
unknown's avatar
unknown committed
485 486 487 488 489
}

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

492
  set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
493
  if (negative)
unknown's avatar
unknown committed
494
  {
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
    if (!unsigned_flag)
    {
      /* Put - sign as a first digit so we'll have -999..999 or 999..999 */
      *to++ = '-';
      len--;
    }
    else
    {
      filler= '0';				// Fill up with 0
      if (!zerofill)
      {
	/*
	  Handle unsigned integer without zerofill, in which case
	  the number should be of format '   0' or '   0.000'
	*/
	uint whole_part=field_length- (dec ? dec+2 : 1);
	// Fill with spaces up to the first digit
	bfill(to, whole_part, ' ');
	to+=  whole_part;
	len-= whole_part;
	// The main code will also handle the 0 before the decimal point
      }
    }
unknown's avatar
unknown committed
518
  }
519
  bfill(to, len, filler);
unknown's avatar
unknown committed
520 521 522 523 524 525
  if (dec)
    ptr[field_length-dec-1]='.';
  return;
}


unknown's avatar
unknown committed
526
int Field_decimal::store(const char *from, uint len, CHARSET_INFO *cs)
unknown's avatar
unknown committed
527
{
528
  char buff[80];
unknown's avatar
unknown committed
529
  String tmp(buff,sizeof(buff), &my_charset_bin);
530

531 532 533
  /* Convert character set if the old one is multi byte */
  if (cs->mbmaxlen > 1)
  { 
534 535
    uint dummy_errors;
    tmp.copy(from, len, cs, &my_charset_bin, &dummy_errors);
536 537 538
    from= tmp.ptr();
    len=  tmp.length();
  }
539

540 541 542 543 544 545 546 547 548
  const char *end= from+len;
  /* The pointer where the field value starts (i.e., "where to write") */
  char *to=ptr;
  uint tmp_dec, tmp_uint;
  /*
    The sign of the number : will be 0 (means positive but sign not
    specified), '+' or '-'
  */
  char sign_char=0;
unknown's avatar
unknown committed
549
  /* The pointers where prezeros start and stop */
550
  const char *pre_zeros_from, *pre_zeros_end;
unknown's avatar
unknown committed
551
  /* The pointers where digits at the left of '.' start and stop */
552
  const char *int_digits_from, *int_digits_end;
unknown's avatar
unknown committed
553
  /* The pointers where digits at the right of '.' start and stop */
554
  const char *frac_digits_from, *frac_digits_end;
unknown's avatar
unknown committed
555
  /* The sign of the exponent : will be 0 (means no exponent), '+' or '-' */
556
  char expo_sign_char=0;
unknown's avatar
unknown committed
557
  uint exponent=0;                                // value of the exponent
558 559 560 561 562 563 564
  /*
    Pointers used when digits move from the left of the '.' to the
    right of the '.' (explained below)
  */
  const char *int_digits_tail_from;
  /* Number of 0 that need to be added at the left of the '.' (1E3: 3 zeros) */
  uint int_digits_added_zeros;
unknown's avatar
unknown committed
565 566 567 568
  /*
    Pointer used when digits move from the right of the '.' to the left
    of the '.'
  */
569
  const char *frac_digits_head_end;
unknown's avatar
unknown committed
570
  /* Number of 0 that need to be added at the right of the '.' (for 1E-3) */
571 572 573 574 575
  uint frac_digits_added_zeros;
  char *pos,*tmp_left_pos,*tmp_right_pos;
  /* Pointers that are used as limits (begin and end of the field buffer) */
  char *left_wall,*right_wall;
  char tmp_char;
unknown's avatar
unknown committed
576
  /*
577
    To remember if table->in_use->cuted_fields has already been incremented,
unknown's avatar
unknown committed
578 579
    to do that only once
  */
580 581 582 583 584 585 586 587 588
  bool is_cuted_fields_incr=0;

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

  /*
    There are three steps in this function :
unknown's avatar
unknown committed
589 590
    - parse the input string
    - modify the position of digits around the decimal dot '.' 
591
      according to the exponent value (if specified)
unknown's avatar
unknown committed
592
    - write the formatted number
593 594 595 596 597
  */

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

unknown's avatar
unknown committed
598
  /* skip pre-space */
unknown's avatar
unknown committed
599
  while (from != end && my_isspace(&my_charset_bin,*from))
unknown's avatar
unknown committed
600
    from++;
601
  if (from == end)
unknown's avatar
unknown committed
602
  {
603
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
604
    is_cuted_fields_incr=1;
unknown's avatar
unknown committed
605
  }
606
  else if (*from == '+' || *from == '-')	// Found some sign ?
unknown's avatar
unknown committed
607
  {
608
    sign_char= *from++;
unknown's avatar
unknown committed
609
    /*
610 611 612
      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
613 614 615 616
    */ 
    if (unsigned_flag)  
    { 
      if (sign_char=='-')
617
      {
618
        Field_decimal::overflow(1);
unknown's avatar
unknown committed
619
        return 1;
620
      }
621
      /* 
unknown's avatar
unknown committed
622 623
	 Defining this will not store "+" for unsigned decimal type even if
	 it is passed in numeric string. This will make some tests to fail
624 625
      */	 
#ifdef DONT_ALLOW_UNSIGNED_PLUS      
626 627
      else 
        sign_char=0;
628
#endif 	
unknown's avatar
unknown committed
629
    }
630
  }
unknown's avatar
unknown committed
631

632 633 634 635
  pre_zeros_from= from;
  for (; from!=end && *from == '0'; from++) ;	// Read prezeros
  pre_zeros_end=int_digits_from=from;      
  /* Read non zero digits at the left of '.'*/
unknown's avatar
unknown committed
636
  for (; from != end && my_isdigit(&my_charset_bin, *from) ; from++) ;
637 638 639 640 641
  int_digits_end=from;
  if (from!=end && *from == '.')		// Some '.' ?
    from++;
  frac_digits_from= from;
  /* Read digits at the right of '.' */
unknown's avatar
unknown committed
642
  for (;from!=end && my_isdigit(&my_charset_bin, *from); from++) ;
643 644 645 646 647 648 649 650 651 652
  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= '+';
    /*
653 654 655 656
      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).
657
    */
unknown's avatar
unknown committed
658
    for (;from!=end && my_isdigit(&my_charset_bin, *from); from++)
659
    {
660
      exponent=10*exponent+(*from-'0');
unknown's avatar
unknown committed
661
      if (exponent>MAX_EXPONENT)
662 663
        break;
    }
unknown's avatar
unknown committed
664
  }
665
  
unknown's avatar
unknown committed
666
  /*
667 668 669 670
    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.
    Even if this flag is not set, it's ok to increment warnings, if
    it makes the code easer to read.
unknown's avatar
unknown committed
671
  */
672

673
  if (table->in_use->count_cuted_fields)
unknown's avatar
unknown committed
674
  {
675
    // Skip end spaces
unknown's avatar
unknown committed
676
    for (;from != end && my_isspace(&my_charset_bin, *from); from++) ;
677
    if (from != end)                     // If still something left, warn
unknown's avatar
unknown committed
678
    {
679
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
680
      is_cuted_fields_incr=1;
unknown's avatar
unknown committed
681
    }
682 683 684 685 686 687
  }
  
  /*
    Now "move" digits around the decimal dot according to the exponent value,
    and add necessary zeros.
    Examples :
unknown's avatar
unknown committed
688 689 690
    - 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'
691
    - 1234.5E-3 : '234' moves at the right of '.'
unknown's avatar
unknown committed
692 693
    These moves are implemented with pointers which point at the begin
    and end of each moved segment. Examples :
694
    - 1234.5E-3 : before the code below is executed, the int_digits part is
unknown's avatar
unknown committed
695 696 697
    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'.
698
    - 1234.5E3 : before the code below is executed, the int_digits part is
unknown's avatar
unknown committed
699 700 701 702
    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).
703 704
  */
  
705
  /* 
unknown's avatar
unknown committed
706
     Below tmp_uint cannot overflow with small enough MAX_EXPONENT setting,
707
     as int_digits_added_zeros<=exponent<4G and 
708 709
     (int_digits_end-int_digits_from)<=max_allowed_packet<=2G and
     (frac_digits_from-int_digits_tail_from)<=max_allowed_packet<=2G
710 711
  */

712 713 714 715 716 717 718 719
  if (!expo_sign_char)
    tmp_uint=tmp_dec+(uint)(int_digits_end-int_digits_from);
  else if (expo_sign_char == '-') 
  {
    tmp_uint=min(exponent,(uint)(int_digits_end-int_digits_from));
    frac_digits_added_zeros=exponent-tmp_uint;
    int_digits_end -= tmp_uint;
    frac_digits_head_end=int_digits_end+tmp_uint;
unknown's avatar
unknown committed
720
    tmp_uint=tmp_dec+(uint)(int_digits_end-int_digits_from);     
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
  }
  else // (expo_sign_char=='+') 
  {
    tmp_uint=min(exponent,(uint)(frac_digits_end-frac_digits_from));
    int_digits_added_zeros=exponent-tmp_uint;
    int_digits_tail_from=frac_digits_from;
    frac_digits_from=frac_digits_from+tmp_uint;
    /*
      We "eat" the heading zeros of the 
      int_digits.int_digits_tail.int_digits_added_zeros concatenation
      (for example 0.003e3 must become 3 and not 0003)
    */
    if (int_digits_from == int_digits_end) 
    {
      /*
	There was nothing in the int_digits part, so continue
	eating int_digits_tail zeros
      */
      for (; int_digits_tail_from != frac_digits_from &&
	     *int_digits_tail_from == '0'; int_digits_tail_from++) ;
      if (int_digits_tail_from == frac_digits_from) 
      {
	// there were only zeros in int_digits_tail too
	int_digits_added_zeros=0;
      }
unknown's avatar
unknown committed
746
    }
747 748 749
    tmp_uint= (tmp_dec+(int_digits_end-int_digits_from)+
               (uint)(frac_digits_from-int_digits_tail_from)+
               int_digits_added_zeros);
750 751 752 753 754 755 756 757 758 759
  }
  
  /*
    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
  */

760
  if (field_length < tmp_uint + (int) (sign_char == '-')) 
761
  {
unknown's avatar
unknown committed
762
    // too big number, change to max or min number
763
    Field_decimal::overflow(sign_char == '-');
764
    return 1;
unknown's avatar
unknown committed
765
  }
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782
 
  /*
    Tmp_left_pos is the position where the leftmost digit of
    the int_% parts will be written
  */
  tmp_left_pos=pos=to+(uint)(field_length-tmp_uint);
  
  // Write all digits of the int_% parts
  while (int_digits_from != int_digits_end)
    *pos++ = *int_digits_from++ ;

  if (expo_sign_char == '+')
  {    
    while (int_digits_tail_from != frac_digits_from)
      *pos++= *int_digits_tail_from++;
    while (int_digits_added_zeros-- >0)
      *pos++= '0';  
unknown's avatar
unknown committed
783
  }
784 785 786 787 788 789
  /*
    Note the position where the rightmost digit of the int_% parts has been
    written (this is to later check if the int_% parts contained nothing,
    meaning an extra 0 is needed).
  */
  tmp_right_pos=pos;
unknown's avatar
unknown committed
790 791

  /*
792 793
    Step back to the position of the leftmost digit of the int_% parts,
    to write sign and fill with zeros or blanks or prezeros.
unknown's avatar
unknown committed
794
  */
795 796 797 798
  pos=tmp_left_pos-1;
  if (zerofill)
  {
    left_wall=to-1;
799
    while (pos > left_wall)			// Fill with zeros
800 801 802 803
      *pos--='0';
  }
  else
  {
unknown's avatar
unknown committed
804
    left_wall=to+(sign_char != 0)-1;
805 806
    if (!expo_sign_char)	// If exponent was specified, ignore prezeros
    {
807
      for (;pos > left_wall && pre_zeros_from !=pre_zeros_end;
808 809 810 811 812 813 814 815 816 817 818 819 820 821 822
	   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
  }
  
823 824
  /*
    Write digits of the frac_% parts ;
825
    Depending on table->in_use->count_cutted_fields, we may also want
826 827 828 829 830
    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)
  */
831
      
832 833 834
  pos=to+(uint)(field_length-tmp_dec);	// Calculate post to '.'
  right_wall=to+field_length;
  if (pos != right_wall) 
835 836
    *pos++='.';

837 838 839
  if (expo_sign_char == '-')
  {
    while (frac_digits_added_zeros-- > 0)
unknown's avatar
unknown committed
840
    {
841
      if (pos == right_wall) 
842
      {
843
        if (table->in_use->count_cuted_fields && !is_cuted_fields_incr) 
844
          break; // Go on below to see if we lose non zero digits
unknown's avatar
unknown committed
845
        return 0;
846
      }
847 848 849 850 851 852
      *pos++='0';
    }
    while (int_digits_end != frac_digits_head_end)
    {
      tmp_char= *int_digits_end++;
      if (pos == right_wall)
unknown's avatar
unknown committed
853
      {
854 855 856
        if (tmp_char != '0')			// Losing a non zero digit ?
        {
          if (!is_cuted_fields_incr)
857 858
            set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                        ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
859
          return 0;
860 861
        }
        continue;
unknown's avatar
unknown committed
862
      }
863
      *pos++= tmp_char;
unknown's avatar
unknown committed
864
    }
865
  }
866

867 868 869 870
  for (;frac_digits_from!=frac_digits_end;) 
  {
    tmp_char= *frac_digits_from++;
    if (pos == right_wall)
871
    {
872
      if (tmp_char != '0')			// Losing a non zero digit ?
873
      {
874
        if (!is_cuted_fields_incr)
875
	  set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
876
        return 0;
877
      }
878
      continue;
879
    }
880
    *pos++= tmp_char;
unknown's avatar
unknown committed
881
  }
882 883 884
      
  while (pos != right_wall)
   *pos++='0';			// Fill with zeros at right of '.'
unknown's avatar
unknown committed
885
  return 0;
unknown's avatar
unknown committed
886 887 888
}


unknown's avatar
unknown committed
889
int Field_decimal::store(double nr)
unknown's avatar
unknown committed
890 891 892 893
{
  if (unsigned_flag && nr < 0)
  {
    overflow(1);
894
    return 1;
unknown's avatar
unknown committed
895
  }
896
  
897 898
#ifdef HAVE_FINITE
  if (!finite(nr)) // Handle infinity as special case
899 900
  {
    overflow(nr < 0.0);
unknown's avatar
unknown committed
901
    return 1;
902
  }
903
#endif
unknown's avatar
unknown committed
904

unknown's avatar
unknown committed
905 906
  reg4 uint i,length;
  char fyllchar,*to;
907
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
unknown's avatar
unknown committed
908 909

  fyllchar = zerofill ? (char) '0' : (char) ' ';
unknown's avatar
unknown committed
910
#ifdef HAVE_SNPRINTF
unknown's avatar
unknown committed
911 912
  buff[sizeof(buff)-1]=0;			// Safety
  snprintf(buff,sizeof(buff)-1, "%.*f",(int) dec,nr);
913
  length=(uint) strlen(buff);
unknown's avatar
unknown committed
914
#else
915
  length=(uint) my_sprintf(buff,(buff,"%.*f",dec,nr));
unknown's avatar
unknown committed
916
#endif
unknown's avatar
unknown committed
917 918 919 920

  if (length > field_length)
  {
    overflow(nr < 0.0);
921
    return 1;
unknown's avatar
unknown committed
922 923 924 925 926 927 928
  }
  else
  {
    to=ptr;
    for (i=field_length-length ; i-- > 0 ;)
      *to++ = fyllchar;
    memcpy(to,buff,length);
929
    return 0;
unknown's avatar
unknown committed
930 931 932 933
  }
}


unknown's avatar
unknown committed
934
int Field_decimal::store(longlong nr)
unknown's avatar
unknown committed
935 936 937 938
{
  if (unsigned_flag && nr < 0)
  {
    overflow(1);
939
    return 1;
unknown's avatar
unknown committed
940 941 942 943 944 945 946 947
  }
  char buff[22];
  uint length=(uint) (longlong10_to_str(nr,buff,-10)-buff);
  uint int_part=field_length- (dec  ? dec+1 : 0);

  if (length > int_part)
  {
    overflow(test(nr < 0L));			/* purecov: inspected */
948
    return 1;
unknown's avatar
unknown committed
949 950 951 952 953 954 955 956 957 958 959 960 961
  }
  else
  {
    char fyllchar = zerofill ? (char) '0' : (char) ' ';
    char *to=ptr;
    for (uint i=int_part-length ; i-- > 0 ;)
      *to++ = fyllchar;
    memcpy(to,buff,length);
    if (dec)
    {
      to[length]='.';
      bfill(to+length+1,dec,'0');
    }
962
    return 0;
unknown's avatar
unknown committed
963 964 965 966 967 968
  }
}


double Field_decimal::val_real(void)
{
969
  int not_used;
unknown's avatar
unknown committed
970
  return my_strntod(&my_charset_bin, ptr, field_length, NULL, &not_used);
unknown's avatar
unknown committed
971 972 973 974
}

longlong Field_decimal::val_int(void)
{
975
  int not_used;
unknown's avatar
unknown committed
976
  if (unsigned_flag)
unknown's avatar
unknown committed
977
    return my_strntoull(&my_charset_bin, ptr, field_length, 10, NULL,
978
			&not_used);
unknown's avatar
unknown committed
979
  else
unknown's avatar
unknown committed
980
    return my_strntoll(&my_charset_bin, ptr, field_length, 10, NULL,
981
			&not_used);
unknown's avatar
unknown committed
982 983
}

984

unknown's avatar
unknown committed
985 986 987 988 989 990
String *Field_decimal::val_str(String *val_buffer __attribute__((unused)),
			       String *val_ptr)
{
  char *str;
  for (str=ptr ; *str == ' ' ; str++) ;
  uint tmp_length=(uint) (str-ptr);
unknown's avatar
unknown committed
991
  val_ptr->set_charset(&my_charset_bin);
unknown's avatar
unknown committed
992 993 994
  if (field_length < tmp_length)		// Error in data
    val_ptr->length(0);
  else
995
    val_ptr->set_ascii((const char*) str, field_length-tmp_length);
unknown's avatar
unknown committed
996 997 998 999 1000 1001 1002 1003 1004 1005 1006
  return val_ptr;
}

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

int Field_decimal::cmp(const char *a_ptr,const char *b_ptr)
{
  const char *end;
1007
  int swap=0;
unknown's avatar
unknown committed
1008 1009 1010 1011
  /* First remove prefixes '0', ' ', and '-' */
  for (end=a_ptr+field_length;
       a_ptr != end &&
	 (*a_ptr == *b_ptr ||
unknown's avatar
unknown committed
1012
	  ((my_isspace(&my_charset_bin,*a_ptr)  || *a_ptr == '+' || 
1013
            *a_ptr == '0') &&
unknown's avatar
unknown committed
1014
	   (my_isspace(&my_charset_bin,*b_ptr) || *b_ptr == '+' || 
1015
            *b_ptr == '0')));
1016 1017 1018 1019 1020
       a_ptr++,b_ptr++)
  {
    if (*a_ptr == '-')				// If both numbers are negative
      swap= -1 ^ 1;				// Swap result      
  }
unknown's avatar
unknown committed
1021 1022 1023
  if (a_ptr == end)
    return 0;
  if (*a_ptr == '-')
1024
    return -1;
1025
  if (*b_ptr == '-')
unknown's avatar
unknown committed
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
    return 1;

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


void Field_decimal::sort_string(char *to,uint length)
{
  char *str,*end;
  for (str=ptr,end=ptr+length;
       str != end &&
unknown's avatar
unknown committed
1042
	 ((my_isspace(&my_charset_bin,*str) || *str == '+' ||
unknown's avatar
unknown committed
1043
	   *str == '0')) ;
unknown's avatar
unknown committed
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
       str++)
    *to++=' ';
  if (str == end)
    return;					/* purecov: inspected */

  if (*str == '-')
  {
    *to++=1;					// Smaller than any number
    str++;
    while (str != end)
unknown's avatar
unknown committed
1054
      if (my_isdigit(&my_charset_bin,*str))
unknown's avatar
unknown committed
1055 1056 1057 1058 1059 1060 1061
	*to++= (char) ('9' - *str++);
      else
	*to++= *str++;
  }
  else memcpy(to,str,(uint) (end-str));
}

unknown's avatar
unknown committed
1062

unknown's avatar
unknown committed
1063 1064
void Field_decimal::sql_type(String &res) const
{
unknown's avatar
unknown committed
1065
  CHARSET_INFO *cs=res.charset();
unknown's avatar
unknown committed
1066 1067 1068 1069 1070
  uint tmp=field_length;
  if (!unsigned_flag)
    tmp--;
  if (dec)
    tmp--;
1071
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
1072
			  "decimal(%d,%d)",tmp,dec));
unknown's avatar
unknown committed
1073 1074 1075 1076 1077 1078 1079 1080
  add_zerofill_and_unsigned(res);
}


/****************************************************************************
** tiny int
****************************************************************************/

unknown's avatar
unknown committed
1081
int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
1082
{
1083
  int not_used;				// We can ignore result from str2int
1084
  char *end;
1085
  long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
unknown's avatar
unknown committed
1086
  int error= 0;
unknown's avatar
unknown committed
1087 1088 1089 1090 1091 1092

  if (unsigned_flag)
  {
    if (tmp < 0)
    {
      tmp=0; /* purecov: inspected */
1093
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1094
      error= 1;
unknown's avatar
unknown committed
1095 1096 1097 1098
    }
    else if (tmp > 255)
    {
      tmp= 255;
1099
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1100
      error= 1;
unknown's avatar
unknown committed
1101
    }
1102
    else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
1103
    {
1104
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
1105
      error= 1;
1106
    }
unknown's avatar
unknown committed
1107 1108 1109 1110 1111 1112
  }
  else
  {
    if (tmp < -128)
    {
      tmp= -128;
1113
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1114
      error= 1;
unknown's avatar
unknown committed
1115 1116 1117 1118
    }
    else if (tmp >= 128)
    {
      tmp= 127;
1119
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1120
      error= 1;
unknown's avatar
unknown committed
1121
    }
1122
    else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
1123
    {
1124
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
1125
      error= 1;
1126
    }
unknown's avatar
unknown committed
1127 1128
  }
  ptr[0]= (char) tmp;
1129
  return error;
unknown's avatar
unknown committed
1130 1131 1132
}


unknown's avatar
unknown committed
1133
int Field_tiny::store(double nr)
unknown's avatar
unknown committed
1134
{
unknown's avatar
unknown committed
1135
  int error= 0;
unknown's avatar
unknown committed
1136 1137 1138 1139 1140 1141
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0.0)
    {
      *ptr=0;
1142
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1143
      error= 1;
unknown's avatar
unknown committed
1144 1145 1146 1147
    }
    else if (nr > 255.0)
    {
      *ptr=(char) 255;
1148
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1149
      error= 1;
unknown's avatar
unknown committed
1150 1151 1152 1153 1154 1155 1156 1157 1158
    }
    else
      *ptr=(char) nr;
  }
  else
  {
    if (nr < -128.0)
    {
      *ptr= (char) -128;
1159
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1160
      error= 1;
unknown's avatar
unknown committed
1161 1162 1163 1164
    }
    else if (nr > 127.0)
    {
      *ptr=127;
1165
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1166
      error= 1;
unknown's avatar
unknown committed
1167 1168 1169 1170
    }
    else
      *ptr=(char) nr;
  }
1171
  return error;
unknown's avatar
unknown committed
1172 1173
}

unknown's avatar
unknown committed
1174
int Field_tiny::store(longlong nr)
unknown's avatar
unknown committed
1175
{
unknown's avatar
unknown committed
1176
  int error= 0;
unknown's avatar
unknown committed
1177 1178 1179 1180 1181
  if (unsigned_flag)
  {
    if (nr < 0L)
    {
      *ptr=0;
1182
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1183
      error= 1;
unknown's avatar
unknown committed
1184 1185 1186 1187
    }
    else if (nr > 255L)
    {
      *ptr= (char) 255;
1188
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1189
      error= 1;
unknown's avatar
unknown committed
1190 1191 1192 1193 1194 1195 1196 1197 1198
    }
    else
      *ptr=(char) nr;
  }
  else
  {
    if (nr < -128L)
    {
      *ptr= (char) -128;
1199
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1200
      error= 1;
unknown's avatar
unknown committed
1201 1202 1203 1204
    }
    else if (nr > 127L)
    {
      *ptr=127;
1205
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1206
      error= 1;
unknown's avatar
unknown committed
1207 1208 1209 1210
    }
    else
      *ptr=(char) nr;
  }
1211
  return error;
unknown's avatar
unknown committed
1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
}


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

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

String *Field_tiny::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
1232
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
1233
  uint length;
1234 1235
  uint mlength=max(field_length+1,5*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
1236
  char *to=(char*) val_buffer->ptr();
1237

unknown's avatar
unknown committed
1238
  if (unsigned_flag)
1239 1240
    length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
					   (long) *((uchar*) ptr));
unknown's avatar
unknown committed
1241
  else
1242 1243
    length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
					   (long) *((signed char*) ptr));
1244
  
unknown's avatar
unknown committed
1245 1246 1247 1248 1249 1250
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}

1251 1252 1253 1254
bool Field_tiny::send_binary(Protocol *protocol)
{
  return protocol->store_tiny((longlong) (int8) ptr[0]);
}
unknown's avatar
unknown committed
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274

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

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

void Field_tiny::sql_type(String &res) const
{
unknown's avatar
unknown committed
1275
  CHARSET_INFO *cs=res.charset();
1276
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
1277
			  "tinyint(%d)",(int) field_length));
unknown's avatar
unknown committed
1278 1279 1280 1281
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
1282
 Field type short int (2 byte)
unknown's avatar
unknown committed
1283 1284
****************************************************************************/

unknown's avatar
unknown committed
1285
int Field_short::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
1286
{
1287
  int not_used;				// We can ignore result from str2int
1288
  char *end;
1289
  long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
unknown's avatar
unknown committed
1290
  int error= 0;
1291

unknown's avatar
unknown committed
1292 1293 1294 1295 1296
  if (unsigned_flag)
  {
    if (tmp < 0)
    {
      tmp=0;
1297
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1298
      error= 1;
unknown's avatar
unknown committed
1299 1300 1301 1302
    }
    else if (tmp > (uint16) ~0)
    {
      tmp=(uint16) ~0;
1303
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1304
      error= 1;
unknown's avatar
unknown committed
1305
    }
1306
    else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
1307
    {
1308
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
1309
      error= 1;
1310
    }
unknown's avatar
unknown committed
1311 1312 1313 1314 1315 1316
  }
  else
  {
    if (tmp < INT_MIN16)
    {
      tmp= INT_MIN16;
1317
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1318
      error= 1;
unknown's avatar
unknown committed
1319 1320 1321 1322
    }
    else if (tmp > INT_MAX16)
    {
      tmp=INT_MAX16;
1323
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1324
      error= 1;
unknown's avatar
unknown committed
1325
    }
1326
    else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
1327
    {
1328
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
1329
      error= 1;
1330
    }
unknown's avatar
unknown committed
1331 1332 1333 1334 1335 1336 1337 1338 1339
  }
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int2store(ptr,tmp);
  }
  else
#endif
    shortstore(ptr,(short) tmp);
1340
  return error;
unknown's avatar
unknown committed
1341 1342 1343
}


unknown's avatar
unknown committed
1344
int Field_short::store(double nr)
unknown's avatar
unknown committed
1345
{
unknown's avatar
unknown committed
1346
  int error= 0;
unknown's avatar
unknown committed
1347 1348 1349 1350 1351 1352 1353
  int16 res;
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
1354
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1355
      error= 1;
unknown's avatar
unknown committed
1356 1357 1358 1359
    }
    else if (nr > (double) (uint16) ~0)
    {
      res=(int16) (uint16) ~0;
1360
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1361
      error= 1;
unknown's avatar
unknown committed
1362 1363 1364 1365 1366 1367 1368 1369 1370
    }
    else
      res=(int16) (uint16) nr;
  }
  else
  {
    if (nr < (double) INT_MIN16)
    {
      res=INT_MIN16;
1371
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1372
      error= 1;
unknown's avatar
unknown committed
1373 1374 1375 1376
    }
    else if (nr > (double) INT_MAX16)
    {
      res=INT_MAX16;
1377
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1378
      error= 1;
unknown's avatar
unknown committed
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390
    }
    else
      res=(int16) nr;
  }
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int2store(ptr,res);
  }
  else
#endif
    shortstore(ptr,res);
1391
  return error;
unknown's avatar
unknown committed
1392 1393
}

unknown's avatar
unknown committed
1394
int Field_short::store(longlong nr)
unknown's avatar
unknown committed
1395
{
unknown's avatar
unknown committed
1396
  int error= 0;
unknown's avatar
unknown committed
1397 1398 1399 1400 1401 1402
  int16 res;
  if (unsigned_flag)
  {
    if (nr < 0L)
    {
      res=0;
1403
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1404
      error= 1;
unknown's avatar
unknown committed
1405 1406 1407 1408
    }
    else if (nr > (longlong) (uint16) ~0)
    {
      res=(int16) (uint16) ~0;
1409
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1410
      error= 1;
unknown's avatar
unknown committed
1411 1412 1413 1414 1415 1416 1417 1418 1419
    }
    else
      res=(int16) (uint16) nr;
  }
  else
  {
    if (nr < INT_MIN16)
    {
      res=INT_MIN16;
1420
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1421
      error= 1;
unknown's avatar
unknown committed
1422 1423 1424 1425
    }
    else if (nr > INT_MAX16)
    {
      res=INT_MAX16;
1426
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1427
      error= 1;
unknown's avatar
unknown committed
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
    }
    else
      res=(int16) nr;
  }
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int2store(ptr,res);
  }
  else
#endif
    shortstore(ptr,res);
1440
  return error;
unknown's avatar
unknown committed
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
}


double Field_short::val_real(void)
{
  short j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint2korr(ptr);
  else
#endif
    shortget(j,ptr);
  return unsigned_flag ? (double) (unsigned short) j : (double) j;
}

longlong Field_short::val_int(void)
{
  short j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint2korr(ptr);
  else
#endif
    shortget(j,ptr);
  return unsigned_flag ? (longlong) (unsigned short) j : (longlong) j;
}

1468

unknown's avatar
unknown committed
1469 1470 1471
String *Field_short::val_str(String *val_buffer,
			     String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
1472
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
1473
  uint length;
1474 1475
  uint mlength=max(field_length+1,7*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
  char *to=(char*) val_buffer->ptr();
  short j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint2korr(ptr);
  else
#endif
    shortget(j,ptr);

  if (unsigned_flag)
1486 1487
    length=(uint) cs->cset->long10_to_str(cs, to, mlength, 10, 
					  (long) (uint16) j);
unknown's avatar
unknown committed
1488
  else
1489
    length=(uint) cs->cset->long10_to_str(cs, to, mlength,-10, (long) j);
unknown's avatar
unknown committed
1490 1491 1492 1493 1494 1495 1496
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


1497 1498 1499 1500 1501 1502
bool Field_short::send_binary(Protocol *protocol)
{
  return protocol->store_short(Field_short::val_int());
}


unknown's avatar
unknown committed
1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
int Field_short::cmp(const char *a_ptr, const char *b_ptr)
{
  short a,b;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    a=sint2korr(a_ptr);
    b=sint2korr(b_ptr);
  }
  else
#endif
  {
    shortget(a,a_ptr);
    shortget(b,b_ptr);
  }

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

void Field_short::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
  if (!table->db_low_byte_first)
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
unknown's avatar
unknown committed
1533
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
1534 1535 1536 1537 1538 1539 1540 1541
    to[1]   = ptr[1];
  }
  else
#endif
  {
    if (unsigned_flag)
      to[0] = ptr[1];
    else
unknown's avatar
unknown committed
1542
      to[0] = (char) (ptr[1] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
1543 1544 1545 1546 1547 1548
    to[1]   = ptr[0];
  }
}

void Field_short::sql_type(String &res) const
{
unknown's avatar
unknown committed
1549
  CHARSET_INFO *cs=res.charset();
1550
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
1551
			  "smallint(%d)",(int) field_length));
unknown's avatar
unknown committed
1552 1553 1554 1555 1556
  add_zerofill_and_unsigned(res);
}


/****************************************************************************
1557
  Field type medium int (3 byte)
unknown's avatar
unknown committed
1558 1559
****************************************************************************/

unknown's avatar
unknown committed
1560
int Field_medium::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
1561
{
1562
  int not_used;				// We can ignore result from str2int
1563
  char *end;
1564
  long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
unknown's avatar
unknown committed
1565
  int error= 0;
unknown's avatar
unknown committed
1566 1567 1568 1569 1570 1571

  if (unsigned_flag)
  {
    if (tmp < 0)
    {
      tmp=0;
1572
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1573
      error= 1;
unknown's avatar
unknown committed
1574 1575 1576 1577
    }
    else if (tmp >= (long) (1L << 24))
    {
      tmp=(long) (1L << 24)-1L;
1578
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1579
      error= 1;
unknown's avatar
unknown committed
1580
    }
1581
    else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
1582
    {
1583
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
1584
      error= 1;
1585
    }
unknown's avatar
unknown committed
1586 1587 1588 1589 1590 1591
  }
  else
  {
    if (tmp < INT_MIN24)
    {
      tmp= INT_MIN24;
1592
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1593
      error= 1;
unknown's avatar
unknown committed
1594 1595 1596 1597
    }
    else if (tmp > INT_MAX24)
    {
      tmp=INT_MAX24;
1598
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1599
      error= 1;
unknown's avatar
unknown committed
1600
    }
1601
    else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
1602
    {
1603
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
1604
      error= 1;
1605
    }
unknown's avatar
unknown committed
1606 1607 1608
  }

  int3store(ptr,tmp);
1609
  return error;
unknown's avatar
unknown committed
1610 1611 1612
}


unknown's avatar
unknown committed
1613
int Field_medium::store(double nr)
unknown's avatar
unknown committed
1614
{
unknown's avatar
unknown committed
1615
  int error= 0;
unknown's avatar
unknown committed
1616 1617 1618 1619 1620 1621
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      int3store(ptr,0);
1622
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1623
      error= 1;
unknown's avatar
unknown committed
1624 1625 1626
    }
    else if (nr >= (double) (long) (1L << 24))
    {
unknown's avatar
unknown committed
1627
      uint32 tmp=(uint32) (1L << 24)-1L;
unknown's avatar
unknown committed
1628
      int3store(ptr,tmp);
1629
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1630
      error= 1;
unknown's avatar
unknown committed
1631 1632
    }
    else
unknown's avatar
unknown committed
1633
      int3store(ptr,(uint32) nr);
unknown's avatar
unknown committed
1634 1635 1636 1637 1638 1639 1640
  }
  else
  {
    if (nr < (double) INT_MIN24)
    {
      long tmp=(long) INT_MIN24;
      int3store(ptr,tmp);
1641
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1642
      error= 1;
unknown's avatar
unknown committed
1643 1644 1645 1646 1647
    }
    else if (nr > (double) INT_MAX24)
    {
      long tmp=(long) INT_MAX24;
      int3store(ptr,tmp);
1648
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1649
      error= 1;
unknown's avatar
unknown committed
1650 1651 1652 1653
    }
    else
      int3store(ptr,(long) nr);
  }
1654
  return error;
unknown's avatar
unknown committed
1655 1656
}

unknown's avatar
unknown committed
1657
int Field_medium::store(longlong nr)
unknown's avatar
unknown committed
1658
{
unknown's avatar
unknown committed
1659
  int error= 0;
unknown's avatar
unknown committed
1660 1661 1662 1663 1664
  if (unsigned_flag)
  {
    if (nr < 0L)
    {
      int3store(ptr,0);
1665
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1666
      error= 1;
unknown's avatar
unknown committed
1667 1668 1669 1670 1671
    }
    else if (nr >= (longlong) (long) (1L << 24))
    {
      long tmp=(long) (1L << 24)-1L;;
      int3store(ptr,tmp);
1672
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1673
      error= 1;
unknown's avatar
unknown committed
1674 1675
    }
    else
unknown's avatar
unknown committed
1676
      int3store(ptr,(uint32) nr);
unknown's avatar
unknown committed
1677 1678 1679 1680 1681 1682 1683
  }
  else
  {
    if (nr < (longlong) INT_MIN24)
    {
      long tmp=(long) INT_MIN24;
      int3store(ptr,tmp);
1684
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1685
      error= 1;
unknown's avatar
unknown committed
1686 1687 1688 1689 1690
    }
    else if (nr > (longlong) INT_MAX24)
    {
      long tmp=(long) INT_MAX24;
      int3store(ptr,tmp);
1691
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1692
      error= 1;
unknown's avatar
unknown committed
1693 1694 1695 1696
    }
    else
      int3store(ptr,(long) nr);
  }
1697
  return error;
unknown's avatar
unknown committed
1698 1699 1700 1701 1702 1703 1704 1705 1706
}


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

1707

unknown's avatar
unknown committed
1708 1709 1710 1711 1712 1713
longlong Field_medium::val_int(void)
{
  long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
  return (longlong) j;
}

1714

unknown's avatar
unknown committed
1715 1716 1717
String *Field_medium::val_str(String *val_buffer,
			      String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
1718
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
1719
  uint length;
1720 1721
  uint mlength=max(field_length+1,10*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
1722 1723 1724
  char *to=(char*) val_buffer->ptr();
  long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);

1725
  length=(uint) cs->cset->long10_to_str(cs,to,mlength,-10,j);
unknown's avatar
unknown committed
1726 1727 1728 1729 1730 1731 1732
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer); /* purecov: inspected */
  return val_buffer;
}


1733 1734 1735 1736 1737 1738
bool Field_medium::send_binary(Protocol *protocol)
{
  return protocol->store_long(Field_medium::val_int());
}


unknown's avatar
unknown committed
1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767
int Field_medium::cmp(const char *a_ptr, const char *b_ptr)
{
  long a,b;
  if (unsigned_flag)
  {
    a=uint3korr(a_ptr);
    b=uint3korr(b_ptr);
  }
  else
  {
    a=sint3korr(a_ptr);
    b=sint3korr(b_ptr);
  }
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

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


void Field_medium::sql_type(String &res) const
{
unknown's avatar
unknown committed
1768
  CHARSET_INFO *cs=res.charset();
1769
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(), 
1770
			  "mediumint(%d)",(int) field_length));
unknown's avatar
unknown committed
1771 1772 1773 1774 1775 1776 1777 1778
  add_zerofill_and_unsigned(res);
}

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


unknown's avatar
unknown committed
1779
int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
1780
{
1781
  long tmp;
unknown's avatar
unknown committed
1782
  int error= 0;
1783
  char *end;
unknown's avatar
unknown committed
1784
  
1785
  tmp= cs->cset->scan(cs, from, from+len, MY_SEQ_SPACES);
unknown's avatar
unknown committed
1786 1787
  len-= tmp;
  from+= tmp;
1788
  my_errno=0;
unknown's avatar
unknown committed
1789

unknown's avatar
unknown committed
1790 1791 1792 1793 1794
  if (unsigned_flag)
  {
    if (!len || *from == '-')
    {
      tmp=0;					// Set negative to 0
1795
      my_errno=ERANGE;
unknown's avatar
unknown committed
1796
      error= 1;
unknown's avatar
unknown committed
1797 1798
    }
    else
1799
      tmp=(long) my_strntoul(cs,from,len,10,&end,&error);
unknown's avatar
unknown committed
1800 1801
  }
  else
1802 1803
    tmp=my_strntol(cs,from,len,10,&end,&error);
  if (error ||
1804
      (from+len != end && table->in_use->count_cuted_fields &&
1805
       !test_if_int(from,len,end,cs)))
unknown's avatar
unknown committed
1806
    error= 1;
1807 1808 1809
#if SIZEOF_LONG > 4
  if (unsigned_flag)
  {
unknown's avatar
unknown committed
1810
    if ((ulong) tmp > UINT_MAX32)
1811 1812
    {
      tmp= UINT_MAX32;
unknown's avatar
unknown committed
1813 1814
      error= 1;
      my_errno=ERANGE;
1815 1816 1817 1818 1819 1820 1821
    }
  }
  else
  {
    if (tmp > INT_MAX32)
    {
      tmp= INT_MAX32;
unknown's avatar
unknown committed
1822 1823
      error= 1;
      my_errno=ERANGE;
1824 1825 1826 1827
    }
    else if (tmp < INT_MIN32)
    {
      tmp= INT_MIN32;
unknown's avatar
unknown committed
1828 1829
      error= 1;
      my_errno=ERANGE;
1830 1831 1832
    }
  }
#endif
unknown's avatar
unknown committed
1833
  if (error)
unknown's avatar
unknown committed
1834
  {
1835
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
1836
    error= 1;
1837
  }
unknown's avatar
unknown committed
1838 1839 1840 1841 1842 1843 1844 1845
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
1846
  return error;
unknown's avatar
unknown committed
1847 1848 1849
}


unknown's avatar
unknown committed
1850
int Field_long::store(double nr)
unknown's avatar
unknown committed
1851
{
unknown's avatar
unknown committed
1852
  int error= 0;
unknown's avatar
unknown committed
1853 1854 1855 1856 1857 1858 1859
  int32 res;
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
1860
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1861
      error= 1;
unknown's avatar
unknown committed
1862
    }
1863
    else if (nr > (double) UINT_MAX32)
unknown's avatar
unknown committed
1864
    {
1865
      res= UINT_MAX32;
1866
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1867
      error= 1;
unknown's avatar
unknown committed
1868 1869 1870 1871 1872 1873 1874 1875 1876
    }
    else
      res=(int32) (ulong) nr;
  }
  else
  {
    if (nr < (double) INT_MIN32)
    {
      res=(int32) INT_MIN32;
1877
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1878
      error= 1;
unknown's avatar
unknown committed
1879 1880 1881 1882
    }
    else if (nr > (double) INT_MAX32)
    {
      res=(int32) INT_MAX32;
1883
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1884
      error= 1;
unknown's avatar
unknown committed
1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896
    }
    else
      res=(int32) nr;
  }
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,res);
  }
  else
#endif
    longstore(ptr,res);
1897
  return error;
unknown's avatar
unknown committed
1898 1899 1900
}


unknown's avatar
unknown committed
1901
int Field_long::store(longlong nr)
unknown's avatar
unknown committed
1902
{
unknown's avatar
unknown committed
1903
  int error= 0;
unknown's avatar
unknown committed
1904
  int32 res;
1905 1906 1907 1908 1909 1910 1911 1912

  /* 
    This assert has nothing to do with this method per se, it was put here
    only because it is one of the best places for catching places there its 
    condition is broken.
  */
  DBUG_ASSERT(table->in_use == current_thd);
  
unknown's avatar
unknown committed
1913 1914 1915 1916 1917
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
1918
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1919
      error= 1;
unknown's avatar
unknown committed
1920 1921 1922 1923
    }
    else if (nr >= (LL(1) << 32))
    {
      res=(int32) (uint32) ~0L;
1924
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1925
      error= 1;
unknown's avatar
unknown committed
1926 1927 1928 1929 1930 1931 1932 1933 1934
    }
    else
      res=(int32) (uint32) nr;
  }
  else
  {
    if (nr < (longlong) INT_MIN32)
    {
      res=(int32) INT_MIN32;
1935
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1936
      error= 1;
unknown's avatar
unknown committed
1937 1938 1939 1940
    }
    else if (nr > (longlong) INT_MAX32)
    {
      res=(int32) INT_MAX32;
1941
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1942
      error= 1;
unknown's avatar
unknown committed
1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954
    }
    else
      res=(int32) nr;
  }
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,res);
  }
  else
#endif
    longstore(ptr,res);
1955
  return error;
unknown's avatar
unknown committed
1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
}


double Field_long::val_real(void)
{
  int32 j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return unsigned_flag ? (double) (uint32) j : (double) j;
}

longlong Field_long::val_int(void)
{
  int32 j;
1974 1975
  /* See the comment in Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
unknown's avatar
unknown committed
1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return unsigned_flag ? (longlong) (uint32) j : (longlong) j;
}

String *Field_long::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
1988
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
1989
  uint length;
1990 1991
  uint mlength=max(field_length+1,12*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
1992 1993 1994 1995 1996 1997 1998 1999 2000
  char *to=(char*) val_buffer->ptr();
  int32 j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);

2001
  if (unsigned_flag)
2002
    length=cs->cset->long10_to_str(cs,to,mlength, 10,(long) (uint32)j);
2003
  else
2004
    length=cs->cset->long10_to_str(cs,to,mlength,-10,(long) j);
unknown's avatar
unknown committed
2005 2006 2007 2008 2009 2010 2011
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


2012 2013 2014 2015 2016
bool Field_long::send_binary(Protocol *protocol)
{
  return protocol->store_long(Field_long::val_int());
}

unknown's avatar
unknown committed
2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
int Field_long::cmp(const char *a_ptr, const char *b_ptr)
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    a=sint4korr(a_ptr);
    b=sint4korr(b_ptr);
  }
  else
#endif
  {
    longget(a,a_ptr);
    longget(b,b_ptr);
  }
  if (unsigned_flag)
unknown's avatar
unknown committed
2033
    return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
unknown's avatar
unknown committed
2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

void Field_long::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
  if (!table->db_low_byte_first)
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
unknown's avatar
unknown committed
2045
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
    to[1]   = ptr[1];
    to[2]   = ptr[2];
    to[3]   = ptr[3];
  }
  else
#endif
  {
    if (unsigned_flag)
      to[0] = ptr[3];
    else
unknown's avatar
unknown committed
2056
      to[0] = (char) (ptr[3] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
2057 2058 2059 2060 2061 2062 2063 2064 2065
    to[1]   = ptr[2];
    to[2]   = ptr[1];
    to[3]   = ptr[0];
  }
}


void Field_long::sql_type(String &res) const
{
unknown's avatar
unknown committed
2066
  CHARSET_INFO *cs=res.charset();
2067
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2068
			  "int(%d)",(int) field_length));
unknown's avatar
unknown committed
2069 2070 2071 2072
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
2073
 Field type longlong int (8 bytes)
unknown's avatar
unknown committed
2074 2075
****************************************************************************/

unknown's avatar
unknown committed
2076
int Field_longlong::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
2077
{
2078 2079
  longlong tmp;
  int error= 0;
2080
  char *end;
unknown's avatar
unknown committed
2081
  
2082
  tmp= cs->cset->scan(cs, from, from+len, MY_SEQ_SPACES);
2083
  len-= (uint)tmp;
unknown's avatar
unknown committed
2084
  from+= tmp;
2085
  my_errno=0;
unknown's avatar
unknown committed
2086 2087 2088 2089 2090
  if (unsigned_flag)
  {
    if (!len || *from == '-')
    {
      tmp=0;					// Set negative to 0
2091
      my_errno= ERANGE;
unknown's avatar
unknown committed
2092
      error= 1;
unknown's avatar
unknown committed
2093 2094
    }
    else
2095
      tmp=(longlong) my_strntoull(cs,from,len,10,&end,&error);
unknown's avatar
unknown committed
2096 2097
  }
  else
2098 2099
    tmp=my_strntoll(cs,from,len,10,&end,&error);
  if (error ||
2100
      (from+len != end && table->in_use->count_cuted_fields &&
2101
       !test_if_int(from,len,end,cs)))
2102
  {
2103
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
2104 2105
    error= 1;
  }
unknown's avatar
unknown committed
2106 2107 2108 2109 2110 2111 2112 2113
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
2114
  return error;
unknown's avatar
unknown committed
2115 2116 2117
}


unknown's avatar
unknown committed
2118
int Field_longlong::store(double nr)
unknown's avatar
unknown committed
2119
{
unknown's avatar
unknown committed
2120
  int error= 0;
unknown's avatar
unknown committed
2121 2122 2123 2124 2125 2126 2127
  longlong res;
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
2128
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2129
      error= 1;
unknown's avatar
unknown committed
2130 2131 2132 2133
    }
    else if (nr >= (double) ~ (ulonglong) 0)
    {
      res= ~(longlong) 0;
2134
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2135
      error= 1;
unknown's avatar
unknown committed
2136 2137 2138 2139 2140 2141 2142 2143 2144
    }
    else
      res=(longlong) (ulonglong) nr;
  }
  else
  {
    if (nr <= (double) LONGLONG_MIN)
    {
      res=(longlong) LONGLONG_MIN;
2145
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2146
      error= 1;
unknown's avatar
unknown committed
2147 2148 2149 2150
    }
    else if (nr >= (double) LONGLONG_MAX)
    {
      res=(longlong) LONGLONG_MAX;
2151
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2152
      error= 1;
unknown's avatar
unknown committed
2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164
    }
    else
      res=(longlong) nr;
  }
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,res);
  }
  else
#endif
    longlongstore(ptr,res);
2165
  return error;
unknown's avatar
unknown committed
2166 2167 2168
}


unknown's avatar
unknown committed
2169
int Field_longlong::store(longlong nr)
unknown's avatar
unknown committed
2170 2171 2172 2173 2174 2175 2176 2177 2178
{
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,nr);
  }
  else
#endif
    longlongstore(ptr,nr);
2179
  return 0;
unknown's avatar
unknown committed
2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193
}


double Field_longlong::val_real(void)
{
  longlong j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    j=sint8korr(ptr);
  }
  else
#endif
    longlongget(j,ptr);
2194 2195 2196 2197 2198 2199 2200
  /* The following is open coded to avoid a bug in gcc 3.3 */
  if (unsigned_flag)
  {
    ulonglong tmp= (ulonglong) j;
    return ulonglong2double(tmp);
  }
  return (double) j;
unknown's avatar
unknown committed
2201 2202
}

2203

unknown's avatar
unknown committed
2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219
longlong Field_longlong::val_int(void)
{
  longlong j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint8korr(ptr);
  else
#endif
    longlongget(j,ptr);
  return j;
}


String *Field_longlong::val_str(String *val_buffer,
				String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
2220
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
2221
  uint length;
2222 2223
  uint mlength=max(field_length+1,22*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
2224 2225 2226 2227 2228 2229 2230 2231 2232
  char *to=(char*) val_buffer->ptr();
  longlong j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint8korr(ptr);
  else
#endif
    longlongget(j,ptr);

2233
  length=(uint) (cs->cset->longlong10_to_str)(cs,to,mlength,
unknown's avatar
unknown committed
2234
					unsigned_flag ? 10 : -10, j);
unknown's avatar
unknown committed
2235 2236 2237 2238 2239 2240 2241
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


2242 2243 2244 2245 2246 2247
bool Field_longlong::send_binary(Protocol *protocol)
{
  return protocol->store_longlong(Field_longlong::val_int(), unsigned_flag);
}


unknown's avatar
unknown committed
2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276
int Field_longlong::cmp(const char *a_ptr, const char *b_ptr)
{
  longlong a,b;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    a=sint8korr(a_ptr);
    b=sint8korr(b_ptr);
  }
  else
#endif
  {
    longlongget(a,a_ptr);
    longlongget(b,b_ptr);
  }
  if (unsigned_flag)
    return ((ulonglong) a < (ulonglong) b) ? -1 :
    ((ulonglong) a > (ulonglong) b) ? 1 : 0;
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

void Field_longlong::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
  if (!table->db_low_byte_first)
  {
    if (unsigned_flag)
      to[0] = ptr[0];
    else
unknown's avatar
unknown committed
2277
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291
    to[1]   = ptr[1];
    to[2]   = ptr[2];
    to[3]   = ptr[3];
    to[4]   = ptr[4];
    to[5]   = ptr[5];
    to[6]   = ptr[6];
    to[7]   = ptr[7];
  }
  else
#endif
  {
    if (unsigned_flag)
      to[0] = ptr[7];
    else
unknown's avatar
unknown committed
2292
      to[0] = (char) (ptr[7] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305
    to[1]   = ptr[6];
    to[2]   = ptr[5];
    to[3]   = ptr[4];
    to[4]   = ptr[3];
    to[5]   = ptr[2];
    to[6]   = ptr[1];
    to[7]   = ptr[0];
  }
}


void Field_longlong::sql_type(String &res) const
{
unknown's avatar
unknown committed
2306
  CHARSET_INFO *cs=res.charset();
2307
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2308
			  "bigint(%d)",(int) field_length));
unknown's avatar
unknown committed
2309 2310 2311
  add_zerofill_and_unsigned(res);
}

unknown's avatar
unknown committed
2312

unknown's avatar
unknown committed
2313
/****************************************************************************
unknown's avatar
unknown committed
2314
  single precision float
unknown's avatar
unknown committed
2315 2316
****************************************************************************/

unknown's avatar
unknown committed
2317
int Field_float::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
2318
{
unknown's avatar
unknown committed
2319
  int error;
2320
  char *end;
unknown's avatar
unknown committed
2321
  double nr= my_strntod(cs,(char*) from,len,&end,&error);
2322
  if (error || ((uint) (end-from) != len && table->in_use->count_cuted_fields))
2323
  {
unknown's avatar
unknown committed
2324
    error= 1;
2325
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
2326
  }
unknown's avatar
unknown committed
2327 2328
  Field_float::store(nr);
  return error;
unknown's avatar
unknown committed
2329 2330 2331
}


unknown's avatar
unknown committed
2332
int Field_float::store(double nr)
unknown's avatar
unknown committed
2333 2334
{
  float j;
unknown's avatar
unknown committed
2335
  int error= 0;
2336

2337
  if (isnan(nr))
unknown's avatar
unknown committed
2338
  {
2339 2340
    j= 0;
    set_null();
2341
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2342
    error= 1;
unknown's avatar
unknown committed
2343
  }
2344
  else if (unsigned_flag && nr < 0)
unknown's avatar
unknown committed
2345
  {
2346
    j= 0;
2347
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2348
    error= 1;
unknown's avatar
unknown committed
2349
  }
2350
  else
unknown's avatar
unknown committed
2351
  {
2352 2353 2354 2355 2356 2357 2358
    double max_value;
    if (dec >= NOT_FIXED_DEC)
    {
      max_value= FLT_MAX;
    }
    else
    {
unknown's avatar
unknown committed
2359 2360
      uint tmp=min(field_length,array_elements(log_10)-1);
      max_value= (log_10[tmp]-1)/log_10[dec];
2361 2362 2363 2364 2365 2366
      /*
	The following comparison is needed to not get an overflow if nr
	is close to FLT_MAX
      */
      if (fabs(nr) < FLT_MAX/10.0e+32)
	nr= floor(nr*log_10[dec]+0.5)/log_10[dec];
2367 2368 2369 2370
    }
    if (nr < -max_value)
    {
      j= (float)-max_value;
2371
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2372 2373 2374 2375 2376
      error= 1;
    }
    else if (nr > max_value)
    {
      j= (float)max_value;
2377
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2378 2379 2380 2381
      error= 1;
    }
    else
      j= (float) nr;
unknown's avatar
unknown committed
2382
  }
2383
  
unknown's avatar
unknown committed
2384 2385 2386 2387 2388 2389 2390 2391
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float4store(ptr,j);
  }
  else
#endif
    memcpy_fixed(ptr,(byte*) &j,sizeof(j));
2392
  return error;
unknown's avatar
unknown committed
2393 2394 2395
}


unknown's avatar
unknown committed
2396
int Field_float::store(longlong nr)
unknown's avatar
unknown committed
2397
{
unknown's avatar
unknown committed
2398
  int error= 0;
unknown's avatar
unknown committed
2399
  float j= (float) nr;
unknown's avatar
unknown committed
2400 2401
  if (unsigned_flag && j < 0)
  {
2402
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2403
    j=0;
unknown's avatar
unknown committed
2404
    error= 1;
unknown's avatar
unknown committed
2405
  }
unknown's avatar
unknown committed
2406 2407 2408 2409 2410 2411 2412 2413
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float4store(ptr,j);
  }
  else
#endif
    memcpy_fixed(ptr,(byte*) &j,sizeof(j));
2414
  return error;
unknown's avatar
unknown committed
2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459
}


double Field_float::val_real(void)
{
  float j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float4get(j,ptr);
  }
  else
#endif
    memcpy_fixed((byte*) &j,ptr,sizeof(j));
  return ((double) j);
}

longlong Field_float::val_int(void)
{
  float j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float4get(j,ptr);
  }
  else
#endif
    memcpy_fixed((byte*) &j,ptr,sizeof(j));
  return ((longlong) j);
}


String *Field_float::val_str(String *val_buffer,
			     String *val_ptr __attribute__((unused)))
{
  float nr;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float4get(nr,ptr);
  }
  else
#endif
    memcpy_fixed((byte*) &nr,ptr,sizeof(nr));

2460 2461
  uint to_length=max(field_length,70);
  val_buffer->alloc(to_length);
unknown's avatar
unknown committed
2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509
  char *to=(char*) val_buffer->ptr();

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

    VOID(sfconvert(&nr,tmp_dec,&decpt,&sign,buff));
    if (sign)
    {
      *to++='-';
    }
    if (decpt < 0)
    {					/* val_buffer is < 0 */
      *to++='0';
      if (!tmp_dec)
	goto end;
      *to++='.';
      if (-decpt > tmp_dec)
	decpt= - (int) tmp_dec;
      tmp_dec=(uint) ((int) tmp_dec+decpt);
      while (decpt++ < 0)
	*to++='0';
    }
    else if (decpt == 0)
    {
      *to++= '0';
      if (!tmp_dec)
	goto end;
      *to++='.';
    }
    else
    {
      while (decpt-- > 0)
	*to++= *pos++;
      if (!tmp_dec)
	goto end;
      *to++='.';
    }
    while (tmp_dec--)
      *to++= *pos++;
unknown's avatar
unknown committed
2510
#else
2511 2512 2513
#ifdef HAVE_SNPRINTF
    to[to_length-1]=0;			// Safety
    snprintf(to,to_length-1,"%.*f",dec,nr);
2514
    to=strend(to);
unknown's avatar
unknown committed
2515
#else
2516
    to+= my_sprintf(to,(to,"%.*f",dec,nr));
unknown's avatar
unknown committed
2517
#endif
unknown's avatar
unknown committed
2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578
#endif
  }
#ifdef HAVE_FCONVERT
 end:
#endif
  val_buffer->length((uint) (to-val_buffer->ptr()));
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


int Field_float::cmp(const char *a_ptr, const char *b_ptr)
{
  float a,b;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float4get(a,a_ptr);
    float4get(b,b_ptr);
  }
  else
#endif
  {
    memcpy_fixed(&a,a_ptr,sizeof(float));
    memcpy_fixed(&b,b_ptr,sizeof(float));
  }
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

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

void Field_float::sort_string(char *to,uint length __attribute__((unused)))
{
  float nr;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float4get(nr,ptr);
  }
  else
#endif
    memcpy_fixed(&nr,ptr,sizeof(float));

  uchar *tmp= (uchar*) to;
  if (nr == (float) 0.0)
  {						/* Change to zero string */
    tmp[0]=(uchar) 128;
    bzero((char*) tmp+1,sizeof(nr)-1);
  }
  else
  {
#ifdef WORDS_BIGENDIAN
    memcpy_fixed(tmp,&nr,sizeof(nr));
#else
    tmp[0]= ptr[3]; tmp[1]=ptr[2]; tmp[2]= ptr[1]; tmp[3]=ptr[0];
#endif
    if (tmp[0] & 128)				/* Negative */
    {						/* make complement */
      uint i;
      for (i=0 ; i < sizeof(nr); i++)
unknown's avatar
unknown committed
2579
	tmp[i]= (uchar) (tmp[i] ^ (uchar) 255);
unknown's avatar
unknown committed
2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592
    }
    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;
    }
  }
}


2593 2594 2595 2596 2597 2598
bool Field_float::send_binary(Protocol *protocol)
{
  return protocol->store((float) Field_float::val_real(), dec, (String*) 0);
}


unknown's avatar
unknown committed
2599 2600 2601
void Field_float::sql_type(String &res) const
{
  if (dec == NOT_FIXED_DEC)
2602
  {
2603
    res.set_ascii("float", 5);
2604
  }
unknown's avatar
unknown committed
2605
  else
2606
  {
2607
    CHARSET_INFO *cs= res.charset();
2608
    res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2609
			    "float(%d,%d)",(int) field_length,dec));
2610
  }
unknown's avatar
unknown committed
2611 2612 2613
  add_zerofill_and_unsigned(res);
}

unknown's avatar
unknown committed
2614

unknown's avatar
unknown committed
2615
/****************************************************************************
unknown's avatar
unknown committed
2616
  double precision floating point numbers
unknown's avatar
unknown committed
2617 2618
****************************************************************************/

unknown's avatar
unknown committed
2619
int Field_double::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
2620
{
unknown's avatar
unknown committed
2621
  int error;
2622
  char *end;
unknown's avatar
unknown committed
2623
  double nr= my_strntod(cs,(char*) from, len, &end, &error);
2624
  if (error || ((uint) (end-from) != len && table->in_use->count_cuted_fields))
unknown's avatar
unknown committed
2625
  {
unknown's avatar
unknown committed
2626
    error= 1;
2627
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
2628
  }
unknown's avatar
unknown committed
2629 2630
  Field_double::store(nr);
  return error;
unknown's avatar
unknown committed
2631 2632 2633
}


unknown's avatar
unknown committed
2634
int Field_double::store(double nr)
unknown's avatar
unknown committed
2635
{
unknown's avatar
unknown committed
2636
  int error= 0;
2637

2638 2639 2640 2641
  if (isnan(nr))
  {
    nr= 0;
    set_null();
2642
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2643 2644 2645
    error= 1;
  }
  else if (unsigned_flag && nr < 0)
unknown's avatar
unknown committed
2646
  {
2647
    nr= 0;
2648
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2649
    error= 1;
unknown's avatar
unknown committed
2650
  }
2651 2652 2653 2654 2655 2656 2657 2658 2659
  else 
  {
    double max_value;
    if (dec >= NOT_FIXED_DEC)
    {
      max_value= DBL_MAX;
    }
    else
    {
unknown's avatar
unknown committed
2660 2661
      uint tmp=min(field_length,array_elements(log_10)-1);
      max_value= (log_10[tmp]-1)/log_10[dec];
2662 2663
      if (fabs(nr) < DBL_MAX/10.0e+32)
	nr= floor(nr*log_10[dec]+0.5)/log_10[dec];
2664 2665 2666 2667
    }
    if (nr < -max_value)
    {
      nr= -max_value;
2668
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2669 2670 2671 2672 2673
      error= 1;
    }
    else if (nr > max_value)
    {
      nr= max_value;
2674
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
2675 2676 2677 2678
      error= 1;
    }
  }

unknown's avatar
unknown committed
2679 2680 2681 2682 2683 2684 2685 2686
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float8store(ptr,nr);
  }
  else
#endif
    doublestore(ptr,nr);
2687
  return error;
unknown's avatar
unknown committed
2688 2689 2690
}


unknown's avatar
unknown committed
2691
int Field_double::store(longlong nr)
unknown's avatar
unknown committed
2692 2693
{
  double j= (double) nr;
unknown's avatar
unknown committed
2694
  int error= 0;
unknown's avatar
unknown committed
2695 2696
  if (unsigned_flag && j < 0)
  {
2697
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2698
    error= 1;
unknown's avatar
unknown committed
2699 2700
    j=0;
  }
unknown's avatar
unknown committed
2701 2702 2703 2704 2705 2706 2707 2708
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float8store(ptr,j);
  }
  else
#endif
    doublestore(ptr,j);
2709
  return error;
unknown's avatar
unknown committed
2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754
}


double Field_double::val_real(void)
{
  double j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float8get(j,ptr);
  }
  else
#endif
    doubleget(j,ptr);
  return j;
}

longlong Field_double::val_int(void)
{
  double j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float8get(j,ptr);
  }
  else
#endif
    doubleget(j,ptr);
  return ((longlong) j);
}


String *Field_double::val_str(String *val_buffer,
			      String *val_ptr __attribute__((unused)))
{
  double nr;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float8get(nr,ptr);
  }
  else
#endif
    doubleget(nr,ptr);

2755
  uint to_length=max(field_length, DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE);
unknown's avatar
unknown committed
2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766
  val_buffer->alloc(to_length);
  char *to=(char*) val_buffer->ptr();

  if (dec >= NOT_FIXED_DEC)
  {
    sprintf(to,"%-*.*g",(int) field_length,DBL_DIG,nr);
    to=strcend(to,' ');
  }
  else
  {
#ifdef HAVE_FCONVERT
unknown's avatar
unknown committed
2767
    char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
2768
    char *pos= buff;
unknown's avatar
unknown committed
2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806
    int decpt,sign,tmp_dec=dec;

    VOID(fconvert(nr,tmp_dec,&decpt,&sign,buff));
    if (sign)
    {
      *to++='-';
    }
    if (decpt < 0)
    {					/* val_buffer is < 0 */
      *to++='0';
      if (!tmp_dec)
	goto end;
      *to++='.';
      if (-decpt > tmp_dec)
	decpt= - (int) tmp_dec;
      tmp_dec=(uint) ((int) tmp_dec+decpt);
      while (decpt++ < 0)
	*to++='0';
    }
    else if (decpt == 0)
    {
      *to++= '0';
      if (!tmp_dec)
	goto end;
      *to++='.';
    }
    else
    {
      while (decpt-- > 0)
	*to++= *pos++;
      if (!tmp_dec)
	goto end;
      *to++='.';
    }
    while (tmp_dec--)
      *to++= *pos++;
#else
#ifdef HAVE_SNPRINTF
unknown's avatar
unknown committed
2807
    to[to_length-1]=0;			// Safety
unknown's avatar
unknown committed
2808
    snprintf(to,to_length-1,"%.*f",dec,nr);
2809
    to=strend(to);
unknown's avatar
unknown committed
2810
#else
2811
    to+= my_sprintf(to,(to,"%.*f",dec,nr));
unknown's avatar
unknown committed
2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
#endif
#endif
  }
#ifdef HAVE_FCONVERT
 end:
#endif

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

2825 2826
bool Field_double::send_binary(Protocol *protocol)
{
unknown's avatar
unknown committed
2827
  return protocol->store((double) Field_double::val_real(), dec, (String*) 0);
2828 2829
}

unknown's avatar
unknown committed
2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842

int Field_double::cmp(const char *a_ptr, const char *b_ptr)
{
  double a,b;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float8get(a,a_ptr);
    float8get(b,b_ptr);
  }
  else
#endif
  {
unknown's avatar
unknown committed
2843 2844
    doubleget(a, a_ptr);
    doubleget(b, b_ptr);
unknown's avatar
unknown committed
2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863
  }
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}


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

/* The following should work for IEEE */

void Field_double::sort_string(char *to,uint length __attribute__((unused)))
{
  double nr;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float8get(nr,ptr);
  }
  else
#endif
unknown's avatar
unknown committed
2864
    doubleget(nr,ptr);
unknown's avatar
unknown committed
2865 2866 2867 2868 2869 2870
  change_double_for_sort(nr, (byte*) to);
}


void Field_double::sql_type(String &res) const
{
unknown's avatar
unknown committed
2871
  CHARSET_INFO *cs=res.charset();
unknown's avatar
unknown committed
2872
  if (dec == NOT_FIXED_DEC)
2873
  {
2874
    res.set_ascii("double",6);
2875
  }
unknown's avatar
unknown committed
2876
  else
2877
  {
2878
    res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2879
			    "double(%d,%d)",(int) field_length,dec));
2880
  }
unknown's avatar
unknown committed
2881 2882 2883 2884
  add_zerofill_and_unsigned(res);
}


2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928
/*
  TIMESTAMP type.
  Holds datetime values in range from 1970-01-01 00:00:01 UTC to 
  2038-01-01 00:00:00 UTC stored as number of seconds since Unix 
  Epoch in UTC.
  
  Up to one of timestamps columns in the table can be automatically 
  set on row update and/or have NOW() as default value.
  TABLE::timestamp_field points to Field object for such timestamp with 
  auto-set-on-update. TABLE::time_stamp holds offset in record + 1 for this
  field, and is used by handler code which performs updates required.
  
  Actually SQL-99 says that we should allow niladic functions (like NOW())
  as defaults for any field. Current limitations (only NOW() and only 
  for one TIMESTAMP field) are because of restricted binary .frm format 
  and should go away in the future.
  
  Also because of this limitation of binary .frm format we use 5 different
  unireg_check values with TIMESTAMP field to distinguish various cases of
  DEFAULT or ON UPDATE values. These values are:
  
  TIMESTAMP_OLD_FIELD - old timestamp, if there was not any fields with
    auto-set-on-update (or now() as default) in this table before, then this 
    field has NOW() as default and is updated when row changes, else it is 
    field which has 0 as default value and is not automaitcally updated.
  TIMESTAMP_DN_FIELD - field with NOW() as default but not set on update
    automatically (TIMESTAMP DEFAULT NOW())
  TIMESTAMP_UN_FIELD - field which is set on update automatically but has not 
    NOW() as default (but it may has 0 or some other const timestamp as 
    default) (TIMESTAMP ON UPDATE NOW()).
  TIMESTAMP_DNUN_FIELD - field which has now() as default and is auto-set on 
    update. (TIMESTAMP DEFAULT NOW() ON UPDATE NOW())
  NONE - field which is not auto-set on update with some other than NOW() 
    default value (TIMESTAMP DEFAULT 0).

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

Field_timestamp::Field_timestamp(char *ptr_arg, uint32 len_arg,
2931
                                 uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
2932 2933
				 enum utype unireg_check_arg,
				 const char *field_name_arg,
2934 2935
				 struct st_table *table_arg,
				 CHARSET_INFO *cs)
2936
  :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
2937
	     unireg_check_arg, field_name_arg, table_arg, cs)
unknown's avatar
unknown committed
2938
{
unknown's avatar
unknown committed
2939 2940
  /* For 4.0 MYD and 4.0 InnoDB compatibility */
  flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
2941 2942
  if (table && !table->timestamp_field && 
      unireg_check != NONE)
unknown's avatar
unknown committed
2943
  {
2944 2945
    /* This timestamp has auto-update */
    table->timestamp_field= this;
unknown's avatar
unknown committed
2946 2947 2948 2949 2950
    flags|=TIMESTAMP_FLAG;
  }
}


2951
/*
2952 2953
  Get auto-set type for TIMESTAMP field.

2954
  SYNOPSIS
2955 2956 2957 2958 2959
    get_auto_set_type()

  DESCRIPTION
    Returns value indicating during which operations this TIMESTAMP field
    should be auto-set to current timestamp.
2960
*/
2961
timestamp_auto_set_type Field_timestamp::get_auto_set_type() const
2962
{
2963 2964 2965 2966 2967 2968
  switch (unireg_check)
  {
  case TIMESTAMP_DN_FIELD:
    return TIMESTAMP_AUTO_SET_ON_INSERT;
  case TIMESTAMP_UN_FIELD:
    return TIMESTAMP_AUTO_SET_ON_UPDATE;
2969 2970 2971 2972 2973 2974 2975 2976
  case TIMESTAMP_OLD_FIELD:
    /*
      Altough we can have several such columns in legacy tables this
      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 */
2977 2978 2979 2980 2981 2982 2983 2984 2985 2986
  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;
  }
2987 2988 2989
}


unknown's avatar
unknown committed
2990
int Field_timestamp::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
2991
{
2992 2993 2994 2995 2996 2997 2998
  TIME l_time;
  my_time_t tmp= 0;
  int error;
  bool have_smth_to_conv;
  bool in_dst_time_gap;
  THD *thd= table->in_use;

2999 3000
  have_smth_to_conv= (str_to_datetime(from, len, &l_time, 0, &error) >
                      MYSQL_TIMESTAMP_ERROR);
3001 3002 3003
  
  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
3004
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
3005 3006 3007 3008 3009 3010 3011

  if (have_smth_to_conv)
  {
    if (!(tmp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                           ER_WARN_DATA_OUT_OF_RANGE,
3012
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
3013 3014 3015 3016 3017 3018 3019
      
      error= 1;
    }
    else if (in_dst_time_gap)
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                           ER_WARN_INVALID_TIMESTAMP, 
3020
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
3021 3022 3023 3024
      error= 1;
    }
  }

unknown's avatar
unknown committed
3025 3026 3027 3028 3029 3030 3031 3032
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
3033
  return error;
unknown's avatar
unknown committed
3034 3035
}

unknown's avatar
unknown committed
3036
int Field_timestamp::store(double nr)
unknown's avatar
unknown committed
3037
{
unknown's avatar
unknown committed
3038
  int error= 0;
unknown's avatar
unknown committed
3039 3040
  if (nr < 0 || nr > 99991231235959.0)
  {
3041 3042
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE, 
3043
                         nr, MYSQL_TIMESTAMP_DATETIME);
unknown's avatar
unknown committed
3044 3045
    nr= 0;					// Avoid overflow on buff
    error= 1;
unknown's avatar
unknown committed
3046
  }
unknown's avatar
unknown committed
3047
  error|= Field_timestamp::store((longlong) rint(nr));
3048
  return error;
unknown's avatar
unknown committed
3049 3050 3051
}


unknown's avatar
unknown committed
3052
int Field_timestamp::store(longlong nr)
unknown's avatar
unknown committed
3053 3054
{
  TIME l_time;
3055 3056 3057 3058
  my_time_t timestamp= 0;
  int error;
  bool in_dst_time_gap;
  THD *thd= table->in_use;
unknown's avatar
unknown committed
3059

3060
  if (number_to_TIME(nr, &l_time, 0, &error))
unknown's avatar
unknown committed
3061
  {
3062 3063 3064 3065
    if (!(timestamp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                          ER_WARN_DATA_OUT_OF_RANGE,
3066
                          nr, MYSQL_TIMESTAMP_DATETIME, 1);
3067 3068
      error= 1;
    }
3069
  
3070 3071 3072 3073
    if (in_dst_time_gap)
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                           ER_WARN_INVALID_TIMESTAMP, 
3074
                           nr, MYSQL_TIMESTAMP_DATETIME, !error);
3075 3076 3077 3078 3079 3080
      error= 1;
    }
  }
  else if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_TRUNCATED,
3081
                         nr, MYSQL_TIMESTAMP_DATETIME, 1);
3082

unknown's avatar
unknown committed
3083 3084 3085 3086 3087 3088 3089
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,timestamp);
  }
  else
#endif
unknown's avatar
unknown committed
3090
    longstore(ptr,(uint32) timestamp);
3091
    
unknown's avatar
unknown committed
3092
  return error;
unknown's avatar
unknown committed
3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103
}


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

longlong Field_timestamp::val_int(void)
{
  uint32 temp;
3104 3105
  TIME time_tmp;
  THD  *thd= table->in_use;
unknown's avatar
unknown committed
3106 3107 3108 3109 3110 3111 3112 3113 3114 3115

#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);

  if (temp == 0L)				// No time
    return(0);					/* purecov: inspected */
3116 3117 3118 3119 3120 3121 3122
  
  thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp, (my_time_t)temp);
  thd->time_zone_used= 1;
  
  return time_tmp.year * LL(10000000000) + time_tmp.month * LL(100000000) +
         time_tmp.day * 1000000L + time_tmp.hour * 10000L +
         time_tmp.minute * 100 + time_tmp.second;
unknown's avatar
unknown committed
3123 3124 3125
}


unknown's avatar
unknown committed
3126
String *Field_timestamp::val_str(String *val_buffer, String *val_ptr)
unknown's avatar
unknown committed
3127
{
3128
  uint32 temp, temp2;
3129 3130
  TIME time_tmp;
  THD *thd= table->in_use;
unknown's avatar
unknown committed
3131
  char *to;
unknown's avatar
unknown committed
3132 3133

  val_buffer->alloc(field_length+1);
unknown's avatar
unknown committed
3134
  to= (char*) val_buffer->ptr();
3135
  val_buffer->length(field_length);
unknown's avatar
unknown committed
3136 3137 3138 3139 3140 3141 3142 3143 3144 3145

#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);

  if (temp == 0L)
  {				      /* Zero time is "000000" */
unknown's avatar
unknown committed
3146
    val_ptr->set("0000-00-00 00:00:00", 19, &my_charset_bin);
3147
    return val_ptr;
unknown's avatar
unknown committed
3148
  }
unknown's avatar
unknown committed
3149
  val_buffer->set_charset(&my_charset_bin);	// Safety
3150 3151 3152
  
  thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp,(my_time_t)temp);
  thd->time_zone_used= 1;
3153

3154
  temp= time_tmp.year % 100;
3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168
  if (temp < YY_PART_YEAR)
  {
    *to++= '2';
    *to++= '0';
  }
  else
  {
    *to++= '1';
    *to++= '9';
  }
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= '-';
3169
  temp=time_tmp.month;
3170 3171 3172 3173
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= '-';
3174
  temp=time_tmp.day;
3175 3176 3177 3178
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ' ';
3179
  temp=time_tmp.hour;
3180 3181 3182 3183
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ':';
3184
  temp=time_tmp.minute;
3185 3186 3187 3188
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ':';
3189
  temp=time_tmp.second;
3190 3191 3192 3193
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to= 0;
unknown's avatar
unknown committed
3194 3195 3196
  return val_buffer;
}

3197

3198
bool Field_timestamp::get_date(TIME *ltime, uint fuzzydate)
unknown's avatar
unknown committed
3199 3200
{
  long temp;
3201
  THD *thd= table->in_use;
unknown's avatar
unknown committed
3202 3203 3204 3205 3206 3207 3208 3209
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    temp=uint4korr(ptr);
  else
#endif
    longget(temp,ptr);
  if (temp == 0L)
  {				      /* Zero time is "000000" */
unknown's avatar
unknown committed
3210 3211
    if (!fuzzydate)
      return 1;
unknown's avatar
unknown committed
3212 3213 3214 3215
    bzero((char*) ltime,sizeof(*ltime));
  }
  else
  {
3216 3217
    thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)temp);
    thd->time_zone_used= 1;
unknown's avatar
unknown committed
3218 3219 3220 3221 3222 3223
  }
  return 0;
}

bool Field_timestamp::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
3224
  return Field_timestamp::get_date(ltime,0);
unknown's avatar
unknown committed
3225 3226
}

3227 3228 3229 3230

bool Field_timestamp::send_binary(Protocol *protocol)
{
  TIME tm;
3231
  Field_timestamp::get_date(&tm, TIME_FUZZY_DATE);
3232 3233 3234 3235
  return protocol->store(&tm);
}


unknown's avatar
unknown committed
3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253
int Field_timestamp::cmp(const char *a_ptr, const char *b_ptr)
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    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;
}

3254

unknown's avatar
unknown committed
3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277
void Field_timestamp::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
  if (!table->db_low_byte_first)
  {
    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
{
3278
  res.set_ascii("timestamp", 9);
unknown's avatar
unknown committed
3279 3280 3281 3282 3283
}


void Field_timestamp::set_time()
{
3284
  long tmp= (long) table->in_use->query_start();
3285
  set_notnull();
unknown's avatar
unknown committed
3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
}

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

unknown's avatar
unknown committed
3303
int Field_time::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3304 3305 3306
{
  TIME ltime;
  long tmp;
3307 3308 3309
  int error;

  if (str_to_time(from, len, &ltime, &error))
3310
  {
unknown's avatar
unknown committed
3311
    tmp=0L;
unknown's avatar
unknown committed
3312
    error= 1;
3313
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
3314
                         from, len, MYSQL_TIMESTAMP_TIME, 1);
3315
  }
unknown's avatar
unknown committed
3316 3317
  else
  {
3318 3319 3320
    if (error)
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                           ER_WARN_DATA_TRUNCATED,
3321
                           from, len, MYSQL_TIMESTAMP_TIME, 1);
3322

unknown's avatar
unknown committed
3323 3324 3325 3326 3327 3328
    if (ltime.month)
      ltime.day=0;
    tmp=(ltime.day*24L+ltime.hour)*10000L+(ltime.minute*100+ltime.second);
    if (tmp > 8385959)
    {
      tmp=8385959;
3329 3330
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                           ER_WARN_DATA_OUT_OF_RANGE,
3331
                           from, len, MYSQL_TIMESTAMP_TIME, !error);
unknown's avatar
unknown committed
3332
      error= 1;
unknown's avatar
unknown committed
3333 3334
    }
  }
3335
  
unknown's avatar
unknown committed
3336 3337
  if (ltime.neg)
    tmp= -tmp;
3338 3339
  error |= Field_time::store((longlong) tmp);
  return error;
unknown's avatar
unknown committed
3340 3341 3342
}


unknown's avatar
unknown committed
3343
int Field_time::store(double nr)
unknown's avatar
unknown committed
3344 3345
{
  long tmp;
unknown's avatar
unknown committed
3346
  int error= 0;
unknown's avatar
unknown committed
3347 3348 3349
  if (nr > 8385959.0)
  {
    tmp=8385959L;
3350
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3351
                         ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
3352
    error= 1;
unknown's avatar
unknown committed
3353 3354 3355 3356
  }
  else if (nr < -8385959.0)
  {
    tmp= -8385959L;
3357
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3358
                         ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
3359
    error= 1;
unknown's avatar
unknown committed
3360 3361 3362 3363 3364 3365 3366 3367 3368
  }
  else
  {
    tmp=(long) floor(fabs(nr));			// Remove fractions
    if (nr < 0)
      tmp= -tmp;
    if (tmp % 100 > 59 || tmp/100 % 100 > 59)
    {
      tmp=0;
3369
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3370 3371
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
3372
      error= 1;
unknown's avatar
unknown committed
3373 3374 3375
    }
  }
  int3store(ptr,tmp);
3376
  return error;
unknown's avatar
unknown committed
3377 3378 3379
}


unknown's avatar
unknown committed
3380
int Field_time::store(longlong nr)
unknown's avatar
unknown committed
3381 3382
{
  long tmp;
unknown's avatar
unknown committed
3383
  int error= 0;
unknown's avatar
unknown committed
3384 3385 3386
  if (nr > (longlong) 8385959L)
  {
    tmp=8385959L;
3387
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3388 3389
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
3390
    error= 1;
unknown's avatar
unknown committed
3391 3392 3393 3394
  }
  else if (nr < (longlong) -8385959L)
  {
    tmp= -8385959L;
3395
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3396 3397
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
3398
    error= 1;
unknown's avatar
unknown committed
3399 3400 3401 3402 3403 3404 3405
  }
  else
  {
    tmp=(long) nr;
    if (tmp % 100 > 59 || tmp/100 % 100 > 59)
    {
      tmp=0;
3406
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3407 3408
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
3409
      error= 1;
unknown's avatar
unknown committed
3410 3411 3412
    }
  }
  int3store(ptr,tmp);
3413
  return error;
unknown's avatar
unknown committed
3414 3415 3416 3417 3418
}


double Field_time::val_real(void)
{
unknown's avatar
unknown committed
3419
  uint32 j= (uint32) uint3korr(ptr);
unknown's avatar
unknown committed
3420 3421 3422 3423 3424 3425 3426 3427
  return (double) j;
}

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

3428 3429 3430 3431 3432 3433

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

unknown's avatar
unknown committed
3434 3435 3436
String *Field_time::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
3437
  TIME ltime;
3438
  val_buffer->alloc(19);
unknown's avatar
unknown committed
3439
  long tmp=(long) sint3korr(ptr);
3440
  ltime.neg= 0;
unknown's avatar
unknown committed
3441 3442 3443
  if (tmp < 0)
  {
    tmp= -tmp;
3444 3445 3446 3447 3448 3449
    ltime.neg= 1;
  }
  ltime.day= (uint) 0;
  ltime.hour= (uint) (tmp/10000);
  ltime.minute= (uint) (tmp/100 % 100);
  ltime.second= (uint) (tmp % 100);
3450
  make_time((DATE_TIME_FORMAT*) 0, &ltime, val_buffer);
unknown's avatar
unknown committed
3451 3452 3453
  return val_buffer;
}

3454

unknown's avatar
unknown committed
3455 3456 3457 3458 3459 3460 3461
/*
  Normally we would not consider 'time' as a vaild date, but we allow
  get_date() here to be able to do things like
  DATE_FORMAT(time, "%l.%i %p")
*/
 
bool Field_time::get_date(TIME *ltime, uint fuzzydate)
3462
{
unknown's avatar
unknown committed
3463 3464 3465
  long tmp;
  if (!fuzzydate)
  {
3466 3467 3468 3469
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_WARN_DATA_OUT_OF_RANGE,
                        ER(ER_WARN_DATA_OUT_OF_RANGE), field_name,
                        table->in_use->row_count);
unknown's avatar
unknown committed
3470 3471 3472
    return 1;
  }
  tmp=(long) sint3korr(ptr);
3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486
  ltime->neg=0;
  if (tmp < 0)
  {
    ltime->neg= 1;
    tmp=-tmp;
  }
  ltime->hour=tmp/10000;
  tmp-=ltime->hour*10000;
  ltime->minute=   tmp/100;
  ltime->second= tmp % 100;
  ltime->year= ltime->month= ltime->day= ltime->second_part= 0;
  return 0;
}

unknown's avatar
unknown committed
3487

unknown's avatar
unknown committed
3488 3489 3490 3491 3492 3493 3494 3495 3496
bool Field_time::get_time(TIME *ltime)
{
  long tmp=(long) sint3korr(ptr);
  ltime->neg=0;
  if (tmp < 0)
  {
    ltime->neg= 1;
    tmp=-tmp;
  }
unknown's avatar
unknown committed
3497
  ltime->day= 0;
unknown's avatar
unknown committed
3498
  ltime->hour=   (int) (tmp/10000);
unknown's avatar
unknown committed
3499
  tmp-=ltime->hour*10000;
unknown's avatar
unknown committed
3500 3501
  ltime->minute= (int) tmp/100;
  ltime->second= (int) tmp % 100;
unknown's avatar
unknown committed
3502
  ltime->second_part=0;
3503
  ltime->time_type= MYSQL_TIMESTAMP_TIME;
unknown's avatar
unknown committed
3504 3505 3506
  return 0;
}

3507 3508 3509 3510 3511

bool Field_time::send_binary(Protocol *protocol)
{
  TIME tm;
  Field_time::get_time(&tm);
3512 3513
  tm.day= tm.hour/24;				// Move hours to days
  tm.hour-= tm.day*24;
unknown's avatar
unknown committed
3514
  return protocol->store_time(&tm);
3515 3516 3517
}


unknown's avatar
unknown committed
3518 3519
int Field_time::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
3520 3521 3522
  int32 a,b;
  a=(int32) sint3korr(a_ptr);
  b=(int32) sint3korr(b_ptr);
unknown's avatar
unknown committed
3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

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

void Field_time::sql_type(String &res) const
{
3535
  res.set_ascii("time", 4);
unknown's avatar
unknown committed
3536 3537 3538 3539 3540 3541 3542 3543
}

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

unknown's avatar
unknown committed
3544
int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3545
{
3546
  int not_used;				// We can ignore result from str2int
3547
  char *end;
3548
  long nr= my_strntol(cs, from, len, 10, &end, &not_used);
unknown's avatar
unknown committed
3549 3550 3551 3552

  if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155)
  {
    *ptr=0;
3553
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3554
    return 1;
unknown's avatar
unknown committed
3555
  }
3556 3557
  if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
3558 3559 3560 3561 3562 3563 3564 3565
  if (nr != 0 || len != 4)
  {
    if (nr < YY_PART_YEAR)
      nr+=100;					// 2000 - 2069
    else if (nr > 1900)
      nr-= 1900;
  }
  *ptr= (char) (unsigned char) nr;
3566
  return 0;
unknown's avatar
unknown committed
3567 3568
}

unknown's avatar
unknown committed
3569

unknown's avatar
unknown committed
3570
int Field_year::store(double nr)
unknown's avatar
unknown committed
3571 3572
{
  if (nr < 0.0 || nr >= 2155.0)
3573 3574 3575 3576
  {
    (void) Field_year::store((longlong) -1);
    return 1;
  }
unknown's avatar
unknown committed
3577
  else
3578
    return Field_year::store((longlong) nr);
unknown's avatar
unknown committed
3579 3580
}

unknown's avatar
unknown committed
3581
int Field_year::store(longlong nr)
unknown's avatar
unknown committed
3582 3583 3584 3585
{
  if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155)
  {
    *ptr=0;
3586
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3587
    return 1;
unknown's avatar
unknown committed
3588 3589 3590 3591 3592 3593 3594 3595 3596
  }
  if (nr != 0 || field_length != 4)		// 0000 -> 0; 00 -> 2000
  {
    if (nr < YY_PART_YEAR)
      nr+=100;					// 2000 - 2069
    else if (nr > 1900)
      nr-= 1900;
  }
  *ptr= (char) (unsigned char) nr;
3597
  return 0;
unknown's avatar
unknown committed
3598 3599
}

unknown's avatar
unknown committed
3600 3601 3602
bool Field_year::send_binary(Protocol *protocol)
{
  ulonglong tmp= Field_year::val_int();
3603
  return protocol->store_short(tmp);
unknown's avatar
unknown committed
3604
}
unknown's avatar
unknown committed
3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632

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

longlong Field_year::val_int(void)
{
  int tmp= (int) ((uchar*) ptr)[0];
  if (field_length != 4)
    tmp%=100;					// Return last 2 char
  else if (tmp)
    tmp+=1900;
  return (longlong) tmp;
}

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

void Field_year::sql_type(String &res) const
{
unknown's avatar
unknown committed
3633
  CHARSET_INFO *cs=res.charset();
3634
  res.length(cs->cset->snprintf(cs,(char*)res.ptr(),res.alloced_length(),
3635
			  "year(%d)",(int) field_length));
unknown's avatar
unknown committed
3636 3637 3638 3639 3640 3641 3642 3643 3644 3645
}


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

unknown's avatar
unknown committed
3646
int Field_date::store(const char *from, uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3647 3648
{
  TIME l_time;
unknown's avatar
unknown committed
3649
  uint32 tmp;
3650 3651
  int error;
  
3652
  if (str_to_datetime(from, len, &l_time, 1, &error) <= MYSQL_TIMESTAMP_ERROR)
3653
  {
unknown's avatar
unknown committed
3654
    tmp=0;
unknown's avatar
unknown committed
3655
    error= 1;
3656
  }
unknown's avatar
unknown committed
3657
  else
unknown's avatar
unknown committed
3658
    tmp=(uint32) l_time.year*10000L + (uint32) (l_time.month*100+l_time.day);
3659 3660 3661

  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
3662
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
3663

unknown's avatar
unknown committed
3664 3665 3666 3667 3668 3669 3670 3671
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
3672
  return error;
unknown's avatar
unknown committed
3673 3674 3675
}


unknown's avatar
unknown committed
3676
int Field_date::store(double nr)
unknown's avatar
unknown committed
3677 3678
{
  long tmp;
unknown's avatar
unknown committed
3679
  int error= 0;
unknown's avatar
unknown committed
3680 3681 3682 3683 3684
  if (nr >= 19000000000000.0 && nr <= 99991231235959.0)
    nr=floor(nr/1000000.0);			// Timestamp to date
  if (nr < 0.0 || nr > 99991231.0)
  {
    tmp=0L;
3685 3686
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE, 
3687
                         nr, MYSQL_TIMESTAMP_DATE);
unknown's avatar
unknown committed
3688
    error= 1;
unknown's avatar
unknown committed
3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699
  }
  else
    tmp=(long) rint(nr);
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
3700
  return error;
unknown's avatar
unknown committed
3701 3702 3703
}


unknown's avatar
unknown committed
3704
int Field_date::store(longlong nr)
unknown's avatar
unknown committed
3705 3706
{
  long tmp;
unknown's avatar
unknown committed
3707
  int error= 0;
unknown's avatar
unknown committed
3708 3709 3710 3711 3712
  if (nr >= LL(19000000000000) && nr < LL(99991231235959))
    nr=nr/LL(1000000);			// Timestamp to date
  if (nr < 0 || nr > LL(99991231))
  {
    tmp=0L;
3713 3714
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE,
3715
                         nr, MYSQL_TIMESTAMP_DATE, 0);
unknown's avatar
unknown committed
3716
    error= 1;
unknown's avatar
unknown committed
3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727
  }
  else
    tmp=(long) nr;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
3728
  return error;
unknown's avatar
unknown committed
3729 3730 3731
}


unknown's avatar
unknown committed
3732 3733 3734 3735 3736 3737 3738 3739 3740 3741
bool Field_date::send_binary(Protocol *protocol)
{
  longlong tmp= Field_date::val_int();
  TIME tm;
  tm.year= (uint32) tmp/10000L % 10000;
  tm.month= (uint32) tmp/100 % 100;
  tm.day= (uint32) tmp % 100;
  return protocol->store_date(&tm);
}

unknown's avatar
unknown committed
3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769

double Field_date::val_real(void)
{
  int32 j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return (double) (uint32) j;
}

longlong Field_date::val_int(void)
{
  int32 j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint4korr(ptr);
  else
#endif
    longget(j,ptr);
  return (longlong) (uint32) j;
}

String *Field_date::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
3770
  TIME ltime;
unknown's avatar
unknown committed
3771 3772 3773 3774 3775 3776 3777 3778
  val_buffer->alloc(field_length);
  int32 tmp;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    tmp=sint4korr(ptr);
  else
#endif
    longget(tmp,ptr);
3779 3780 3781 3782
  ltime.neg= 0;
  ltime.year= (int) ((uint32) tmp/10000L % 10000);
  ltime.month= (int) ((uint32) tmp/100 % 100);
  ltime.day= (int) ((uint32) tmp % 100);
3783
  make_date((DATE_TIME_FORMAT *) 0, &ltime, val_buffer);
unknown's avatar
unknown committed
3784 3785 3786
  return val_buffer;
}

3787

unknown's avatar
unknown committed
3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828
int Field_date::cmp(const char *a_ptr, const char *b_ptr)
{
  int32 a,b;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    a=sint4korr(a_ptr);
    b=sint4korr(b_ptr);
  }
  else
#endif
  {
    longget(a,a_ptr);
    longget(b,b_ptr);
  }
  return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
}


void Field_date::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
  if (!table->db_low_byte_first)
  {
    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
{
3829
  res.set_ascii("date", 4);
unknown's avatar
unknown committed
3830 3831 3832 3833 3834 3835 3836 3837
}

/****************************************************************************
** The new date type
** This is identical to the old date type, but stored on 3 bytes instead of 4
** In number context: YYYYMMDD
****************************************************************************/

unknown's avatar
unknown committed
3838
int Field_newdate::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3839 3840 3841
{
  TIME l_time;
  long tmp;
3842
  int error;
3843
  if (str_to_datetime(from, len, &l_time, 1, &error) <= MYSQL_TIMESTAMP_ERROR)
3844
  {
unknown's avatar
unknown committed
3845
    tmp=0L;
unknown's avatar
unknown committed
3846
    error= 1;
3847
  }
unknown's avatar
unknown committed
3848 3849
  else
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
3850 3851 3852

  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
3853
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
3854
    
unknown's avatar
unknown committed
3855
  int3store(ptr,tmp);
3856
  return error;
unknown's avatar
unknown committed
3857 3858
}

unknown's avatar
unknown committed
3859
int Field_newdate::store(double nr)
unknown's avatar
unknown committed
3860 3861
{
  if (nr < 0.0 || nr > 99991231235959.0)
3862 3863
  {
    (void) Field_newdate::store((longlong) -1);
3864
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3865
                         ER_WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATE);
3866 3867
    return 1;
  }
unknown's avatar
unknown committed
3868
  else
3869
    return Field_newdate::store((longlong) rint(nr));
unknown's avatar
unknown committed
3870 3871 3872
}


unknown's avatar
unknown committed
3873
int Field_newdate::store(longlong nr)
unknown's avatar
unknown committed
3874
{
unknown's avatar
unknown committed
3875
  int32 tmp;
unknown's avatar
unknown committed
3876
  int error= 0;
unknown's avatar
unknown committed
3877 3878 3879 3880 3881
  if (nr >= LL(100000000) && nr <= LL(99991231235959))
    nr=nr/LL(1000000);			// Timestamp to date
  if (nr < 0L || nr > 99991231L)
  {
    tmp=0;
3882
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3883 3884
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_DATE, 1);
unknown's avatar
unknown committed
3885
    error= 1;
unknown's avatar
unknown committed
3886 3887 3888
  }
  else
  {
unknown's avatar
unknown committed
3889
    tmp=(int32) nr;
unknown's avatar
unknown committed
3890 3891 3892
    if (tmp)
    {
      if (tmp < YY_PART_YEAR*10000L)			// Fix short dates
unknown's avatar
unknown committed
3893
	tmp+= (uint32) 20000000L;
unknown's avatar
unknown committed
3894
      else if (tmp < 999999L)
unknown's avatar
unknown committed
3895
	tmp+= (uint32) 19000000L;
unknown's avatar
unknown committed
3896
    }
unknown's avatar
unknown committed
3897 3898
    uint month= (uint) ((tmp/100) % 100);
    uint day=   (uint) (tmp%100);
unknown's avatar
unknown committed
3899 3900 3901
    if (month > 12 || day > 31)
    {
      tmp=0L;					// Don't allow date to change
3902
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3903 3904
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_DATE, 1);
unknown's avatar
unknown committed
3905
      error= 1;
unknown's avatar
unknown committed
3906 3907 3908 3909
    }
    else
      tmp= day + month*32 + (tmp/10000)*16*32;
  }
unknown's avatar
unknown committed
3910
  int3store(ptr,(int32) tmp);
3911
  return error;
unknown's avatar
unknown committed
3912 3913 3914 3915 3916
}

void Field_newdate::store_time(TIME *ltime,timestamp_type type)
{
  long tmp;
3917
  if (type == MYSQL_TIMESTAMP_DATE || type == MYSQL_TIMESTAMP_DATETIME)
unknown's avatar
unknown committed
3918 3919 3920 3921
    tmp=ltime->year*16*32+ltime->month*32+ltime->day;
  else
  {
    tmp=0;
3922
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
3923 3924 3925 3926
  }
  int3store(ptr,tmp);
}

unknown's avatar
unknown committed
3927 3928 3929 3930 3931 3932
bool Field_newdate::send_binary(Protocol *protocol)
{
  TIME tm;
  Field_newdate::get_date(&tm,0);
  return protocol->store_date(&tm);
}
unknown's avatar
unknown committed
3933 3934 3935 3936 3937 3938 3939 3940

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

longlong Field_newdate::val_int(void)
{
unknown's avatar
unknown committed
3941
  ulong j= uint3korr(ptr);
unknown's avatar
unknown committed
3942 3943 3944 3945 3946 3947 3948 3949 3950
  j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
  return (longlong) j;
}

String *Field_newdate::val_str(String *val_buffer,
			       String *val_ptr __attribute__((unused)))
{
  val_buffer->alloc(field_length);
  val_buffer->length(field_length);
unknown's avatar
unknown committed
3951
  uint32 tmp=(uint32) uint3korr(ptr);
unknown's avatar
unknown committed
3952 3953 3954 3955
  int part;
  char *pos=(char*) val_buffer->ptr()+10;

  /* Open coded to get more speed */
unknown's avatar
unknown committed
3956
  *pos--=0;					// End NULL
unknown's avatar
unknown committed
3957
  part=(int) (tmp & 31);
unknown's avatar
unknown committed
3958 3959 3960
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
unknown's avatar
unknown committed
3961
  part=(int) (tmp >> 5 & 15);
unknown's avatar
unknown committed
3962 3963 3964
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
unknown's avatar
unknown committed
3965
  part=(int) (tmp >> 9);
unknown's avatar
unknown committed
3966 3967 3968 3969
  *pos--= (char) ('0'+part%10); part/=10;
  *pos--= (char) ('0'+part%10); part/=10;
  *pos--= (char) ('0'+part%10); part/=10;
  *pos=   (char) ('0'+part);
unknown's avatar
unknown committed
3970 3971 3972
  return val_buffer;
}

3973
bool Field_newdate::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
3974 3975 3976
{
  if (is_null())
    return 1;
unknown's avatar
unknown committed
3977
  uint32 tmp=(uint32) uint3korr(ptr);
unknown's avatar
unknown committed
3978 3979 3980
  ltime->day=   tmp & 31;
  ltime->month= (tmp >> 5) & 15;
  ltime->year=  (tmp >> 9);
3981
  ltime->time_type= MYSQL_TIMESTAMP_DATE;
3982
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
unknown's avatar
unknown committed
3983
  return (!fuzzydate && (!ltime->month || !ltime->day)) ? 1 : 0;
unknown's avatar
unknown committed
3984 3985 3986 3987
}

bool Field_newdate::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
3988
  return Field_newdate::get_date(ltime,0);
unknown's avatar
unknown committed
3989 3990 3991 3992
}

int Field_newdate::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
3993 3994 3995
  uint32 a,b;
  a=(uint32) uint3korr(a_ptr);
  b=(uint32) uint3korr(b_ptr);
unknown's avatar
unknown committed
3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007
  return (a < b) ? -1 : (a > b) ? 1 : 0;
}

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

void Field_newdate::sql_type(String &res) const
{
4008
  res.set_ascii("date", 4);
unknown's avatar
unknown committed
4009 4010 4011 4012 4013 4014 4015 4016 4017 4018
}


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

unknown's avatar
unknown committed
4019
int Field_datetime::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4020
{
4021 4022 4023 4024
  TIME time_tmp;
  int error;
  ulonglong tmp= 0;
  
4025
  if (str_to_datetime(from, len, &time_tmp, 1, &error) > MYSQL_TIMESTAMP_ERROR)
4026 4027 4028 4029 4030
    tmp= TIME_to_ulonglong_datetime(&time_tmp);
  
  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE,
4031
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
4032

unknown's avatar
unknown committed
4033 4034 4035 4036 4037 4038 4039 4040
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
4041
  return error;
unknown's avatar
unknown committed
4042 4043 4044
}


unknown's avatar
unknown committed
4045
int Field_datetime::store(double nr)
unknown's avatar
unknown committed
4046
{
unknown's avatar
unknown committed
4047
  int error= 0;
unknown's avatar
unknown committed
4048 4049
  if (nr < 0.0 || nr > 99991231235959.0)
  {
4050 4051
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE,
4052
                         nr, MYSQL_TIMESTAMP_DATETIME);
unknown's avatar
unknown committed
4053
    nr=0.0;
unknown's avatar
unknown committed
4054
    error= 1;
unknown's avatar
unknown committed
4055
  }
4056 4057
  error |= Field_datetime::store((longlong) rint(nr));
  return error;
unknown's avatar
unknown committed
4058 4059 4060
}


unknown's avatar
unknown committed
4061
int Field_datetime::store(longlong nr)
unknown's avatar
unknown committed
4062
{
4063
  TIME not_used;
4064 4065
  int error;
  longlong initial_nr= nr;
4066
  
4067 4068 4069 4070 4071
  nr= number_to_TIME(nr, &not_used, 1, &error);

  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_TRUNCATED, initial_nr, 
4072
                         MYSQL_TIMESTAMP_DATETIME, 1);
4073

unknown's avatar
unknown committed
4074 4075 4076 4077 4078 4079 4080 4081
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,nr);
  }
  else
#endif
    longlongstore(ptr,nr);
4082
  return error;
unknown's avatar
unknown committed
4083 4084
}

unknown's avatar
unknown committed
4085

unknown's avatar
unknown committed
4086 4087 4088
void Field_datetime::store_time(TIME *ltime,timestamp_type type)
{
  longlong tmp;
4089 4090 4091 4092
  /*
    We don't perform range checking here since values stored in TIME
    structure always fit into DATETIME range.
  */
4093
  if (type == MYSQL_TIMESTAMP_DATE || type == MYSQL_TIMESTAMP_DATETIME)
unknown's avatar
unknown committed
4094 4095 4096 4097 4098
    tmp=((ltime->year*10000L+ltime->month*100+ltime->day)*LL(1000000)+
	 (ltime->hour*10000L+ltime->minute*100+ltime->second));
  else
  {
    tmp=0;
4099
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110
  }
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
}

unknown's avatar
unknown committed
4111 4112 4113
bool Field_datetime::send_binary(Protocol *protocol)
{
  TIME tm;
4114
  Field_datetime::get_date(&tm, TIME_FUZZY_DATE);
unknown's avatar
unknown committed
4115 4116 4117
  return protocol->store(&tm);
}

unknown's avatar
unknown committed
4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162

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

longlong Field_datetime::val_int(void)
{
  longlong j;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    j=sint8korr(ptr);
  else
#endif
    longlongget(j,ptr);
  return j;
}


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

#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    tmp=sint8korr(ptr);
  else
#endif
    longlongget(tmp,ptr);

  /*
    Avoid problem with slow longlong aritmetic and sprintf
  */

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

  pos=(char*) val_buffer->ptr()+19;
  *pos--=0;
unknown's avatar
unknown committed
4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181
  *pos--= (char) ('0'+(char) (part2%10)); part2/=10;
  *pos--= (char) ('0'+(char) (part2%10)); part3= (int) (part2 / 10);
  *pos--= ':';
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos--= ':';
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos--= (char) ('0'+(char) part3);
  *pos--= ' ';
  *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
  *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
  *pos--= '-';
  *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
  *pos--= (char) ('0'+(char) (part1%10)); part3= (int) (part1/10);
  *pos--= '-';
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  *pos=(char) ('0'+(char) part3);
unknown's avatar
unknown committed
4182 4183 4184
  return val_buffer;
}

4185
bool Field_datetime::get_date(TIME *ltime, uint fuzzydate)
unknown's avatar
unknown committed
4186 4187
{
  longlong tmp=Field_datetime::val_int();
unknown's avatar
unknown committed
4188 4189 4190
  uint32 part1,part2;
  part1=(uint32) (tmp/LL(1000000));
  part2=(uint32) (tmp - (ulonglong) part1*LL(1000000));
unknown's avatar
unknown committed
4191

4192
  ltime->time_type=	MYSQL_TIMESTAMP_DATETIME;
unknown's avatar
unknown committed
4193 4194 4195 4196 4197 4198 4199 4200
  ltime->neg=		0;
  ltime->second_part=	0;
  ltime->second=	(int) (part2%100);
  ltime->minute=	(int) (part2/100%100);
  ltime->hour=		(int) (part2/10000);
  ltime->day=		(int) (part1%100);
  ltime->month= 	(int) (part1/100%100);
  ltime->year= 		(int) (part1/10000);
unknown's avatar
unknown committed
4201
  return (!fuzzydate && (!ltime->month || !ltime->day)) ? 1 : 0;
unknown's avatar
unknown committed
4202 4203 4204 4205
}

bool Field_datetime::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
4206
  return Field_datetime::get_date(ltime,0);
unknown's avatar
unknown committed
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 4254 4255 4256 4257 4258
}

int Field_datetime::cmp(const char *a_ptr, const char *b_ptr)
{
  longlong a,b;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    a=sint8korr(a_ptr);
    b=sint8korr(b_ptr);
  }
  else
#endif
  {
    longlongget(a,a_ptr);
    longlongget(b,b_ptr);
  }
  return ((ulonglong) a < (ulonglong) b) ? -1 :
    ((ulonglong) a > (ulonglong) b) ? 1 : 0;
}

void Field_datetime::sort_string(char *to,uint length __attribute__((unused)))
{
#ifdef WORDS_BIGENDIAN
  if (!table->db_low_byte_first)
  {
    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
{
4259
  res.set_ascii("datetime", 8);
unknown's avatar
unknown committed
4260 4261 4262 4263 4264 4265 4266 4267 4268
}

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

	/* Copy a string and fill with space */

unknown's avatar
unknown committed
4269
int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4270
{
unknown's avatar
unknown committed
4271
  int error= 0;
unknown's avatar
unknown committed
4272
  uint32 not_used;
unknown's avatar
unknown committed
4273 4274
  char buff[80];
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
4275
  uint copy_length;
4276 4277 4278 4279
  
  /* See the comment for Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
  
unknown's avatar
unknown committed
4280
  /* Convert character set if nesessary */
unknown's avatar
unknown committed
4281
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
4282
  { 
4283 4284
    uint conv_errors;
    tmpstr.copy(from, length, cs, field_charset, &conv_errors);
unknown's avatar
unknown committed
4285 4286
    from= tmpstr.ptr();
    length=  tmpstr.length();
4287 4288
    if (conv_errors)
      error= 1;
unknown's avatar
unknown committed
4289
  }
unknown's avatar
unknown committed
4290 4291

  /* 
4292
    Make sure we don't break a multibyte sequence
unknown's avatar
unknown committed
4293 4294
    as well as don't copy a malformed data.
  */
4295 4296 4297 4298
  copy_length= field_charset->cset->well_formed_len(field_charset,
						    from,from+length,
						    field_length/
						    field_charset->mbmaxlen);
unknown's avatar
unknown committed
4299 4300 4301 4302 4303
  memcpy(ptr,from,copy_length);
  if (copy_length < field_length)	// Append spaces if shorter
    field_charset->cset->fill(field_charset,ptr+copy_length,
			      field_length-copy_length,' ');
  
4304
  if ((copy_length < length) && table->in_use->count_cuted_fields)
unknown's avatar
unknown committed
4305 4306 4307 4308 4309 4310
  {					// Check if we loosed some info
    const char *end=from+length;
    from+= copy_length;
    from+= field_charset->cset->scan(field_charset, from, end,
				     MY_SEQ_SPACES);
    if (from != end)
4311
      error= 1;
unknown's avatar
unknown committed
4312
  }
4313 4314 4315
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);

4316
  return error;
unknown's avatar
unknown committed
4317 4318 4319
}


4320 4321 4322 4323
/*
  Store double value in Field_string or Field_varstring.

  SYNOPSIS
unknown's avatar
unknown committed
4324
    store(double nr)
4325 4326 4327 4328 4329 4330
    nr            number

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

unknown's avatar
unknown committed
4331
int Field_str::store(double nr)
unknown's avatar
unknown committed
4332
{
4333
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
4334
  uint length;
unknown's avatar
unknown committed
4335 4336
  bool use_scientific_notation= TRUE;
  use_scientific_notation= TRUE;
unknown's avatar
unknown committed
4337
  if (field_length < 32 && fabs(nr) < log_10[field_length]-1)
unknown's avatar
unknown committed
4338
    use_scientific_notation= FALSE;
unknown's avatar
unknown committed
4339

unknown's avatar
unknown committed
4340 4341 4342 4343 4344
  length= (uint) my_sprintf(buff, (buff, "%-.*g",
                                   (use_scientific_notation ?
                                    max(0, (int)field_length-5) :
                                    field_length),
                                   nr));
4345 4346 4347 4348 4349
  /*
    +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)
4350 4351
    the test for field_length < 5 is for extreme cases,
    like inserting 500.0 in char(1)
4352
  */
4353
  DBUG_ASSERT(field_length < 5 || length <= field_length+1);
4354
  return store((const char *) buff, length, charset());
4355 4356
}

unknown's avatar
unknown committed
4357

unknown's avatar
unknown committed
4358
int Field_string::store(longlong nr)
unknown's avatar
unknown committed
4359
{
unknown's avatar
unknown committed
4360 4361 4362
  char buff[64];
  int  l;
  CHARSET_INFO *cs=charset();
4363
  l= (cs->cset->longlong10_to_str)(cs,buff,sizeof(buff),-10,nr);
unknown's avatar
unknown committed
4364
  return Field_string::store(buff,(uint)l,cs);
unknown's avatar
unknown committed
4365 4366 4367 4368 4369
}


double Field_string::val_real(void)
{
4370
  int not_used;
unknown's avatar
unknown committed
4371
  CHARSET_INFO *cs=charset();
4372
  return my_strntod(cs,ptr,field_length,(char**)0,&not_used);
unknown's avatar
unknown committed
4373 4374 4375 4376 4377
}


longlong Field_string::val_int(void)
{
4378
  int not_used;
4379
  CHARSET_INFO *cs=charset();
4380
  return my_strntoll(cs,ptr,field_length,10,NULL,&not_used);
unknown's avatar
unknown committed
4381 4382 4383 4384 4385 4386
}


String *Field_string::val_str(String *val_buffer __attribute__((unused)),
			      String *val_ptr)
{
unknown's avatar
unknown committed
4387
  uint length= field_charset->cset->lengthsp(field_charset, ptr, field_length);
4388 4389
  /* See the comment for Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
unknown's avatar
unknown committed
4390
  val_ptr->set((const char*) ptr, length, field_charset);
unknown's avatar
unknown committed
4391 4392 4393 4394 4395 4396
  return val_ptr;
}


int Field_string::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
4397 4398
  uint a_len, b_len;

unknown's avatar
unknown committed
4399
  if (field_charset->strxfrm_multiply > 1)
4400 4401 4402 4403 4404
  {
    /*
      We have to remove end space to be able to compare multi-byte-characters
      like in latin_de 'ae' and 0xe4
    */
4405
    return field_charset->coll->strnncollsp(field_charset,
unknown's avatar
unknown committed
4406 4407 4408
                                            (const uchar*) a_ptr, field_length,
                                            (const uchar*) b_ptr,
                                            field_length);
4409
  }
unknown's avatar
unknown committed
4410 4411 4412 4413 4414 4415 4416 4417
  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;
4418 4419
  return my_strnncoll(field_charset,(const uchar*) a_ptr, a_len,
                                    (const uchar*) b_ptr, b_len);
unknown's avatar
unknown committed
4420 4421
}

4422

unknown's avatar
unknown committed
4423 4424
void Field_string::sort_string(char *to,uint length)
{
4425
  uint tmp=my_strnxfrm(field_charset,
4426 4427
		       (unsigned char *) to, length,
		       (unsigned char *) ptr, field_length);
4428
  if (tmp < length)
4429
    field_charset->cset->fill(field_charset, to + tmp, length - tmp, ' ');
unknown's avatar
unknown committed
4430 4431 4432 4433 4434
}


void Field_string::sql_type(String &res) const
{
4435
  THD *thd= table->in_use;
unknown's avatar
unknown committed
4436
  CHARSET_INFO *cs=res.charset();
4437
  ulong length= cs->cset->snprintf(cs,(char*) res.ptr(),
unknown's avatar
unknown committed
4438
			    res.alloced_length(), "%s(%d)",
4439 4440 4441
			    (field_length > 3 &&
			     (table->db_options_in_use &
			      HA_OPTION_PACK_RECORD) ?
4442
			      (has_charset() ? "varchar" : "varbinary") :
4443
			      (has_charset() ? "char" : "binary")),
4444
			    (int) field_length / charset()->mbmaxlen);
4445
  res.length(length);
4446 4447 4448
  if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
      has_charset() && (charset()->state & MY_CS_BINSORT))
    res.append(" binary");
unknown's avatar
unknown committed
4449 4450 4451
}

char *Field_string::pack(char *to, const char *from, uint max_length)
4452
{
unknown's avatar
unknown committed
4453 4454
  uint length=      min(field_length,max_length);
  uint char_length= max_length/field_charset->mbmaxlen;
4455
  if (length > char_length)
unknown's avatar
unknown committed
4456
    char_length= my_charpos(field_charset, from, from+length, char_length);
4457
  set_if_smaller(length, char_length);
unknown's avatar
unknown committed
4458 4459
  while (length && from[length-1] == ' ')
    length--;
4460
  *to++= (char) (uchar) length;
4461
  if (field_length > 255)
4462
    *to++= (char) (uchar) (length >> 8);
4463 4464
  memcpy(to, from, length);
  return to+length;
4465 4466 4467
}


unknown's avatar
unknown committed
4468 4469
const char *Field_string::unpack(char *to, const char *from)
{
4470 4471 4472 4473 4474 4475 4476 4477
  uint length;
  if (field_length > 255)
  {
    length= uint2korr(from);
    from+= 2;
  }
  else
    length= (uint) (uchar) *from++;
unknown's avatar
unknown committed
4478 4479 4480 4481 4482 4483 4484 4485
  memcpy(to, from, (int) length);
  bfill(to+length, field_length - length, ' ');
  return from+length;
}


int Field_string::pack_cmp(const char *a, const char *b, uint length)
{
4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498
  uint a_length, b_length;
  if (field_length > 255)
  {
    a_length= uint2korr(a);
    b_length= uint2korr(b);
    a+= 2;
    b+= 2;
  }
  else
  {
    a_length= (uint) (uchar) *a++;
    b_length= (uint) (uchar) *b++;
  }
unknown's avatar
unknown committed
4499 4500 4501
  return my_strnncoll(field_charset,
		      (const uchar*)a,a_length,
		      (const uchar*)b,b_length);
unknown's avatar
unknown committed
4502 4503 4504
}


4505 4506
int Field_string::pack_cmp(const char *b, uint length)
{
4507 4508 4509 4510 4511 4512 4513 4514
  uint b_length;
  if (field_length > 255)
  {
    b_length= uint2korr(b);
    b+= 2;
  }
  else
    b_length= (uint) (uchar) *b++;
4515 4516 4517 4518
  char *end= ptr + field_length;
  while (end > ptr && end[-1] == ' ')
    end--;
  uint a_length = (uint) (end - ptr);
unknown's avatar
unknown committed
4519 4520 4521
  return my_strnncoll(field_charset,
		     (const uchar*)ptr,a_length,
		     (const uchar*)b, b_length);
4522 4523 4524
}


4525
uint Field_string::packed_col_length(const char *data_ptr, uint length)
unknown's avatar
unknown committed
4526
{
4527
  if (length > 255)
4528
    return uint2korr(data_ptr)+2;
unknown's avatar
unknown committed
4529
  else
4530
    return (uint) ((uchar) *data_ptr)+1;
unknown's avatar
unknown committed
4531 4532 4533 4534
}

uint Field_string::max_packed_col_length(uint max_length)
{
4535
  return (max_length > 255 ? 2 : 1)+max_length;
unknown's avatar
unknown committed
4536 4537 4538 4539 4540 4541 4542 4543
}


/****************************************************************************
** VARCHAR type  (Not available for the end user yet)
****************************************************************************/


unknown's avatar
unknown committed
4544
int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4545
{
unknown's avatar
unknown committed
4546
  int error= 0;
unknown's avatar
unknown committed
4547
  uint32 not_used;
unknown's avatar
unknown committed
4548 4549
  char buff[80];
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
4550

unknown's avatar
unknown committed
4551
  /* Convert character set if nesessary */
unknown's avatar
unknown committed
4552
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
4553
  { 
4554 4555
    uint conv_errors;
    tmpstr.copy(from, length, cs, field_charset, &conv_errors);
unknown's avatar
unknown committed
4556 4557
    from= tmpstr.ptr();
    length=  tmpstr.length();
4558 4559
    if (conv_errors)
      error= 1;
unknown's avatar
unknown committed
4560
  }
4561
  if (length > field_length)
unknown's avatar
unknown committed
4562 4563
  {
    length=field_length;
unknown's avatar
unknown committed
4564
    error= 1;
unknown's avatar
unknown committed
4565
  }
4566 4567
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
4568
  memcpy(ptr+HA_KEY_BLOB_LENGTH,from,length);
4569
  int2store(ptr, length);
4570
  return error;
unknown's avatar
unknown committed
4571 4572 4573
}


unknown's avatar
unknown committed
4574
int Field_varstring::store(longlong nr)
unknown's avatar
unknown committed
4575
{
unknown's avatar
unknown committed
4576 4577 4578
  char buff[64];
  int  l;
  CHARSET_INFO *cs=charset();
4579
  l= (cs->cset->longlong10_to_str)(cs,buff,sizeof(buff),-10,nr);
unknown's avatar
unknown committed
4580
  return Field_varstring::store(buff,(uint)l,cs);
unknown's avatar
unknown committed
4581 4582 4583 4584 4585
}


double Field_varstring::val_real(void)
{
4586
  int not_used;
4587
  uint length=uint2korr(ptr)+HA_KEY_BLOB_LENGTH;
unknown's avatar
unknown committed
4588
  CHARSET_INFO *cs=charset();
4589
  return my_strntod(cs, ptr+HA_KEY_BLOB_LENGTH, length, (char**)0, &not_used);
unknown's avatar
unknown committed
4590 4591 4592 4593 4594
}


longlong Field_varstring::val_int(void)
{
4595
  int not_used;
4596
  uint length=uint2korr(ptr)+HA_KEY_BLOB_LENGTH;
4597
  CHARSET_INFO *cs=charset();
4598
  return my_strntoll(cs,ptr+HA_KEY_BLOB_LENGTH,length,10,NULL, &not_used);
unknown's avatar
unknown committed
4599 4600 4601 4602 4603 4604 4605
}


String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
				 String *val_ptr)
{
  uint length=uint2korr(ptr);
4606
  val_ptr->set((const char*) ptr+HA_KEY_BLOB_LENGTH,length,field_charset);
unknown's avatar
unknown committed
4607 4608 4609 4610 4611 4612 4613 4614 4615
  return val_ptr;
}


int Field_varstring::cmp(const char *a_ptr, const char *b_ptr)
{
  uint a_length=uint2korr(a_ptr);
  uint b_length=uint2korr(b_ptr);
  int diff;
4616 4617 4618 4619 4620
  diff= my_strnncoll(field_charset,
		     (const uchar*) a_ptr+HA_KEY_BLOB_LENGTH,
		     min(a_length,b_length),
		     (const uchar*) b_ptr+HA_KEY_BLOB_LENGTH,
		     min(a_length,b_length));
unknown's avatar
unknown committed
4621 4622 4623 4624 4625 4626
  return diff ? diff : (int) (a_length - b_length);
}

void Field_varstring::sort_string(char *to,uint length)
{
  uint tot_length=uint2korr(ptr);
4627 4628 4629 4630
  tot_length= my_strnxfrm(field_charset,
			  (uchar*) to, length,
			  (uchar*) ptr+HA_KEY_BLOB_LENGTH,
			  tot_length);
unknown's avatar
unknown committed
4631
  if (tot_length < length)
4632 4633
    field_charset->cset->fill(field_charset, to+tot_length,length-tot_length,
			      binary() ? (char) 0 : ' ');
unknown's avatar
unknown committed
4634 4635 4636 4637 4638
}


void Field_varstring::sql_type(String &res) const
{
unknown's avatar
unknown committed
4639
  CHARSET_INFO *cs=res.charset();
4640
  ulong length= cs->cset->snprintf(cs,(char*) res.ptr(),
unknown's avatar
unknown committed
4641
			     res.alloced_length(),"varchar(%u)",
4642
			     field_length / charset()->mbmaxlen);
4643
  res.length(length);
unknown's avatar
unknown committed
4644 4645 4646 4647
}

char *Field_varstring::pack(char *to, const char *from, uint max_length)
{
4648
  uint length=uint2korr(from);
unknown's avatar
unknown committed
4649 4650
  if (length > max_length)
    length=max_length;
unknown's avatar
unknown committed
4651
  *to++= (char) (length & 255);
unknown's avatar
unknown committed
4652
  if (max_length > 255)
unknown's avatar
unknown committed
4653
    *to++= (char) (length >> 8);
unknown's avatar
unknown committed
4654
  if (length)
4655
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
unknown's avatar
unknown committed
4656 4657 4658 4659
  return to+length;
}


4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677
char *Field_varstring::pack_key(char *to, const char *from, uint max_length)
{
  uint length=uint2korr(from);
  uint char_length= (field_charset->mbmaxlen > 1) ?
              max_length/field_charset->mbmaxlen : max_length;
  from+=HA_KEY_BLOB_LENGTH;
  if (length > char_length)
    char_length= my_charpos(field_charset, from, from+length, char_length);
  set_if_smaller(length, char_length);
  *to++= (char) (length & 255);
  if (max_length > 255)
    *to++= (char) (length >> 8);
  if (length)
    memcpy(to, from, length);
  return to+length;
}


unknown's avatar
unknown committed
4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692
const char *Field_varstring::unpack(char *to, const char *from)
{
  uint length;
  if (field_length > 255)
  {
    length= (uint) (uchar) (*to= *from++);
    to[1]=0;
  }
  else
  {
    length=uint2korr(from);
    to[0] = *from++;
    to[1] = *from++;
  }
  if (length)
4693
    memcpy(to+HA_KEY_BLOB_LENGTH, from, length);
unknown's avatar
unknown committed
4694 4695 4696 4697 4698 4699 4700 4701 4702 4703
  return from+length;
}


int Field_varstring::pack_cmp(const char *a, const char *b, uint key_length)
{
  uint a_length;
  uint b_length;
  if (key_length > 255)
  {
4704 4705
    a_length=uint2korr(a); a+= 2;
    b_length=uint2korr(b); b+= 2;
unknown's avatar
unknown committed
4706 4707 4708 4709 4710 4711
  }
  else
  {
    a_length= (uint) (uchar) *a++;
    b_length= (uint) (uchar) *b++;
  }
unknown's avatar
unknown committed
4712
  return my_strnncoll(field_charset,
4713 4714
		     (const uchar*) a, a_length,
		     (const uchar*) b, b_length);
unknown's avatar
unknown committed
4715 4716
}

4717 4718
int Field_varstring::pack_cmp(const char *b, uint key_length)
{
4719 4720
  char *a= ptr+HA_KEY_BLOB_LENGTH;
  uint a_length= uint2korr(ptr);
4721 4722 4723
  uint b_length;
  if (key_length > 255)
  {
4724
    b_length=uint2korr(b); b+= 2;
4725 4726 4727 4728 4729
  }
  else
  {
    b_length= (uint) (uchar) *b++;
  }
unknown's avatar
unknown committed
4730
  return my_strnncoll(field_charset,
4731 4732
		     (const uchar*) a, a_length,
		     (const uchar*) b, b_length);
4733 4734
}

4735
uint Field_varstring::packed_col_length(const char *data_ptr, uint length)
unknown's avatar
unknown committed
4736
{
4737
  if (length > 255)
4738
    return uint2korr(data_ptr)+HA_KEY_BLOB_LENGTH;
unknown's avatar
unknown committed
4739
  else
4740
    return (uint) ((uchar) *data_ptr)+1;
unknown's avatar
unknown committed
4741 4742 4743 4744
}

uint Field_varstring::max_packed_col_length(uint max_length)
{
4745
  return (max_length > 255 ? 2 : 1)+max_length;
unknown's avatar
unknown committed
4746 4747
}

4748 4749
void Field_varstring::get_key_image(char *buff, uint length, CHARSET_INFO *cs,
				    imagetype type)
4750 4751 4752 4753 4754
{
  uint f_length=uint2korr(ptr);
  if (f_length > length)
    f_length= length;
  int2store(buff,length);
4755
  memcpy(buff+HA_KEY_BLOB_LENGTH, ptr+HA_KEY_BLOB_LENGTH, length);
4756 4757
#ifdef HAVE_purify
  if (f_length < length)
4758
    bzero(buff+HA_KEY_BLOB_LENGTH+f_length, (length-f_length));
4759 4760 4761
#endif
}

unknown's avatar
unknown committed
4762
void Field_varstring::set_key_image(char *buff,uint length, CHARSET_INFO *cs)
4763 4764
{
  length=uint2korr(buff);			// Real length is here
4765
  (void) Field_varstring::store(buff+HA_KEY_BLOB_LENGTH, length, cs);
4766 4767 4768 4769
}



unknown's avatar
unknown committed
4770 4771 4772 4773 4774 4775
/****************************************************************************
** blob type
** A blob is saved as a length and a pointer. The length is stored in the
** packlength slot and may be from 1-4.
****************************************************************************/

unknown's avatar
unknown committed
4776
Field_blob::Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
4777 4778
		       enum utype unireg_check_arg, const char *field_name_arg,
		       struct st_table *table_arg,uint blob_pack_length,
4779
		       CHARSET_INFO *cs)
unknown's avatar
unknown committed
4780 4781
  :Field_str(ptr_arg, (1L << min(blob_pack_length,3)*8)-1L,
	     null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
4782
	     table_arg, cs),
unknown's avatar
unknown committed
4783
   packlength(blob_pack_length)
unknown's avatar
unknown committed
4784 4785 4786 4787 4788 4789 4790
{
  flags|= BLOB_FLAG;
  if (table)
    table->blob_fields++;
}


unknown's avatar
unknown committed
4791
void Field_blob::store_length(uint32 number)
unknown's avatar
unknown committed
4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822
{
  switch (packlength) {
  case 1:
    ptr[0]= (uchar) number;
    break;
  case 2:
#ifdef WORDS_BIGENDIAN
    if (table->db_low_byte_first)
    {
      int2store(ptr,(unsigned short) number);
    }
    else
#endif
      shortstore(ptr,(unsigned short) number);
    break;
  case 3:
    int3store(ptr,number);
    break;
  case 4:
#ifdef WORDS_BIGENDIAN
    if (table->db_low_byte_first)
    {
      int4store(ptr,number);
    }
    else
#endif
      longstore(ptr,number);
  }
}


unknown's avatar
unknown committed
4823
uint32 Field_blob::get_length(const char *pos)
unknown's avatar
unknown committed
4824 4825 4826
{
  switch (packlength) {
  case 1:
unknown's avatar
unknown committed
4827
    return (uint32) (uchar) pos[0];
unknown's avatar
unknown committed
4828 4829 4830 4831 4832 4833 4834 4835 4836
  case 2:
    {
      uint16 tmp;
#ifdef WORDS_BIGENDIAN
      if (table->db_low_byte_first)
	tmp=sint2korr(pos);
      else
#endif
	shortget(tmp,pos);
unknown's avatar
unknown committed
4837
      return (uint32) tmp;
unknown's avatar
unknown committed
4838 4839
    }
  case 3:
unknown's avatar
unknown committed
4840
    return (uint32) uint3korr(pos);
unknown's avatar
unknown committed
4841 4842 4843 4844 4845 4846 4847 4848 4849
  case 4:
    {
      uint32 tmp;
#ifdef WORDS_BIGENDIAN
      if (table->db_low_byte_first)
	tmp=uint4korr(pos);
      else
#endif
	longget(tmp,pos);
unknown's avatar
unknown committed
4850
      return (uint32) tmp;
unknown's avatar
unknown committed
4851 4852 4853 4854 4855 4856
    }
  }
  return 0;					// Impossible
}


4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892
/*
  Put a blob length field into a record buffer.

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

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

  RETURN
    nothing
*/

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


unknown's avatar
unknown committed
4893
int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4894
{
4895
  int error= 0;
unknown's avatar
unknown committed
4896
  if (!length)
unknown's avatar
unknown committed
4897 4898 4899 4900 4901
  {
    bzero(ptr,Field_blob::pack_length());
  }
  else
  {
unknown's avatar
unknown committed
4902
    bool was_conversion;
unknown's avatar
unknown committed
4903 4904
    char buff[80];
    String tmpstr(buff,sizeof(buff), &my_charset_bin);
4905
    uint copy_length;
unknown's avatar
unknown committed
4906
    uint32 not_used;
unknown's avatar
unknown committed
4907

unknown's avatar
unknown committed
4908
    /* Convert character set if nesessary */
unknown's avatar
unknown committed
4909 4910
    if ((was_conversion= String::needs_conversion(length, cs, field_charset,
						  &not_used)))
unknown's avatar
unknown committed
4911
    { 
4912 4913
      uint conv_errors;
      tmpstr.copy(from, length, cs, field_charset, &conv_errors);
unknown's avatar
unknown committed
4914 4915
      from= tmpstr.ptr();
      length=  tmpstr.length();
4916 4917
      if (conv_errors)
        error= 1;
unknown's avatar
unknown committed
4918
    }
4919 4920
    
    copy_length= max_data_length();
4921 4922 4923 4924 4925 4926 4927 4928 4929
    /*
      copy_length is ok as last argument to well_formed_len as this is never
      used to limit the length of the data. The cut of long data is done with
      the 'min()' call below.
    */
    copy_length= field_charset->cset->well_formed_len(field_charset,
						      from,from +
						      min(length, copy_length),
						      copy_length);
4930
    if (copy_length < length)
4931
      error= 1;
4932 4933
    Field_blob::store_length(copy_length);
    if (was_conversion || table->copy_blobs || copy_length <= MAX_FIELD_WIDTH)
unknown's avatar
unknown committed
4934
    {						// Must make a copy
unknown's avatar
unknown committed
4935 4936
      if (from != value.ptr())			// For valgrind
      {
4937
	value.copy(from,copy_length,charset());
unknown's avatar
unknown committed
4938
	from=value.ptr();
unknown's avatar
unknown committed
4939
      }
unknown's avatar
unknown committed
4940 4941 4942
    }
    bmove(ptr+packlength,(char*) &from,sizeof(char*));
  }
4943 4944
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
4945
  return 0;
unknown's avatar
unknown committed
4946 4947 4948
}


unknown's avatar
unknown committed
4949
int Field_blob::store(double nr)
unknown's avatar
unknown committed
4950
{
4951 4952 4953
  CHARSET_INFO *cs=charset();
  value.set(nr, 2, cs);
  return Field_blob::store(value.ptr(),(uint) value.length(), cs);
unknown's avatar
unknown committed
4954 4955 4956
}


unknown's avatar
unknown committed
4957
int Field_blob::store(longlong nr)
unknown's avatar
unknown committed
4958
{
4959 4960 4961
  CHARSET_INFO *cs=charset();
  value.set(nr, cs);
  return Field_blob::store(value.ptr(), (uint) value.length(), cs);
unknown's avatar
unknown committed
4962 4963 4964 4965 4966
}


double Field_blob::val_real(void)
{
4967
  int not_used;
unknown's avatar
unknown committed
4968 4969 4970 4971
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
    return 0.0;
unknown's avatar
unknown committed
4972
  uint32 length=get_length(ptr);
unknown's avatar
unknown committed
4973
  CHARSET_INFO *cs=charset();
4974
  return my_strntod(cs,blob,length,(char**)0, &not_used);
unknown's avatar
unknown committed
4975 4976 4977 4978 4979
}


longlong Field_blob::val_int(void)
{
4980
  int not_used;
unknown's avatar
unknown committed
4981 4982 4983 4984
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
    return 0;
unknown's avatar
unknown committed
4985
  uint32 length=get_length(ptr);
4986
  return my_strntoll(charset(),blob,length,10,NULL,&not_used);
unknown's avatar
unknown committed
4987 4988 4989 4990 4991 4992 4993 4994 4995
}


String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
			    String *val_ptr)
{
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
4996
    val_ptr->set("",0,charset());	// A bit safer than ->length(0)
unknown's avatar
unknown committed
4997
  else
4998
    val_ptr->set((const char*) blob,get_length(ptr),charset());
unknown's avatar
unknown committed
4999 5000 5001 5002
  return val_ptr;
}


unknown's avatar
unknown committed
5003 5004
int Field_blob::cmp(const char *a,uint32 a_length, const char *b,
		    uint32 b_length)
unknown's avatar
unknown committed
5005
{
5006 5007 5008 5009
  return field_charset->coll->strnncoll(field_charset, 
                                        (const uchar*)a, a_length,
                                        (const uchar*)b, b_length,
                                        0);
unknown's avatar
unknown committed
5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035
}


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


int Field_blob::cmp_offset(uint row_offset)
{
  return Field_blob::cmp(ptr,ptr+row_offset);
}


int Field_blob::cmp_binary_offset(uint row_offset)
{
  return cmp_binary(ptr, ptr+row_offset);
}


int Field_blob::cmp_binary(const char *a_ptr, const char *b_ptr,
unknown's avatar
unknown committed
5036
			   uint32 max_length)
unknown's avatar
unknown committed
5037 5038 5039
{
  char *a,*b;
  uint diff;
unknown's avatar
unknown committed
5040
  uint32 a_length,b_length;
unknown's avatar
unknown committed
5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055
  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 */

5056
void Field_blob::get_key_image(char *buff,uint length,
5057
			       CHARSET_INFO *cs, imagetype type)
unknown's avatar
unknown committed
5058
{
unknown's avatar
unknown committed
5059
  uint32 blob_length= get_length(ptr);
unknown's avatar
unknown committed
5060
  char *blob;
unknown's avatar
unknown committed
5061

unknown's avatar
unknown committed
5062
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
5063
  if (type == itMBR)
unknown's avatar
unknown committed
5064
  {
unknown's avatar
unknown committed
5065
    const char *dummy;
unknown's avatar
unknown committed
5066
    MBR mbr;
5067 5068
    Geometry_buffer buffer;
    Geometry *gobj;
unknown's avatar
unknown committed
5069 5070 5071 5072 5073 5074 5075

    if (blob_length < SRID_SIZE)
    {
      bzero(buff, SIZEOF_STORED_DOUBLE*4);
      return;
    }
    get_ptr(&blob);
5076 5077 5078
    gobj= Geometry::create_from_wkb(&buffer,
				    blob + SRID_SIZE, blob_length - SRID_SIZE);
    if (gobj->get_mbr(&mbr, &dummy))
unknown's avatar
unknown committed
5079 5080 5081 5082 5083 5084 5085 5086
      bzero(buff, SIZEOF_STORED_DOUBLE*4);
    else
    {
      float8store(buff,    mbr.xmin);
      float8store(buff+8,  mbr.xmax);
      float8store(buff+16, mbr.ymin);
      float8store(buff+24, mbr.ymax);
    }
unknown's avatar
unknown committed
5087 5088
    return;
  }
unknown's avatar
unknown committed
5089
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
5090

5091 5092
  get_ptr(&blob);
  uint char_length= length / cs->mbmaxlen;
5093 5094
  char_length= my_charpos(cs, blob, blob + blob_length, char_length);
  set_if_smaller(blob_length, char_length);
5095

unknown's avatar
unknown committed
5096
  if ((uint32) length > blob_length)
unknown's avatar
unknown committed
5097
  {
5098 5099 5100 5101
    /*
      Must clear this as we do a memcmp in opt_range.cc to detect
      identical keys
    */
5102
    bzero(buff+HA_KEY_BLOB_LENGTH+blob_length, (length-blob_length));
unknown's avatar
unknown committed
5103
    length=(uint) blob_length;
unknown's avatar
unknown committed
5104
  }
unknown's avatar
unknown committed
5105
  int2store(buff,length);
5106
  memcpy(buff+HA_KEY_BLOB_LENGTH, blob, length);
unknown's avatar
unknown committed
5107 5108
}

unknown's avatar
unknown committed
5109
void Field_blob::set_key_image(char *buff,uint length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
5110
{
5111 5112
  length= uint2korr(buff);
  (void) Field_blob::store(buff+HA_KEY_BLOB_LENGTH, length, cs);
unknown's avatar
unknown committed
5113 5114
}

unknown's avatar
unknown committed
5115

unknown's avatar
unknown committed
5116 5117 5118 5119 5120
int Field_blob::key_cmp(const byte *key_ptr, uint max_key_length)
{
  char *blob1;
  uint blob_length=get_length(ptr);
  memcpy_fixed(&blob1,ptr+packlength,sizeof(char*));
5121 5122 5123 5124
  CHARSET_INFO *cs= charset();
  uint char_length= max_key_length / cs->mbmaxlen;
  char_length= my_charpos(cs, blob1, blob1+blob_length, char_length);
  set_if_smaller(blob_length, char_length);
unknown's avatar
unknown committed
5125
  return Field_blob::cmp(blob1,min(blob_length, max_key_length),
5126 5127
			 (char*) key_ptr+HA_KEY_BLOB_LENGTH,
			 uint2korr(key_ptr));
unknown's avatar
unknown committed
5128 5129 5130 5131
}

int Field_blob::key_cmp(const byte *a,const byte *b)
{
5132 5133
  return Field_blob::cmp((char*) a+HA_KEY_BLOB_LENGTH, uint2korr(a),
			 (char*) b+HA_KEY_BLOB_LENGTH, uint2korr(b));
unknown's avatar
unknown committed
5134 5135 5136 5137 5138 5139 5140
}


void Field_blob::sort_string(char *to,uint length)
{
  char *blob;
  uint blob_length=get_length();
unknown's avatar
unknown committed
5141

unknown's avatar
unknown committed
5142 5143 5144 5145 5146
  if (!blob_length)
    bzero(to,length);
  else
  {
    memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
unknown's avatar
unknown committed
5147 5148
    
    blob_length=my_strnxfrm(field_charset,
5149 5150
                            (uchar*) to, length, 
                            (uchar*) blob, blob_length);
5151
    if (blob_length < length)
5152 5153 5154
      field_charset->cset->fill(field_charset, to+blob_length,
				length-blob_length,
				binary() ? (char) 0 : ' ');
unknown's avatar
unknown committed
5155 5156 5157 5158 5159 5160 5161
  }
}


void Field_blob::sql_type(String &res) const
{
  const char *str;
5162
  uint length;
unknown's avatar
unknown committed
5163
  switch (packlength) {
5164 5165 5166 5167 5168
  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;
  }
5169
  res.set_ascii(str,length);
5170
  if (charset() == &my_charset_bin)
5171 5172 5173 5174
    res.append("blob");
  else
  {
    res.append("text");
unknown's avatar
unknown committed
5175 5176 5177 5178
  }
}


5179 5180 5181 5182
char *Field_blob::pack(char *to, const char *from, uint max_length)
{
  char *save=ptr;
  ptr=(char*) from;
unknown's avatar
unknown committed
5183
  uint32 length=get_length();			// Length of from string
5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205
  if (length > max_length)
  {
    ptr=to;
    length=max_length;
    store_length(length);			// Store max length
    ptr=(char*) from;
  }
  else
    memcpy(to,from,packlength);			// Copy length
  if (length)
  {
    get_ptr((char**) &from);
    memcpy(to+packlength, from,length);
  }
  ptr=save;					// Restore org row pointer
  return to+packlength+length;
}


const char *Field_blob::unpack(char *to, const char *from)
{
  memcpy(to,from,packlength);
unknown's avatar
unknown committed
5206
  uint32 length=get_length(from);
5207 5208 5209 5210 5211 5212 5213 5214
  from+=packlength;
  if (length)
    memcpy_fixed(to+packlength, &from, sizeof(from));
  else
    bzero(to+packlength,sizeof(from));
  return from+length;
}

unknown's avatar
unknown committed
5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230
/* Keys for blobs are like keys on varchars */

int Field_blob::pack_cmp(const char *a, const char *b, uint key_length)
{
  uint a_length;
  uint b_length;
  if (key_length > 255)
  {
    a_length=uint2korr(a); a+=2;
    b_length=uint2korr(b); b+=2;
  }
  else
  {
    a_length= (uint) (uchar) *a++;
    b_length= (uint) (uchar) *b++;
  }
unknown's avatar
unknown committed
5231
  return my_strnncoll(field_charset,
5232 5233
		     (const uchar*) a, a_length,
		     (const uchar*) b, b_length);
unknown's avatar
unknown committed
5234 5235
}

5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253

int Field_blob::pack_cmp(const char *b, uint key_length)
{
  char *a;
  memcpy_fixed(&a,ptr+packlength,sizeof(char*));
  if (!a)
    return key_length > 0 ? -1 : 0;
  uint a_length=get_length(ptr);
  uint b_length;

  if (key_length > 255)
  {
    b_length=uint2korr(b); b+=2;
  }
  else
  {
    b_length= (uint) (uchar) *b++;
  }
unknown's avatar
unknown committed
5254
  return my_strnncoll(field_charset,
5255 5256
		     (const uchar*) a, a_length,
		     (const uchar*) b, b_length);
5257 5258
}

5259
/* Create a packed key that will be used for storage from a MySQL row */
5260

unknown's avatar
unknown committed
5261 5262
char *Field_blob::pack_key(char *to, const char *from, uint max_length)
{
5263 5264
  char *save=ptr;
  ptr=(char*) from;
unknown's avatar
unknown committed
5265
  uint32 length=get_length();			// Length of from string
5266 5267 5268 5269 5270 5271 5272
  uint char_length= (field_charset->mbmaxlen > 1) ?
              max_length/field_charset->mbmaxlen : max_length;
  if (length)
    get_ptr((char**) &from);
  if (length > char_length)
    char_length= my_charpos(field_charset, from, from+length, char_length);
  set_if_smaller(length, char_length);
5273 5274 5275
  *to++= (uchar) length;
  if (max_length > 255)				// 2 byte length
    *to++= (uchar) (length >> 8);
5276
  memcpy(to, from, length);
5277 5278 5279 5280
  ptr=save;					// Restore org row pointer
  return to+length;
}

5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324

/*
  Unpack a blob key into a record buffer.

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

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

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

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

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

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

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

5325 5326 5327 5328 5329 5330
/* Create a packed key that will be used for storage from a MySQL key */

char *Field_blob::pack_key_from_key_image(char *to, const char *from,
					  uint max_length)
{
  uint length=uint2korr(from);
unknown's avatar
unknown committed
5331 5332
  if (length > max_length)
    length=max_length;
unknown's avatar
unknown committed
5333
  *to++= (char) (length & 255);
unknown's avatar
unknown committed
5334
  if (max_length > 255)
unknown's avatar
unknown committed
5335
    *to++= (char) (length >> 8);
unknown's avatar
unknown committed
5336
  if (length)
5337
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
unknown's avatar
unknown committed
5338 5339 5340
  return to+length;
}

5341
uint Field_blob::packed_col_length(const char *data_ptr, uint length)
5342 5343
{
  if (length > 255)
5344
    return uint2korr(data_ptr)+2;
5345
  else
5346
    return (uint) ((uchar) *data_ptr)+1;
5347 5348 5349 5350 5351 5352
}

uint Field_blob::max_packed_col_length(uint max_length)
{
  return (max_length > 255 ? 2 : 1)+max_length;
}
5353

unknown's avatar
unknown committed
5354

unknown's avatar
unknown committed
5355
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
5356 5357 5358 5359 5360

void Field_geom::get_key_image(char *buff, uint length, CHARSET_INFO *cs,
			       imagetype type)
{
  char *blob;
unknown's avatar
unknown committed
5361
  const char *dummy;
unknown's avatar
unknown committed
5362
  MBR mbr;
5363 5364 5365
  ulong blob_length= get_length(ptr);
  Geometry_buffer buffer;
  Geometry *gobj;
unknown's avatar
unknown committed
5366 5367 5368 5369 5370 5371 5372

  if (blob_length < SRID_SIZE)
  {
    bzero(buff, SIZEOF_STORED_DOUBLE*4);
    return;
  }
  get_ptr(&blob);
5373 5374 5375
  gobj= Geometry::create_from_wkb(&buffer,
				  blob + SRID_SIZE, blob_length - SRID_SIZE);
  if (gobj->get_mbr(&mbr, &dummy))
unknown's avatar
unknown committed
5376 5377 5378 5379 5380 5381 5382 5383
    bzero(buff, SIZEOF_STORED_DOUBLE*4);
  else
  {
    float8store(buff, mbr.xmin);
    float8store(buff + 8, mbr.xmax);
    float8store(buff + 16, mbr.ymin);
    float8store(buff + 24, mbr.ymax);
  }
unknown's avatar
unknown committed
5384 5385 5386 5387 5388 5389 5390 5391 5392 5393
}


void Field_geom::set_key_image(char *buff, uint length, CHARSET_INFO *cs)
{
  Field_blob::set_key_image(buff, length, cs);
}

void Field_geom::sql_type(String &res) const
{
unknown's avatar
unknown committed
5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420
  CHARSET_INFO *cs= &my_charset_latin1;
  switch (geom_type)
  {
    case GEOM_POINT:
     res.set("point", 5, cs);
     break;
    case GEOM_LINESTRING:
     res.set("linestring", 10, cs);
     break;
    case GEOM_POLYGON:
     res.set("polygon", 7, cs);
     break;
    case GEOM_MULTIPOINT:
     res.set("multipoint", 10, cs);
     break;
    case GEOM_MULTILINESTRING:
     res.set("multilinestring", 15, cs);
     break;
    case GEOM_MULTIPOLYGON:
     res.set("multipolygon", 12, cs);
     break;
    case GEOM_GEOMETRYCOLLECTION:
     res.set("geometrycollection", 18, cs);
     break;
    default:
     res.set("geometry", 8, cs);
  }
unknown's avatar
unknown committed
5421 5422 5423 5424 5425 5426 5427 5428 5429
}


int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
{
  if (!length)
    bzero(ptr, Field_blob::pack_length());
  else
  {
unknown's avatar
unknown committed
5430 5431 5432 5433 5434
    // Check given WKB
    uint32 wkb_type;
    if (length < SRID_SIZE + WKB_HEADER_SIZE + SIZEOF_STORED_DOUBLE*2)
      goto err;
    wkb_type= uint4korr(from + WKB_HEADER_SIZE);
5435
    if (wkb_type < (uint32) Geometry::wkb_point ||
unknown's avatar
unknown committed
5436
	wkb_type > (uint32) Geometry::wkb_end)
unknown's avatar
unknown committed
5437
      return -1;
unknown's avatar
unknown committed
5438 5439 5440 5441 5442 5443 5444 5445 5446
    Field_blob::store_length(length);
    if (table->copy_blobs || length <= MAX_FIELD_WIDTH)
    {						// Must make a copy
      value.copy(from, length, cs);
      from= value.ptr();
    }
    bmove(ptr + packlength, (char*) &from, sizeof(char*));
  }
  return 0;
unknown's avatar
unknown committed
5447 5448 5449

err:
  bzero(ptr, Field_blob::pack_length());  
unknown's avatar
unknown committed
5450
  return -1;
unknown's avatar
unknown committed
5451 5452
}

unknown's avatar
unknown committed
5453
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
5454

unknown's avatar
unknown committed
5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514
/****************************************************************************
** 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
  if (table->db_low_byte_first)
  {
    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
  if (table->db_low_byte_first)
  {
    int4store(ptr,value);
  }
  else
#endif
    longstore(ptr,(long) value);
  break;
  case 8:
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,value);
  }
  else
#endif
    longlongstore(ptr,value); break;
  }
}


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

unknown's avatar
unknown committed
5515
int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5516
{
5517
  int err= 0;
unknown's avatar
unknown committed
5518
  uint32 not_used;
unknown's avatar
unknown committed
5519 5520
  char buff[80];
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
5521

unknown's avatar
unknown committed
5522
  /* Convert character set if nesessary */
unknown's avatar
unknown committed
5523
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
5524
  { 
5525 5526
    uint dummy_errors;
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
unknown's avatar
unknown committed
5527 5528 5529
    from= tmpstr.ptr();
    length=  tmpstr.length();
  }
5530 5531 5532 5533

  /* Remove end space */
  while (length > 0 && my_isspace(system_charset_info,from[length-1]))
    length--;
5534
  uint tmp=find_type2(typelib, from, length, field_charset);
unknown's avatar
unknown committed
5535
  if (!tmp)
unknown's avatar
unknown committed
5536
  {
5537
    if (length < 6) // Can't be more than 99999 enums
unknown's avatar
unknown committed
5538
    {
unknown's avatar
unknown committed
5539
      /* This is for reading numbers with LOAD DATA INFILE */
5540
      char *end;
5541 5542
      tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
      if (err || end != from+length || tmp > typelib->count)
unknown's avatar
unknown committed
5543 5544
      {
	tmp=0;
5545
	set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5546
      }
unknown's avatar
unknown committed
5547 5548
    }
    else
5549
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5550
  }
unknown's avatar
unknown committed
5551
  store_type((ulonglong) tmp);
5552
  return err;
unknown's avatar
unknown committed
5553 5554 5555
}


unknown's avatar
unknown committed
5556
int Field_enum::store(double nr)
unknown's avatar
unknown committed
5557
{
5558
  return Field_enum::store((longlong) nr);
unknown's avatar
unknown committed
5559 5560 5561
}


unknown's avatar
unknown committed
5562
int Field_enum::store(longlong nr)
unknown's avatar
unknown committed
5563
{
unknown's avatar
unknown committed
5564
  int error= 0;
unknown's avatar
unknown committed
5565 5566
  if ((uint) nr > typelib->count || nr == 0)
  {
5567
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5568
    nr=0;
5569
    error=1;
unknown's avatar
unknown committed
5570 5571
  }
  store_type((ulonglong) (uint) nr);
5572
  return error;
unknown's avatar
unknown committed
5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631
}


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


longlong Field_enum::val_int(void)
{
  switch (packlength) {
  case 1:
    return (longlong) (uchar) ptr[0];
  case 2:
    {
      uint16 tmp;
#ifdef WORDS_BIGENDIAN
      if (table->db_low_byte_first)
	tmp=sint2korr(ptr);
      else
#endif
	shortget(tmp,ptr);
      return (longlong) tmp;
    }
  case 3:
    return (longlong) uint3korr(ptr);
  case 4:
    {
      uint32 tmp;
#ifdef WORDS_BIGENDIAN
      if (table->db_low_byte_first)
	tmp=uint4korr(ptr);
      else
#endif
	longget(tmp,ptr);
      return (longlong) tmp;
    }
  case 8:
    {
      longlong tmp;
#ifdef WORDS_BIGENDIAN
      if (table->db_low_byte_first)
	tmp=sint8korr(ptr);
      else
#endif
	longlongget(tmp,ptr);
      return tmp;
    }
  }
  return 0;					// impossible
}


String *Field_enum::val_str(String *val_buffer __attribute__((unused)),
			    String *val_ptr)
{
  uint tmp=(uint) Field_enum::val_int();
  if (!tmp || tmp > typelib->count)
unknown's avatar
unknown committed
5632
    val_ptr->set("", 0, field_charset);
unknown's avatar
unknown committed
5633 5634
  else
    val_ptr->set((const char*) typelib->type_names[tmp-1],
5635
		 (uint) strlen(typelib->type_names[tmp-1]),
5636
		 field_charset);
unknown's avatar
unknown committed
5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664
  return val_ptr;
}

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

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


void Field_enum::sql_type(String &res) const
{
5665 5666 5667
  char buffer[255];
  String enum_item(buffer, sizeof(buffer), res.charset());

unknown's avatar
unknown committed
5668 5669 5670 5671
  res.length(0);
  res.append("enum(");

  bool flag=0;
5672
  for (const char **pos= typelib->type_names; *pos; pos++)
unknown's avatar
unknown committed
5673
  {
5674
    uint dummy_errors;
unknown's avatar
unknown committed
5675 5676
    if (flag)
      res.append(',');
5677
    /* convert to res.charset() == utf8, then quote */
5678
    enum_item.copy(*pos, strlen(*pos), charset(), res.charset(), &dummy_errors);
5679 5680
    append_unescaped(&res, enum_item.ptr(), enum_item.length());
    flag= 1;
unknown's avatar
unknown committed
5681 5682 5683 5684 5685
  }
  res.append(')');
}


5686 5687 5688 5689 5690 5691 5692 5693
/*
   set type.
   This is a string which can have a collection of different values.
   Each string value is separated with a ','.
   For example "One,two,five"
   If one uses this string in a number context one gets the bits as a longlong
   number.
*/
unknown's avatar
unknown committed
5694 5695


unknown's avatar
unknown committed
5696
int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5697
{
unknown's avatar
unknown committed
5698
  bool got_warning= 0;
5699
  int err= 0;
5700 5701
  char *not_used;
  uint not_used2;
unknown's avatar
unknown committed
5702
  uint32 not_used_offset;
unknown's avatar
unknown committed
5703 5704
  char buff[80];
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
5705

unknown's avatar
unknown committed
5706
  /* Convert character set if nesessary */
unknown's avatar
unknown committed
5707
  if (String::needs_conversion(length, cs, field_charset, &not_used_offset))
unknown's avatar
unknown committed
5708
  { 
5709 5710
    uint dummy_errors;
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
unknown's avatar
unknown committed
5711 5712 5713
    from= tmpstr.ptr();
    length=  tmpstr.length();
  }
5714 5715
  ulonglong tmp= find_set(typelib, from, length, field_charset,
                          &not_used, &not_used2, &got_warning);
unknown's avatar
unknown committed
5716 5717 5718
  if (!tmp && length && length < 22)
  {
    /* This is for reading numbers with LOAD DATA INFILE */
5719
    char *end;
5720 5721
    tmp=my_strntoull(cs,from,length,10,&end,&err);
    if (err || end != from+length ||
unknown's avatar
unknown committed
5722
	tmp > (ulonglong) (((longlong) 1 << typelib->count) - (longlong) 1))
5723
    {
5724
      tmp=0;      
5725
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
5726
    }
unknown's avatar
unknown committed
5727
  }
unknown's avatar
unknown committed
5728
  else if (got_warning)
5729
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5730
  store_type(tmp);
5731
  return err;
unknown's avatar
unknown committed
5732 5733 5734
}


unknown's avatar
unknown committed
5735
int Field_set::store(longlong nr)
unknown's avatar
unknown committed
5736
{
unknown's avatar
unknown committed
5737
  int error= 0;
unknown's avatar
unknown committed
5738 5739 5740
  if ((ulonglong) nr > (ulonglong) (((longlong) 1 << typelib->count) -
				    (longlong) 1))
  {
5741
    nr&= (longlong) (((longlong) 1 << typelib->count) - (longlong) 1);    
5742
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
5743
    error=1;
unknown's avatar
unknown committed
5744 5745
  }
  store_type((ulonglong) nr);
5746
  return error;
unknown's avatar
unknown committed
5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763
}


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);
  while (tmp && bitnr < (uint) typelib->count)
  {
    if (tmp & 1)
    {
      if (val_buffer->length())
	val_buffer->append(field_separator);
      String str(typelib->type_names[bitnr],
5764
		 (uint) strlen(typelib->type_names[bitnr]),
5765
		 field_charset);
unknown's avatar
unknown committed
5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776
      val_buffer->append(str);
    }
    tmp>>=1;
    bitnr++;
  }
  return val_buffer;
}


void Field_set::sql_type(String &res) const
{
5777 5778 5779
  char buffer[255];
  String set_item(buffer, sizeof(buffer), res.charset());

unknown's avatar
unknown committed
5780 5781 5782 5783
  res.length(0);
  res.append("set(");

  bool flag=0;
5784
  for (const char **pos= typelib->type_names; *pos; pos++)
unknown's avatar
unknown committed
5785
  {
5786
    uint dummy_errors;
unknown's avatar
unknown committed
5787 5788
    if (flag)
      res.append(',');
5789
    /* convert to res.charset() == utf8, then quote */
5790
    set_item.copy(*pos, strlen(*pos), charset(), res.charset(), &dummy_errors);
5791 5792
    append_unescaped(&res, set_item.ptr(), set_item.length());
    flag= 1;
unknown's avatar
unknown committed
5793 5794 5795 5796 5797 5798 5799 5800
  }
  res.append(')');
}

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

bool Field::eq_def(Field *field)
{
5801
  if (real_type() != field->real_type() || charset() != field->charset() ||
unknown's avatar
unknown committed
5802 5803 5804 5805 5806 5807 5808 5809 5810 5811
      pack_length() != field->pack_length())
    return 0;
  return 1;
}

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

unknown's avatar
unknown committed
5813 5814 5815
  if (typelib->count < from_lib->count)
    return 0;
  for (uint i=0 ; i < from_lib->count ; i++)
5816 5817 5818 5819 5820
    if (my_strnncoll(field_charset,
                     (const uchar*)typelib->type_names[i],
                     strlen(typelib->type_names[i]),
                     (const uchar*)from_lib->type_names[i],
                     strlen(from_lib->type_names[i])))
unknown's avatar
unknown committed
5821 5822 5823 5824 5825
      return 0;
  return 1;
}

bool Field_num::eq_def(Field *field)
unknown's avatar
unknown committed
5826
{
unknown's avatar
unknown committed
5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842
  if (!Field::eq_def(field))
    return 0;
  Field_num *from_num= (Field_num*) field;

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


/*****************************************************************************
** Handling of field and create_field
*****************************************************************************/

5843 5844
void create_field::create_length_to_internal_length(void)
{
unknown's avatar
unknown committed
5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866
  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:
    length*= charset->mbmaxlen;
    pack_length= calc_pack_length(sql_type == FIELD_TYPE_VAR_STRING ?
                                  FIELD_TYPE_STRING : sql_type, length);
    break;
#ifdef CORRECT_CODE_BUT_CANT_YET_BE_USED
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_SET:
    length*= charset->mbmaxlen;
    break;
#else
    /*
      Because of a bug in MySQL 4.1 where length was extended for ENUM and SET
      fields for every ALTER TABLE, we have to recalculate lengths here
    */
  case MYSQL_TYPE_ENUM:
5867
  {
unknown's avatar
unknown committed
5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885
    uint32 tot_length, max_length;
    calculate_interval_lengths(current_thd, interval,
                               &max_length, &tot_length);
    length= max_length * charset->mbmaxlen;
    break;
  }
  case MYSQL_TYPE_SET:
  {
    uint32 tot_length, max_length;
    calculate_interval_lengths(current_thd, interval,
                               &max_length, &tot_length);
    length= (tot_length + (interval->count - 1)) * charset->mbmaxlen;
    break;
  }
#endif
  default:
    /* do nothing */
    break;
5886 5887 5888
  }
}

unknown's avatar
unknown committed
5889
/*
unknown's avatar
unknown committed
5890
  Make a field from the .frm file info
unknown's avatar
unknown committed
5891 5892 5893 5894 5895 5896 5897
*/

uint32 calc_pack_length(enum_field_types type,uint32 length)
{
  switch (type) {
  case FIELD_TYPE_STRING:
  case FIELD_TYPE_DECIMAL: return (length);
5898
  case FIELD_TYPE_VAR_STRING: return (length+HA_KEY_BLOB_LENGTH);
unknown's avatar
unknown committed
5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913
  case FIELD_TYPE_YEAR:
  case FIELD_TYPE_TINY	: return 1;
  case FIELD_TYPE_SHORT : return 2;
  case FIELD_TYPE_INT24:
  case FIELD_TYPE_NEWDATE:
  case FIELD_TYPE_TIME:   return 3;
  case FIELD_TYPE_TIMESTAMP:
  case FIELD_TYPE_DATE:
  case FIELD_TYPE_LONG	: return 4;
  case FIELD_TYPE_FLOAT : return sizeof(float);
  case FIELD_TYPE_DOUBLE: return sizeof(double);
  case FIELD_TYPE_DATETIME:
  case FIELD_TYPE_LONGLONG: return 8;	/* Don't crash if no longlong */
  case FIELD_TYPE_NULL	: return 0;
  case FIELD_TYPE_TINY_BLOB:	return 1+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
5914
  case FIELD_TYPE_BLOB:		return 2+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
5915 5916
  case FIELD_TYPE_MEDIUM_BLOB:	return 3+portable_sizeof_char_ptr;
  case FIELD_TYPE_LONG_BLOB:	return 4+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
5917
  case FIELD_TYPE_GEOMETRY:	return 4+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
5918 5919
  case FIELD_TYPE_SET:
  case FIELD_TYPE_ENUM: abort(); return 0;	// This shouldn't happen
unknown's avatar
unknown committed
5920
  default: return 0;
unknown's avatar
unknown committed
5921
  }
unknown's avatar
unknown committed
5922
  return 0;					// Keep compiler happy
unknown's avatar
unknown committed
5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939
}


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


Field *make_field(char *ptr, uint32 field_length,
unknown's avatar
unknown committed
5940
		  uchar *null_pos, uchar null_bit,
unknown's avatar
unknown committed
5941
		  uint pack_flag,
5942
		  enum_field_types field_type,
5943
		  CHARSET_INFO *field_charset,
unknown's avatar
unknown committed
5944
		  Field::geometry_type geom_type,
unknown's avatar
unknown committed
5945 5946 5947 5948 5949 5950 5951 5952 5953 5954
		  Field::utype unireg_check,
		  TYPELIB *interval,
		  const char *field_name,
		  struct st_table *table)
{
  if (!f_maybe_null(pack_flag))
  {
    null_pos=0;
    null_bit=0;
  }
unknown's avatar
unknown committed
5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966

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

unknown's avatar
unknown committed
5967 5968 5969
  if (f_is_alpha(pack_flag))
  {
    if (!f_is_packed(pack_flag))
unknown's avatar
unknown committed
5970 5971
    {
      if (field_type == FIELD_TYPE_STRING ||
5972
          field_type == FIELD_TYPE_DECIMAL ||   // 3.23 or 4.0 string
unknown's avatar
unknown committed
5973 5974 5975 5976 5977 5978
          field_type == FIELD_TYPE_VAR_STRING)
        return new Field_string(ptr,field_length,null_pos,null_bit,
                                unireg_check, field_name, table,
                                field_charset);
      return 0;                                 // Error
    }
unknown's avatar
unknown committed
5979 5980 5981 5982 5983

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

unknown's avatar
unknown committed
5984
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
5985 5986
    if (f_is_geom(pack_flag))
      return new Field_geom(ptr,null_pos,null_bit,
unknown's avatar
unknown committed
5987
			    unireg_check, field_name, table,
unknown's avatar
unknown committed
5988
			    pack_length, geom_type);
unknown's avatar
unknown committed
5989
#endif
unknown's avatar
unknown committed
5990 5991 5992
    if (f_is_blob(pack_flag))
      return new Field_blob(ptr,null_pos,null_bit,
			    unireg_check, field_name, table,
unknown's avatar
unknown committed
5993
			    pack_length, field_charset);
unknown's avatar
unknown committed
5994 5995 5996 5997 5998
    if (interval)
    {
      if (f_is_enum(pack_flag))
	return new Field_enum(ptr,field_length,null_pos,null_bit,
				  unireg_check, field_name, table,
5999
				  pack_length, interval, field_charset);
unknown's avatar
unknown committed
6000 6001 6002
      else
	return new Field_set(ptr,field_length,null_pos,null_bit,
			     unireg_check, field_name, table,
6003
			     pack_length, interval, field_charset);
unknown's avatar
unknown committed
6004 6005 6006
    }
  }

6007
  switch (field_type) {
unknown's avatar
unknown committed
6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051
  case FIELD_TYPE_DECIMAL:
    return new Field_decimal(ptr,field_length,null_pos,null_bit,
			     unireg_check, field_name, table,
			     f_decimals(pack_flag),
			     f_is_zerofill(pack_flag) != 0,
			     f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_FLOAT:
    return new Field_float(ptr,field_length,null_pos,null_bit,
			   unireg_check, field_name, table,
			   f_decimals(pack_flag),
			   f_is_zerofill(pack_flag) != 0,
			   f_is_dec(pack_flag)== 0);
  case FIELD_TYPE_DOUBLE:
    return new Field_double(ptr,field_length,null_pos,null_bit,
			    unireg_check, field_name, table,
			    f_decimals(pack_flag),
			    f_is_zerofill(pack_flag) != 0,
			    f_is_dec(pack_flag)== 0);
  case FIELD_TYPE_TINY:
    return new Field_tiny(ptr,field_length,null_pos,null_bit,
			  unireg_check, field_name, table,
			  f_is_zerofill(pack_flag) != 0,
			  f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_SHORT:
    return new Field_short(ptr,field_length,null_pos,null_bit,
			   unireg_check, field_name, table,
			   f_is_zerofill(pack_flag) != 0,
			   f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_INT24:
    return new Field_medium(ptr,field_length,null_pos,null_bit,
			    unireg_check, field_name, table,
			    f_is_zerofill(pack_flag) != 0,
			    f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_LONG:
    return new Field_long(ptr,field_length,null_pos,null_bit,
			   unireg_check, field_name, table,
			   f_is_zerofill(pack_flag) != 0,
			   f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_LONGLONG:
    return new Field_longlong(ptr,field_length,null_pos,null_bit,
			      unireg_check, field_name, table,
			      f_is_zerofill(pack_flag) != 0,
			      f_is_dec(pack_flag) == 0);
  case FIELD_TYPE_TIMESTAMP:
6052 6053 6054
    return new Field_timestamp(ptr,field_length, null_pos, null_bit,
                               unireg_check, field_name, table,
                               field_charset);
unknown's avatar
unknown committed
6055 6056 6057 6058 6059
  case FIELD_TYPE_YEAR:
    return new Field_year(ptr,field_length,null_pos,null_bit,
			  unireg_check, field_name, table);
  case FIELD_TYPE_DATE:
    return new Field_date(ptr,null_pos,null_bit,
6060
			  unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
6061 6062
  case FIELD_TYPE_NEWDATE:
    return new Field_newdate(ptr,null_pos,null_bit,
6063
			     unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
6064 6065
  case FIELD_TYPE_TIME:
    return new Field_time(ptr,null_pos,null_bit,
6066
			  unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
6067 6068
  case FIELD_TYPE_DATETIME:
    return new Field_datetime(ptr,null_pos,null_bit,
6069
			      unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
6070
  case FIELD_TYPE_NULL:
6071
    return new Field_null(ptr,field_length,unireg_check,field_name,table, field_charset);
6072 6073
  default:					// Impossible (Wrong version)
    break;
unknown's avatar
unknown committed
6074
  }
unknown's avatar
unknown committed
6075
  return 0;
unknown's avatar
unknown committed
6076 6077 6078 6079 6080
}


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

6081
create_field::create_field(Field *old_field,Field *orig_field)
unknown's avatar
unknown committed
6082 6083 6084 6085 6086 6087 6088 6089
{
  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();
  sql_type=   old_field->real_type();
unknown's avatar
unknown committed
6090 6091
  charset=    old_field->charset();		// May be NULL ptr
  comment=    old_field->comment;
unknown's avatar
unknown committed
6092 6093 6094 6095 6096

  /* Fix if the original table had 4 byte pointer blobs */
  if (flags & BLOB_FLAG)
    pack_length= (pack_length- old_field->table->blob_ptr_size +
		  portable_sizeof_char_ptr);
6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107

  switch (sql_type)
  {
    case FIELD_TYPE_BLOB:
      switch (pack_length - portable_sizeof_char_ptr)
      {
        case  1: sql_type= FIELD_TYPE_TINY_BLOB; break;
        case  2: sql_type= FIELD_TYPE_BLOB; break;
        case  3: sql_type= FIELD_TYPE_MEDIUM_BLOB; break;
        default: sql_type= FIELD_TYPE_LONG_BLOB; break;
      }
6108
      length=(length+charset->mbmaxlen-1)/charset->mbmaxlen; // QQ: Probably not needed
6109
      break;
unknown's avatar
unknown committed
6110 6111
    case MYSQL_TYPE_ENUM:
    case MYSQL_TYPE_SET:
6112 6113
    case FIELD_TYPE_STRING:
    case FIELD_TYPE_VAR_STRING:
6114
      length=(length+charset->mbmaxlen-1)/charset->mbmaxlen;
6115 6116 6117 6118
      break;
    default:
      break;
  }
6119

unknown's avatar
unknown committed
6120 6121 6122
  decimals= old_field->decimals();
  if (sql_type == FIELD_TYPE_STRING)
  {
unknown's avatar
unknown committed
6123
    /* Change CHAR -> VARCHAR if dynamic record length */
unknown's avatar
unknown committed
6124 6125 6126 6127 6128 6129 6130
    sql_type=old_field->type();
    decimals=0;
  }
  if (flags & (ENUM_FLAG | SET_FLAG))
    interval= ((Field_enum*) old_field)->typelib;
  else
    interval=0;
6131
  def=0;
6132
  if (!old_field->is_real_null() && ! (flags & BLOB_FLAG) &&
6133
      old_field->ptr && orig_field)
unknown's avatar
unknown committed
6134 6135
  {
    char buff[MAX_FIELD_WIDTH],*pos;
6136
    String tmp(buff,sizeof(buff), charset);
6137

unknown's avatar
unknown committed
6138
    /* Get the value from default_values */
6139
    my_ptrdiff_t diff= (my_ptrdiff_t) (orig_field->table->rec_buff_length*2);
unknown's avatar
unknown committed
6140
    orig_field->move_field(diff);		// Points now at default_values
6141
    bool is_null=orig_field->is_real_null();
6142
    orig_field->val_str(&tmp);
6143
    orig_field->move_field(-diff);		// Back to record[0]
6144
    if (!is_null)
6145 6146 6147
    {
      pos= (char*) sql_memdup(tmp.ptr(),tmp.length()+1);
      pos[tmp.length()]=0;
6148
      def= new Item_string(pos, tmp.length(), charset);
6149
    }
unknown's avatar
unknown committed
6150
  }
unknown's avatar
unknown committed
6151
#ifdef HAVE_SPATIAL
6152 6153 6154 6155
  if (sql_type == FIELD_TYPE_GEOMETRY)
  {
    geom_type= ((Field_geom*)old_field)->geom_type;
  }
unknown's avatar
unknown committed
6156
#endif
unknown's avatar
unknown committed
6157
}
6158 6159 6160


/* Warning handling */
6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180

/*
  Produce warning or note about data saved into field

  SYNOPSYS
    set_warning()
      level            - level of message (Note/Warning/Error)
      code             - error code of message to be produced
      cuted_increment  - whenever we should increase cut fields count or not

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

  RETURN VALUE
    true  - if count_cuted_fields == FIELD_CHECK_IGNORE
    false - otherwise
*/
bool 
Field::set_warning(const uint level, const uint code, int cuted_increment)
6181
{
6182
  THD *thd= table->in_use;
unknown's avatar
unknown committed
6183 6184
  if (thd->count_cuted_fields)
  {
6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 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 6271 6272 6273 6274 6275 6276
    thd->cuted_fields+= cuted_increment;
    push_warning_printf(thd, (MYSQL_ERROR::enum_warning_level) level,
                        code, ER(code), field_name, thd->row_count);
    return 0;
  }
  return 1;
}


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

  SYNOPSYS
    set_warning()
      level            - level of message (Note/Warning/Error)
      code             - error code of message to be produced
      str              - string value which we tried to save
      str_len          - length of string which we tried to save
      ts_type          - type of datetime value (datetime/date/time)
      cuted_increment  - whenever we should increase cut fields count or not
  
  NOTE
    This function will always produce some warning but won't increase cut 
    fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current 
    thread.
*/
void 
Field::set_datetime_warning(const uint level, const uint code, 
                            const char *str, uint str_length, 
                            timestamp_type ts_type, int cuted_increment)
{
  if (set_warning(level, code, cuted_increment))
    make_truncated_value_warning(table->in_use, str, str_length, ts_type);
}


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

  SYNOPSYS
    set_warning()
      level            - level of message (Note/Warning/Error)
      code             - error code of message to be produced
      nr               - numeric value which we tried to save
      ts_type          - type of datetime value (datetime/date/time)
      cuted_increment  - whenever we should increase cut fields count or not
  
  NOTE
    This function will always produce some warning but won't increase cut 
    fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current 
    thread.
*/
void 
Field::set_datetime_warning(const uint level, const uint code, 
                            longlong nr, timestamp_type ts_type,
                            int cuted_increment)
{
  if (set_warning(level, code, cuted_increment))
  {
    char str_nr[22];
    char *str_end= longlong10_to_str(nr, str_nr, -10);
    make_truncated_value_warning(table->in_use, str_nr, str_end - str_nr, 
                                 ts_type);
  }
}


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

  SYNOPSYS
    set_warning()
      level            - level of message (Note/Warning/Error)
      code             - error code of message to be produced
      nr               - double value which we tried to save
      ts_type          - type of datetime value (datetime/date/time)
  
  NOTE
    This function will always produce some warning but won't increase cut 
    fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current 
    thread.
*/
void 
Field::set_datetime_warning(const uint level, const uint code, 
                            double nr, timestamp_type ts_type)
{
  if (set_warning(level, code, 1))
  {
    /* 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));
    make_truncated_value_warning(table->in_use, str_nr, str_len, ts_type);
unknown's avatar
unknown committed
6277
  }
6278
}
unknown's avatar
unknown committed
6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299

/*
  maximum possible display length for blob

  SYNOPSIS
    Field_blob::max_length()

  RETURN
    length
*/
uint32 Field_blob::max_length()
{
  switch (packlength)
  {
  case 1:
    return 255;
  case 2:
    return 65535;
  case 3:
    return 16777215;
  case 4:
6300
    return (uint32) 4294967295U;
unknown's avatar
unknown committed
6301 6302 6303 6304 6305
  default:
    DBUG_ASSERT(0); // we should never go here
    return 0;
  }
}