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

  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
unknown's avatar
unknown committed
86
    1	error.  A warning is pushed if field_name != 0
unknown's avatar
unknown committed
87 88
*/

unknown's avatar
unknown committed
89 90
bool Field::check_int(const char *str, int length, const char *int_end,
                      CHARSET_INFO *cs)
unknown's avatar
unknown committed
91
{
unknown's avatar
unknown committed
92
  const char *end;
93
  if (str == int_end)
unknown's avatar
unknown committed
94 95 96 97 98 99 100 101 102 103 104 105
  {
    char buff[128];
    String tmp(buff,(uint32) sizeof(buff), system_charset_info);
    tmp.copy(str, length, system_charset_info);
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, 
                        ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
                        "integer", tmp.c_ptr(), field_name,
                        (ulong) table->in_use->row_count);
    return 1;					// Empty string
  }
  end= str+length;
106
  if ((str= int_end) == end)
unknown's avatar
unknown committed
107
    return 0;					// ok; All digits was used
unknown's avatar
unknown committed
108

109 110
  /* Allow end .0000 */
  if (*str == '.')
unknown's avatar
unknown committed
111
  {
unknown's avatar
unknown committed
112 113
    for (str++ ; str != end && *str == '0'; str++)
      ;
114 115
  }
  /* Allow end space */
unknown's avatar
unknown committed
116
  for ( ; str != end ; str++)
117 118
  {
    if (!my_isspace(cs,*str))
unknown's avatar
unknown committed
119 120 121 122
    {
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
      return 1;
    }
unknown's avatar
unknown committed
123
  }
unknown's avatar
unknown committed
124
  return 0;
unknown's avatar
unknown committed
125 126
}

unknown's avatar
unknown committed
127

unknown's avatar
unknown committed
128
#ifdef NOT_USED
129
static bool test_if_real(const char *str,int length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
130
{
131
  cs= system_charset_info; // QQ move test_if_real into CHARSET_INFO struct
132 133

  while (length && my_isspace(cs,*str))
unknown's avatar
unknown committed
134 135 136 137 138 139 140 141
  {						// Allow start space
    length--; str++;
  }
  if (!length)
    return 0;
  if (*str == '+' || *str == '-')
  {
    length--; str++;
142
    if (!length || !(my_isdigit(cs,*str) || *str == '.'))
unknown's avatar
unknown committed
143 144
      return 0;
  }
145
  while (length && my_isdigit(cs,*str))
unknown's avatar
unknown committed
146 147 148 149 150 151 152 153
  {
    length--; str++;
  }
  if (!length)
    return 1;
  if (*str == '.')
  {
    length--; str++;
154
    while (length && my_isdigit(cs,*str))
unknown's avatar
unknown committed
155 156 157 158 159 160 161 162
    {
      length--; str++;
    }
  }
  if (!length)
    return 1;
  if (*str == 'E' || *str == 'e')
  {
163
    if (length < 3 || (str[1] != '+' && str[1] != '-') || 
164
        !my_isdigit(cs,str[2]))
unknown's avatar
unknown committed
165 166 167
      return 0;
    length-=3;
    str+=3;
168
    while (length && my_isdigit(cs,*str))
unknown's avatar
unknown committed
169 170 171 172
    {
      length--; str++;
    }
  }
173
  for (; length ; length--, str++)
unknown's avatar
unknown committed
174
  {						// Allow end space
175
    if (!my_isspace(cs,*str))
unknown's avatar
unknown committed
176 177 178 179
      return 0;
  }
  return 1;
}
unknown's avatar
unknown committed
180
#endif
unknown's avatar
unknown committed
181

182

unknown's avatar
unknown committed
183 184 185 186 187 188 189 190
/*
 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[]=
191 192
{Field::FIELD_CAST_DECIMAL,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
unknown's avatar
unknown committed
193 194
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_tiny[]=
195 196
{Field::FIELD_CAST_TINY,
 Field::FIELD_CAST_SHORT, Field::FIELD_CAST_MEDIUM, Field::FIELD_CAST_LONG,
unknown's avatar
unknown committed
197 198 199 200 201
 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[]=
202 203
{Field::FIELD_CAST_SHORT,
 Field::FIELD_CAST_MEDIUM, Field::FIELD_CAST_LONG, Field::FIELD_CAST_LONGLONG,
unknown's avatar
unknown committed
204 205 206 207
 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[]=
208 209
{Field::FIELD_CAST_MEDIUM,
 Field::FIELD_CAST_LONG, Field::FIELD_CAST_LONGLONG,
unknown's avatar
unknown committed
210 211 212 213
 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[]=
214 215
{Field::FIELD_CAST_LONG,
 Field::FIELD_CAST_LONGLONG,
unknown's avatar
unknown committed
216 217 218 219
 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[]=
220 221
{Field::FIELD_CAST_LONGLONG,
 Field::FIELD_CAST_DOUBLE,
unknown's avatar
unknown committed
222 223 224
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_float[]=
225 226
{Field::FIELD_CAST_FLOAT,
 Field::FIELD_CAST_DOUBLE,
unknown's avatar
unknown committed
227 228 229
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_double[]=
230 231
{Field::FIELD_CAST_DOUBLE,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
unknown's avatar
unknown committed
232 233
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_null[]=
234 235
{Field::FIELD_CAST_NULL,
 Field::FIELD_CAST_DECIMAL, Field::FIELD_CAST_TINY, Field::FIELD_CAST_SHORT,
unknown's avatar
unknown committed
236 237 238 239 240 241 242 243 244 245
 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[]=
246 247
{Field::FIELD_CAST_TIMESTAMP,
 Field::FIELD_CAST_DATETIME,
unknown's avatar
unknown committed
248 249 250
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_year[]=
251 252
{Field::FIELD_CAST_YEAR,
 Field::FIELD_CAST_SHORT, Field::FIELD_CAST_MEDIUM, Field::FIELD_CAST_LONG,
unknown's avatar
unknown committed
253 254 255 256 257
 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[]=
258 259
{Field::FIELD_CAST_DATE,
 Field::FIELD_CAST_DATETIME,
unknown's avatar
unknown committed
260 261 262
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_newdate[]=
263 264
{Field::FIELD_CAST_NEWDATE,
 Field::FIELD_CAST_DATETIME,
unknown's avatar
unknown committed
265 266 267
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_time[]=
268 269
{Field::FIELD_CAST_TIME,
 Field::FIELD_CAST_DATETIME,
unknown's avatar
unknown committed
270 271 272
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_datetime[]=
273 274
{Field::FIELD_CAST_DATETIME,
 Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
unknown's avatar
unknown committed
275 276
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_string[]=
277 278
{Field::FIELD_CAST_STRING,
 Field::FIELD_CAST_VARSTRING, Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
unknown's avatar
unknown committed
279
static Field::field_cast_enum field_cast_varstring[]=
280 281
{Field::FIELD_CAST_VARSTRING,
 Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
unknown's avatar
unknown committed
282
static Field::field_cast_enum field_cast_blob[]=
283 284 285 286 287
{Field::FIELD_CAST_BLOB,
 Field::FIELD_CAST_STOP};
/*
  Geometrical, enum and set fields can be casted only to expressions
*/
unknown's avatar
unknown committed
288 289 290
static Field::field_cast_enum field_cast_geom[]=
{Field::FIELD_CAST_STOP};
static Field::field_cast_enum field_cast_enum[]=
291
{Field::FIELD_CAST_STOP};
unknown's avatar
unknown committed
292
static Field::field_cast_enum field_cast_set[]=
293
{Field::FIELD_CAST_STOP};
unknown's avatar
unknown committed
294 295 296 297 298 299 300 301 302 303 304 305 306 307
// 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
308 309 310 311 312 313 314 315 316 317 318
/*
  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
319 320 321 322
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()];
323
  while (*array != FIELD_CAST_STOP)
unknown's avatar
unknown committed
324
  {
325
    if (*(array++) == type)
unknown's avatar
unknown committed
326
      return 1;
327
  }
unknown's avatar
unknown committed
328 329 330 331
  return 0;
}


unknown's avatar
unknown committed
332 333
/****************************************************************************
** Functions for the base classes
unknown's avatar
unknown committed
334
** This is an unpacked number.
unknown's avatar
unknown committed
335 336 337
****************************************************************************/

Field::Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
unknown's avatar
unknown committed
338
	     uchar null_bit_arg,
unknown's avatar
unknown committed
339 340
	     utype unireg_check_arg, const char *field_name_arg,
	     struct st_table *table_arg)
unknown's avatar
unknown committed
341
  :ptr(ptr_arg),null_ptr(null_ptr_arg),
342 343
   table(table_arg),orig_table(table_arg),
   table_name(table_arg ? table_arg->table_name : 0),
unknown's avatar
unknown committed
344
   field_name(field_name_arg),
unknown's avatar
unknown committed
345 346
   query_id(0), key_start(0), part_of_key(0), part_of_sortkey(0),
   unireg_check(unireg_check_arg),
unknown's avatar
unknown committed
347
   field_length(length_arg),null_bit(null_bit_arg)
unknown's avatar
unknown committed
348 349
{
  flags=null_ptr ? 0: NOT_NULL_FLAG;
unknown's avatar
unknown committed
350 351
  comment.str= (char*) "";
  comment.length=0;
unknown's avatar
unknown committed
352 353 354 355 356 357 358 359 360 361 362 363 364
}

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
365 366
    *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) |
			null_ptr[row_offset] & (uchar) null_bit);
unknown's avatar
unknown committed
367 368 369 370
  }
}


371
bool Field::send_binary(Protocol *protocol)
unknown's avatar
unknown committed
372 373
{
  char buff[MAX_FIELD_WIDTH];
374
  String tmp(buff,sizeof(buff),charset());
375
  val_str(&tmp);
376
  return protocol->store(tmp.ptr(), tmp.length(), tmp.charset());
unknown's avatar
unknown committed
377 378 379 380 381
}


void Field_num::add_zerofill_and_unsigned(String &res) const
{
382 383 384 385
  if (unsigned_flag)
    res.append(" unsigned");
  if (zerofill)
    res.append(" zerofill");
unknown's avatar
unknown committed
386 387 388 389
}

void Field_num::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 403 404 405
  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
406
  /* table_cache_key is not set for temp tables */
407 408 409 410
  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
411
  field->col_name=field->org_col_name=field_name;
412
  field->charsetnr= charset()->number;
unknown's avatar
unknown committed
413 414 415 416 417 418
  field->length=field_length;
  field->type=type();
  field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
  field->decimals=0;
}

419

unknown's avatar
unknown committed
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
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;
}

440 441

bool Field::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
442 443
{
  char buff[40];
444 445
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  if (!(res=val_str(&tmp)) ||
446 447
      str_to_datetime_with_warn(res->ptr(), res->length(),
                                ltime, fuzzydate) <= MYSQL_TIMESTAMP_ERROR)
unknown's avatar
unknown committed
448 449 450 451 452 453 454
    return 1;
  return 0;
}

bool Field::get_time(TIME *ltime)
{
  char buff[40];
455 456
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  if (!(res=val_str(&tmp)) ||
457
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
unknown's avatar
unknown committed
458 459 460 461
    return 1;
  return 0;
}

462 463 464 465 466 467
/*
  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
468 469 470

void Field::store_time(TIME *ltime,timestamp_type type)
{
471 472 473
  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
474 475 476
}


477
bool Field::optimize_range(uint idx, uint part)
unknown's avatar
unknown committed
478
{
479
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
unknown's avatar
unknown committed
480 481
}

482
/****************************************************************************
483
  Field_null, a field that always return NULL
484 485 486 487
****************************************************************************/

void Field_null::sql_type(String &res) const
{
488
  res.set_ascii("null", 4);
489 490 491
}


unknown's avatar
unknown committed
492
/****************************************************************************
unknown's avatar
unknown committed
493 494
  Functions for the Field_decimal class
  This is an number stored as a pre-space (or pre-zero) string
unknown's avatar
unknown committed
495 496 497 498 499
****************************************************************************/

void
Field_decimal::reset(void)
{
unknown's avatar
unknown committed
500
  Field_decimal::store("0",1,&my_charset_bin);
unknown's avatar
unknown committed
501 502 503 504 505
}

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

508
  set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
509
  if (negative)
unknown's avatar
unknown committed
510
  {
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
    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
534
  }
535
  bfill(to, len, filler);
unknown's avatar
unknown committed
536 537 538 539 540 541
  if (dec)
    ptr[field_length-dec-1]='.';
  return;
}


unknown's avatar
unknown committed
542
int Field_decimal::store(const char *from, uint len, CHARSET_INFO *cs)
unknown's avatar
unknown committed
543
{
544
  char buff[80];
unknown's avatar
unknown committed
545
  String tmp(buff,sizeof(buff), &my_charset_bin);
546

547 548 549
  /* Convert character set if the old one is multi byte */
  if (cs->mbmaxlen > 1)
  { 
550 551
    uint dummy_errors;
    tmp.copy(from, len, cs, &my_charset_bin, &dummy_errors);
552 553 554
    from= tmp.ptr();
    len=  tmp.length();
  }
555

556 557 558 559 560 561 562 563 564
  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
565
  /* The pointers where prezeros start and stop */
566
  const char *pre_zeros_from, *pre_zeros_end;
unknown's avatar
unknown committed
567
  /* The pointers where digits at the left of '.' start and stop */
568
  const char *int_digits_from, *int_digits_end;
unknown's avatar
unknown committed
569
  /* The pointers where digits at the right of '.' start and stop */
570
  const char *frac_digits_from, *frac_digits_end;
unknown's avatar
unknown committed
571
  /* The sign of the exponent : will be 0 (means no exponent), '+' or '-' */
572
  char expo_sign_char=0;
unknown's avatar
unknown committed
573
  uint exponent=0;                                // value of the exponent
574 575 576 577 578 579 580
  /*
    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
581 582 583 584
  /*
    Pointer used when digits move from the right of the '.' to the left
    of the '.'
  */
585
  const char *frac_digits_head_end;
unknown's avatar
unknown committed
586
  /* Number of 0 that need to be added at the right of the '.' (for 1E-3) */
587 588 589 590 591
  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
592
  /*
593
    To remember if table->in_use->cuted_fields has already been incremented,
unknown's avatar
unknown committed
594 595
    to do that only once
  */
596 597 598 599 600 601 602 603 604
  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
605 606
    - parse the input string
    - modify the position of digits around the decimal dot '.' 
607
      according to the exponent value (if specified)
unknown's avatar
unknown committed
608
    - write the formatted number
609 610 611 612 613
  */

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

unknown's avatar
unknown committed
614
  /* skip pre-space */
unknown's avatar
unknown committed
615
  while (from != end && my_isspace(&my_charset_bin,*from))
unknown's avatar
unknown committed
616
    from++;
617
  if (from == end)
unknown's avatar
unknown committed
618
  {
619
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
620
    is_cuted_fields_incr=1;
unknown's avatar
unknown committed
621
  }
622
  else if (*from == '+' || *from == '-')	// Found some sign ?
unknown's avatar
unknown committed
623
  {
624
    sign_char= *from++;
unknown's avatar
unknown committed
625
    /*
626 627 628
      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
629 630 631 632
    */ 
    if (unsigned_flag)  
    { 
      if (sign_char=='-')
633
      {
634
        Field_decimal::overflow(1);
unknown's avatar
unknown committed
635
        return 1;
636
      }
637
      /* 
unknown's avatar
unknown committed
638 639
	 Defining this will not store "+" for unsigned decimal type even if
	 it is passed in numeric string. This will make some tests to fail
640 641
      */	 
#ifdef DONT_ALLOW_UNSIGNED_PLUS      
642 643
      else 
        sign_char=0;
644
#endif 	
unknown's avatar
unknown committed
645
    }
646
  }
unknown's avatar
unknown committed
647

648 649 650 651
  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
652
  for (; from != end && my_isdigit(&my_charset_bin, *from) ; from++) ;
653 654 655 656 657
  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
658
  for (;from!=end && my_isdigit(&my_charset_bin, *from); from++) ;
659 660 661 662 663 664 665 666 667 668
  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= '+';
    /*
669 670 671 672
      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).
673
    */
unknown's avatar
unknown committed
674
    for (;from!=end && my_isdigit(&my_charset_bin, *from); from++)
675
    {
676
      exponent=10*exponent+(*from-'0');
unknown's avatar
unknown committed
677
      if (exponent>MAX_EXPONENT)
678 679
        break;
    }
unknown's avatar
unknown committed
680
  }
681
  
unknown's avatar
unknown committed
682
  /*
683 684 685 686
    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
687
  */
688

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

728 729 730 731 732 733 734 735
  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
736
    tmp_uint=tmp_dec+(uint)(int_digits_end-int_digits_from);     
737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
  }
  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
762
    }
763 764 765
    tmp_uint= (tmp_dec+(int_digits_end-int_digits_from)+
               (uint)(frac_digits_from-int_digits_tail_from)+
               int_digits_added_zeros);
766 767 768 769 770 771 772 773 774 775
  }
  
  /*
    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
  */

776
  if (field_length < tmp_uint + (int) (sign_char == '-')) 
777
  {
unknown's avatar
unknown committed
778
    // too big number, change to max or min number
779
    Field_decimal::overflow(sign_char == '-');
780
    return 1;
unknown's avatar
unknown committed
781
  }
782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
 
  /*
    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
799
  }
800 801 802 803 804 805
  /*
    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
806 807

  /*
808 809
    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
810
  */
811 812 813 814
  pos=tmp_left_pos-1;
  if (zerofill)
  {
    left_wall=to-1;
815
    while (pos > left_wall)			// Fill with zeros
816 817 818 819
      *pos--='0';
  }
  else
  {
unknown's avatar
unknown committed
820
    left_wall=to+(sign_char != 0)-1;
821 822
    if (!expo_sign_char)	// If exponent was specified, ignore prezeros
    {
823
      for (;pos > left_wall && pre_zeros_from !=pre_zeros_end;
824 825 826 827 828 829 830 831 832 833 834 835 836 837 838
	   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
  }
  
839 840
  /*
    Write digits of the frac_% parts ;
841
    Depending on table->in_use->count_cutted_fields, we may also want
842 843 844 845 846
    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)
  */
847
      
848 849 850
  pos=to+(uint)(field_length-tmp_dec);	// Calculate post to '.'
  right_wall=to+field_length;
  if (pos != right_wall) 
851 852
    *pos++='.';

853 854 855
  if (expo_sign_char == '-')
  {
    while (frac_digits_added_zeros-- > 0)
unknown's avatar
unknown committed
856
    {
857
      if (pos == right_wall) 
858
      {
859
        if (table->in_use->count_cuted_fields && !is_cuted_fields_incr) 
860
          break; // Go on below to see if we lose non zero digits
unknown's avatar
unknown committed
861
        return 0;
862
      }
863 864 865 866 867 868
      *pos++='0';
    }
    while (int_digits_end != frac_digits_head_end)
    {
      tmp_char= *int_digits_end++;
      if (pos == right_wall)
unknown's avatar
unknown committed
869
      {
870 871 872
        if (tmp_char != '0')			// Losing a non zero digit ?
        {
          if (!is_cuted_fields_incr)
873 874
            set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                        ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
875
          return 0;
876 877
        }
        continue;
unknown's avatar
unknown committed
878
      }
879
      *pos++= tmp_char;
unknown's avatar
unknown committed
880
    }
881
  }
882

883 884 885 886
  for (;frac_digits_from!=frac_digits_end;) 
  {
    tmp_char= *frac_digits_from++;
    if (pos == right_wall)
887
    {
888
      if (tmp_char != '0')			// Losing a non zero digit ?
889
      {
890
        if (!is_cuted_fields_incr)
unknown's avatar
unknown committed
891 892 893 894 895 896 897
        {
          /*
            This is a note, not a warning, as we don't want to abort
            when we cut decimals in strict mode
          */
	  set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, ER_WARN_DATA_TRUNCATED, 1);
        }
unknown's avatar
unknown committed
898
        return 0;
899
      }
900
      continue;
901
    }
902
    *pos++= tmp_char;
unknown's avatar
unknown committed
903
  }
904 905 906
      
  while (pos != right_wall)
   *pos++='0';			// Fill with zeros at right of '.'
unknown's avatar
unknown committed
907
  return 0;
unknown's avatar
unknown committed
908 909 910
}


unknown's avatar
unknown committed
911
int Field_decimal::store(double nr)
unknown's avatar
unknown committed
912 913 914 915
{
  if (unsigned_flag && nr < 0)
  {
    overflow(1);
916
    return 1;
unknown's avatar
unknown committed
917
  }
918
  
919 920
#ifdef HAVE_FINITE
  if (!finite(nr)) // Handle infinity as special case
921 922
  {
    overflow(nr < 0.0);
unknown's avatar
unknown committed
923
    return 1;
924
  }
925
#endif
unknown's avatar
unknown committed
926

unknown's avatar
unknown committed
927 928
  reg4 uint i,length;
  char fyllchar,*to;
929
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
unknown's avatar
unknown committed
930 931

  fyllchar = zerofill ? (char) '0' : (char) ' ';
unknown's avatar
unknown committed
932
#ifdef HAVE_SNPRINTF
unknown's avatar
unknown committed
933 934
  buff[sizeof(buff)-1]=0;			// Safety
  snprintf(buff,sizeof(buff)-1, "%.*f",(int) dec,nr);
935
  length=(uint) strlen(buff);
unknown's avatar
unknown committed
936
#else
937
  length=(uint) my_sprintf(buff,(buff,"%.*f",dec,nr));
unknown's avatar
unknown committed
938
#endif
unknown's avatar
unknown committed
939 940 941 942

  if (length > field_length)
  {
    overflow(nr < 0.0);
943
    return 1;
unknown's avatar
unknown committed
944 945 946 947 948 949 950
  }
  else
  {
    to=ptr;
    for (i=field_length-length ; i-- > 0 ;)
      *to++ = fyllchar;
    memcpy(to,buff,length);
951
    return 0;
unknown's avatar
unknown committed
952 953 954 955
  }
}


unknown's avatar
unknown committed
956
int Field_decimal::store(longlong nr)
unknown's avatar
unknown committed
957 958 959 960
{
  if (unsigned_flag && nr < 0)
  {
    overflow(1);
961
    return 1;
unknown's avatar
unknown committed
962 963 964 965 966 967 968 969
  }
  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 */
970
    return 1;
unknown's avatar
unknown committed
971 972 973 974 975 976 977 978 979 980 981 982 983
  }
  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');
    }
984
    return 0;
unknown's avatar
unknown committed
985 986 987 988 989 990
  }
}


double Field_decimal::val_real(void)
{
991
  int not_used;
unknown's avatar
unknown committed
992
  return my_strntod(&my_charset_bin, ptr, field_length, NULL, &not_used);
unknown's avatar
unknown committed
993 994 995 996
}

longlong Field_decimal::val_int(void)
{
997
  int not_used;
unknown's avatar
unknown committed
998
  if (unsigned_flag)
unknown's avatar
unknown committed
999
    return my_strntoull(&my_charset_bin, ptr, field_length, 10, NULL,
1000
			&not_used);
unknown's avatar
unknown committed
1001
  else
unknown's avatar
unknown committed
1002
    return my_strntoll(&my_charset_bin, ptr, field_length, 10, NULL,
1003
			&not_used);
unknown's avatar
unknown committed
1004 1005
}

1006

unknown's avatar
unknown committed
1007 1008 1009 1010 1011 1012
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
1013
  val_ptr->set_charset(&my_charset_bin);
unknown's avatar
unknown committed
1014 1015 1016
  if (field_length < tmp_length)		// Error in data
    val_ptr->length(0);
  else
1017
    val_ptr->set_ascii((const char*) str, field_length-tmp_length);
unknown's avatar
unknown committed
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
  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;
1029
  int swap=0;
unknown's avatar
unknown committed
1030 1031 1032 1033
  /* First remove prefixes '0', ' ', and '-' */
  for (end=a_ptr+field_length;
       a_ptr != end &&
	 (*a_ptr == *b_ptr ||
unknown's avatar
unknown committed
1034
	  ((my_isspace(&my_charset_bin,*a_ptr)  || *a_ptr == '+' || 
1035
            *a_ptr == '0') &&
unknown's avatar
unknown committed
1036
	   (my_isspace(&my_charset_bin,*b_ptr) || *b_ptr == '+' || 
1037
            *b_ptr == '0')));
1038 1039 1040 1041 1042
       a_ptr++,b_ptr++)
  {
    if (*a_ptr == '-')				// If both numbers are negative
      swap= -1 ^ 1;				// Swap result      
  }
unknown's avatar
unknown committed
1043 1044 1045
  if (a_ptr == end)
    return 0;
  if (*a_ptr == '-')
1046
    return -1;
1047
  if (*b_ptr == '-')
unknown's avatar
unknown committed
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
    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
1064
	 ((my_isspace(&my_charset_bin,*str) || *str == '+' ||
unknown's avatar
unknown committed
1065
	   *str == '0')) ;
unknown's avatar
unknown committed
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
       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
1076
      if (my_isdigit(&my_charset_bin,*str))
unknown's avatar
unknown committed
1077 1078 1079 1080 1081 1082 1083
	*to++= (char) ('9' - *str++);
      else
	*to++= *str++;
  }
  else memcpy(to,str,(uint) (end-str));
}

unknown's avatar
unknown committed
1084

unknown's avatar
unknown committed
1085 1086
void Field_decimal::sql_type(String &res) const
{
unknown's avatar
unknown committed
1087
  CHARSET_INFO *cs=res.charset();
unknown's avatar
unknown committed
1088 1089 1090 1091 1092
  uint tmp=field_length;
  if (!unsigned_flag)
    tmp--;
  if (dec)
    tmp--;
1093
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
1094
			  "decimal(%d,%d)",tmp,dec));
unknown's avatar
unknown committed
1095 1096 1097 1098 1099 1100 1101 1102
  add_zerofill_and_unsigned(res);
}


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

unknown's avatar
unknown committed
1103
int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
1104
{
1105
  int not_used;				// We can ignore result from str2int
1106
  char *end;
1107
  long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
unknown's avatar
unknown committed
1108
  int error= 0;
unknown's avatar
unknown committed
1109 1110 1111 1112 1113 1114

  if (unsigned_flag)
  {
    if (tmp < 0)
    {
      tmp=0; /* purecov: inspected */
1115
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1116
      error= 1;
unknown's avatar
unknown committed
1117 1118 1119 1120
    }
    else if (tmp > 255)
    {
      tmp= 255;
1121
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1122
      error= 1;
unknown's avatar
unknown committed
1123
    }
unknown's avatar
unknown committed
1124
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
1125
      error= 1;
unknown's avatar
unknown committed
1126 1127 1128 1129 1130 1131
  }
  else
  {
    if (tmp < -128)
    {
      tmp= -128;
1132
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1133
      error= 1;
unknown's avatar
unknown committed
1134 1135 1136 1137
    }
    else if (tmp >= 128)
    {
      tmp= 127;
1138
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1139
      error= 1;
unknown's avatar
unknown committed
1140
    }
unknown's avatar
unknown committed
1141
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
1142
      error= 1;
unknown's avatar
unknown committed
1143 1144
  }
  ptr[0]= (char) tmp;
1145
  return error;
unknown's avatar
unknown committed
1146 1147 1148
}


unknown's avatar
unknown committed
1149
int Field_tiny::store(double nr)
unknown's avatar
unknown committed
1150
{
unknown's avatar
unknown committed
1151
  int error= 0;
unknown's avatar
unknown committed
1152 1153 1154 1155 1156 1157
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0.0)
    {
      *ptr=0;
1158
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1159
      error= 1;
unknown's avatar
unknown committed
1160 1161 1162 1163
    }
    else if (nr > 255.0)
    {
      *ptr=(char) 255;
1164
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1165
      error= 1;
unknown's avatar
unknown committed
1166 1167 1168 1169 1170 1171 1172 1173 1174
    }
    else
      *ptr=(char) nr;
  }
  else
  {
    if (nr < -128.0)
    {
      *ptr= (char) -128;
1175
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1176
      error= 1;
unknown's avatar
unknown committed
1177 1178 1179 1180
    }
    else if (nr > 127.0)
    {
      *ptr=127;
1181
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1182
      error= 1;
unknown's avatar
unknown committed
1183 1184 1185 1186
    }
    else
      *ptr=(char) nr;
  }
1187
  return error;
unknown's avatar
unknown committed
1188 1189
}

unknown's avatar
unknown committed
1190
int Field_tiny::store(longlong nr)
unknown's avatar
unknown committed
1191
{
unknown's avatar
unknown committed
1192
  int error= 0;
unknown's avatar
unknown committed
1193 1194 1195 1196 1197
  if (unsigned_flag)
  {
    if (nr < 0L)
    {
      *ptr=0;
1198
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1199
      error= 1;
unknown's avatar
unknown committed
1200 1201 1202 1203
    }
    else if (nr > 255L)
    {
      *ptr= (char) 255;
1204
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1205
      error= 1;
unknown's avatar
unknown committed
1206 1207 1208 1209 1210 1211 1212 1213 1214
    }
    else
      *ptr=(char) nr;
  }
  else
  {
    if (nr < -128L)
    {
      *ptr= (char) -128;
1215
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1216
      error= 1;
unknown's avatar
unknown committed
1217 1218 1219 1220
    }
    else if (nr > 127L)
    {
      *ptr=127;
1221
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1222
      error= 1;
unknown's avatar
unknown committed
1223 1224 1225 1226
    }
    else
      *ptr=(char) nr;
  }
1227
  return error;
unknown's avatar
unknown committed
1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247
}


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
1248
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
1249
  uint length;
1250 1251
  uint mlength=max(field_length+1,5*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
1252
  char *to=(char*) val_buffer->ptr();
1253

unknown's avatar
unknown committed
1254
  if (unsigned_flag)
1255 1256
    length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
					   (long) *((uchar*) ptr));
unknown's avatar
unknown committed
1257
  else
1258 1259
    length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
					   (long) *((signed char*) ptr));
1260
  
unknown's avatar
unknown committed
1261 1262 1263 1264 1265 1266
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}

1267 1268 1269 1270
bool Field_tiny::send_binary(Protocol *protocol)
{
  return protocol->store_tiny((longlong) (int8) ptr[0]);
}
unknown's avatar
unknown committed
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290

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
1291
  CHARSET_INFO *cs=res.charset();
1292
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
1293
			  "tinyint(%d)",(int) field_length));
unknown's avatar
unknown committed
1294 1295 1296 1297
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
1298
 Field type short int (2 byte)
unknown's avatar
unknown committed
1299 1300
****************************************************************************/

unknown's avatar
unknown committed
1301
int Field_short::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
1302
{
1303
  int not_used;				// We can ignore result from str2int
1304
  char *end;
1305
  long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
unknown's avatar
unknown committed
1306
  int error= 0;
1307

unknown's avatar
unknown committed
1308 1309 1310 1311 1312
  if (unsigned_flag)
  {
    if (tmp < 0)
    {
      tmp=0;
1313
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1314
      error= 1;
unknown's avatar
unknown committed
1315 1316 1317 1318
    }
    else if (tmp > (uint16) ~0)
    {
      tmp=(uint16) ~0;
1319
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1320
      error= 1;
unknown's avatar
unknown committed
1321
    }
unknown's avatar
unknown committed
1322
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
1323
      error= 1;
unknown's avatar
unknown committed
1324 1325 1326 1327 1328 1329
  }
  else
  {
    if (tmp < INT_MIN16)
    {
      tmp= INT_MIN16;
1330
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1331
      error= 1;
unknown's avatar
unknown committed
1332 1333 1334 1335
    }
    else if (tmp > INT_MAX16)
    {
      tmp=INT_MAX16;
1336
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1337
      error= 1;
unknown's avatar
unknown committed
1338
    }
unknown's avatar
unknown committed
1339
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
1340
      error= 1;
unknown's avatar
unknown committed
1341 1342 1343 1344 1345 1346 1347 1348 1349
  }
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int2store(ptr,tmp);
  }
  else
#endif
    shortstore(ptr,(short) tmp);
1350
  return error;
unknown's avatar
unknown committed
1351 1352 1353
}


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

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


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

1478

unknown's avatar
unknown committed
1479 1480 1481
String *Field_short::val_str(String *val_buffer,
			     String *val_ptr __attribute__((unused)))
{
unknown's avatar
unknown committed
1482
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
1483
  uint length;
1484 1485
  uint mlength=max(field_length+1,7*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
  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)
1496 1497
    length=(uint) cs->cset->long10_to_str(cs, to, mlength, 10, 
					  (long) (uint16) j);
unknown's avatar
unknown committed
1498
  else
1499
    length=(uint) cs->cset->long10_to_str(cs, to, mlength,-10, (long) j);
unknown's avatar
unknown committed
1500 1501 1502 1503 1504 1505 1506
  val_buffer->length(length);
  if (zerofill)
    prepend_zeros(val_buffer);
  return val_buffer;
}


1507 1508 1509 1510 1511 1512
bool Field_short::send_binary(Protocol *protocol)
{
  return protocol->store_short(Field_short::val_int());
}


unknown's avatar
unknown committed
1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
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
1543
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
1544 1545 1546 1547 1548 1549 1550 1551
    to[1]   = ptr[1];
  }
  else
#endif
  {
    if (unsigned_flag)
      to[0] = ptr[1];
    else
unknown's avatar
unknown committed
1552
      to[0] = (char) (ptr[1] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
1553 1554 1555 1556 1557 1558
    to[1]   = ptr[0];
  }
}

void Field_short::sql_type(String &res) const
{
unknown's avatar
unknown committed
1559
  CHARSET_INFO *cs=res.charset();
1560
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
1561
			  "smallint(%d)",(int) field_length));
unknown's avatar
unknown committed
1562 1563 1564 1565 1566
  add_zerofill_and_unsigned(res);
}


/****************************************************************************
1567
  Field type medium int (3 byte)
unknown's avatar
unknown committed
1568 1569
****************************************************************************/

unknown's avatar
unknown committed
1570
int Field_medium::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
1571
{
1572
  int not_used;				// We can ignore result from str2int
1573
  char *end;
1574
  long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
unknown's avatar
unknown committed
1575
  int error= 0;
unknown's avatar
unknown committed
1576 1577 1578 1579 1580 1581

  if (unsigned_flag)
  {
    if (tmp < 0)
    {
      tmp=0;
1582
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1583
      error= 1;
unknown's avatar
unknown committed
1584 1585 1586 1587
    }
    else if (tmp >= (long) (1L << 24))
    {
      tmp=(long) (1L << 24)-1L;
1588
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1589
      error= 1;
unknown's avatar
unknown committed
1590
    }
unknown's avatar
unknown committed
1591
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
1592
      error= 1;
unknown's avatar
unknown committed
1593 1594 1595 1596 1597 1598
  }
  else
  {
    if (tmp < INT_MIN24)
    {
      tmp= INT_MIN24;
1599
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1600
      error= 1;
unknown's avatar
unknown committed
1601 1602 1603 1604
    }
    else if (tmp > INT_MAX24)
    {
      tmp=INT_MAX24;
1605
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
1606
      error= 1;
unknown's avatar
unknown committed
1607
    }
unknown's avatar
unknown committed
1608
    else if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
unknown's avatar
unknown committed
1609
      error= 1;
unknown's avatar
unknown committed
1610 1611 1612
  }

  int3store(ptr,tmp);
1613
  return error;
unknown's avatar
unknown committed
1614 1615 1616
}


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

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


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

1711

unknown's avatar
unknown committed
1712 1713 1714 1715 1716 1717
longlong Field_medium::val_int(void)
{
  long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
  return (longlong) j;
}

1718

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

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


1737 1738 1739 1740 1741 1742
bool Field_medium::send_binary(Protocol *protocol)
{
  return protocol->store_long(Field_medium::val_int());
}


unknown's avatar
unknown committed
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 1768 1769 1770 1771
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
1772
  CHARSET_INFO *cs=res.charset();
1773
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(), 
1774
			  "mediumint(%d)",(int) field_length));
unknown's avatar
unknown committed
1775 1776 1777 1778 1779 1780 1781 1782
  add_zerofill_and_unsigned(res);
}

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


unknown's avatar
unknown committed
1783
int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
1784
{
unknown's avatar
unknown committed
1785 1786 1787 1788
  longlong tmp;
  long store_tmp;
  int error;
  bool warning_given= 0;
1789
  char *end;
unknown's avatar
unknown committed
1790
  
1791
  tmp= cs->cset->scan(cs, from, from+len, MY_SEQ_SPACES);
unknown's avatar
unknown committed
1792 1793
  len-= tmp;
  from+= tmp;
unknown's avatar
unknown committed
1794

unknown's avatar
unknown committed
1795 1796 1797 1798
  end= (char*) from+len;
  tmp= my_strtoll10(from, &end, &error);

  if (error != MY_ERRNO_EDOM)
unknown's avatar
unknown committed
1799
  {
unknown's avatar
unknown committed
1800
    if (unsigned_flag)
unknown's avatar
unknown committed
1801
    {
unknown's avatar
unknown committed
1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813
      if (error < 0)
      {
        error= 1;
        tmp= 0;
      }
      else if ((ulonglong) tmp > (ulonglong) UINT_MAX32)
      {
        tmp= UINT_MAX32;
        error= 1;
      }
      else
        error= 0;
unknown's avatar
unknown committed
1814 1815
    }
    else
1816
    {
unknown's avatar
unknown committed
1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830
      if (error < 0)
      {
        error= 0;
        if (tmp < INT_MIN32)
        {
          tmp= INT_MIN32;
          error= 1;
        }
      }
      else if (tmp > INT_MAX32)
      {
        tmp= INT_MAX32;
        error= 1;
      }
1831 1832
    }
  }
unknown's avatar
unknown committed
1833
  if (error)
unknown's avatar
unknown committed
1834
  {
1835
    error= 1;
unknown's avatar
unknown committed
1836
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1837
  }
unknown's avatar
unknown committed
1838 1839 1840 1841 1842
  else if (from+len != end && table->in_use->count_cuted_fields &&
           check_int(from,len,end,cs))
    error= 1;
    
  store_tmp= (long) tmp;
unknown's avatar
unknown committed
1843 1844 1845
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
unknown's avatar
unknown committed
1846
    int4store(ptr, store_tmp);
unknown's avatar
unknown committed
1847 1848 1849
  }
  else
#endif
unknown's avatar
unknown committed
1850
    longstore(ptr, store_tmp);
1851
  return error;
unknown's avatar
unknown committed
1852 1853 1854
}


unknown's avatar
unknown committed
1855
int Field_long::store(double nr)
unknown's avatar
unknown committed
1856
{
unknown's avatar
unknown committed
1857
  int error= 0;
unknown's avatar
unknown committed
1858 1859 1860 1861 1862 1863 1864
  int32 res;
  nr=rint(nr);
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
unknown's avatar
unknown committed
1865
      error= 1;
unknown's avatar
unknown committed
1866 1867 1868 1869
    }
    else if (nr > (double) (ulong) ~0L)
    {
      res=(int32) (uint32) ~0L;
unknown's avatar
unknown committed
1870
      error= 1;
unknown's avatar
unknown committed
1871 1872 1873 1874 1875 1876 1877 1878 1879
    }
    else
      res=(int32) (ulong) nr;
  }
  else
  {
    if (nr < (double) INT_MIN32)
    {
      res=(int32) INT_MIN32;
unknown's avatar
unknown committed
1880
      error= 1;
unknown's avatar
unknown committed
1881 1882 1883 1884
    }
    else if (nr > (double) INT_MAX32)
    {
      res=(int32) INT_MAX32;
unknown's avatar
unknown committed
1885
      error= 1;
unknown's avatar
unknown committed
1886 1887 1888 1889
    }
    else
      res=(int32) nr;
  }
unknown's avatar
unknown committed
1890 1891 1892
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);

unknown's avatar
unknown committed
1893 1894 1895 1896 1897 1898 1899 1900
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,res);
  }
  else
#endif
    longstore(ptr,res);
1901
  return error;
unknown's avatar
unknown committed
1902 1903 1904
}


unknown's avatar
unknown committed
1905
int Field_long::store(longlong nr)
unknown's avatar
unknown committed
1906
{
unknown's avatar
unknown committed
1907
  int error= 0;
unknown's avatar
unknown committed
1908
  int32 res;
unknown's avatar
unknown committed
1909
  DBUG_ASSERT(table->in_use == current_thd);    // General safety
1910
  
unknown's avatar
unknown committed
1911 1912 1913 1914 1915
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
unknown's avatar
unknown committed
1916
      error= 1;
unknown's avatar
unknown committed
1917 1918 1919 1920
    }
    else if (nr >= (LL(1) << 32))
    {
      res=(int32) (uint32) ~0L;
unknown's avatar
unknown committed
1921
      error= 1;
unknown's avatar
unknown committed
1922 1923 1924 1925 1926 1927 1928 1929 1930
    }
    else
      res=(int32) (uint32) nr;
  }
  else
  {
    if (nr < (longlong) INT_MIN32)
    {
      res=(int32) INT_MIN32;
unknown's avatar
unknown committed
1931
      error= 1;
unknown's avatar
unknown committed
1932 1933 1934 1935
    }
    else if (nr > (longlong) INT_MAX32)
    {
      res=(int32) INT_MAX32;
unknown's avatar
unknown committed
1936
      error= 1;
unknown's avatar
unknown committed
1937 1938 1939 1940
    }
    else
      res=(int32) nr;
  }
unknown's avatar
unknown committed
1941 1942 1943
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);

unknown's avatar
unknown committed
1944 1945 1946 1947 1948 1949 1950 1951
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,res);
  }
  else
#endif
    longstore(ptr,res);
1952
  return error;
unknown's avatar
unknown committed
1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970
}


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;
1971 1972
  /* See the comment in Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
unknown's avatar
unknown committed
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
#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
1985
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
1986
  uint length;
1987 1988
  uint mlength=max(field_length+1,12*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
1989 1990 1991 1992 1993 1994 1995 1996 1997
  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);

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


2009 2010 2011 2012 2013
bool Field_long::send_binary(Protocol *protocol)
{
  return protocol->store_long(Field_long::val_int());
}

unknown's avatar
unknown committed
2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029
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
2030
    return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
unknown's avatar
unknown committed
2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
  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
2042
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052
    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
2053
      to[0] = (char) (ptr[3] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
2054 2055 2056 2057 2058 2059 2060 2061 2062
    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
2063
  CHARSET_INFO *cs=res.charset();
2064
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2065
			  "int(%d)",(int) field_length));
unknown's avatar
unknown committed
2066 2067 2068 2069
  add_zerofill_and_unsigned(res);
}

/****************************************************************************
2070
 Field type longlong int (8 bytes)
unknown's avatar
unknown committed
2071 2072
****************************************************************************/

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


unknown's avatar
unknown committed
2115
int Field_longlong::store(double nr)
unknown's avatar
unknown committed
2116
{
unknown's avatar
unknown committed
2117
  int error= 0;
unknown's avatar
unknown committed
2118
  longlong res;
unknown's avatar
unknown committed
2119 2120

  nr= rint(nr);
unknown's avatar
unknown committed
2121 2122 2123 2124 2125
  if (unsigned_flag)
  {
    if (nr < 0)
    {
      res=0;
unknown's avatar
unknown committed
2126
      error= 1;
unknown's avatar
unknown committed
2127 2128 2129 2130
    }
    else if (nr >= (double) ~ (ulonglong) 0)
    {
      res= ~(longlong) 0;
unknown's avatar
unknown committed
2131
      error= 1;
unknown's avatar
unknown committed
2132 2133 2134 2135 2136 2137
    }
    else
      res=(longlong) (ulonglong) nr;
  }
  else
  {
unknown's avatar
unknown committed
2138
    if (nr < (double) LONGLONG_MIN)
unknown's avatar
unknown committed
2139
    {
unknown's avatar
unknown committed
2140
      res= LONGLONG_MIN;
unknown's avatar
unknown committed
2141
      error= 1;
unknown's avatar
unknown committed
2142
    }
unknown's avatar
unknown committed
2143
    else if (nr > (double) LONGLONG_MAX)
unknown's avatar
unknown committed
2144
    {
unknown's avatar
unknown committed
2145
      res= LONGLONG_MAX;
unknown's avatar
unknown committed
2146
      error= 1;
unknown's avatar
unknown committed
2147 2148 2149 2150
    }
    else
      res=(longlong) nr;
  }
unknown's avatar
unknown committed
2151 2152 2153
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);

unknown's avatar
unknown committed
2154 2155 2156 2157 2158 2159 2160 2161
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,res);
  }
  else
#endif
    longlongstore(ptr,res);
2162
  return error;
unknown's avatar
unknown committed
2163 2164 2165
}


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


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);
2191 2192 2193 2194 2195 2196 2197
  /* 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
2198 2199
}

2200

unknown's avatar
unknown committed
2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216
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
2217
  CHARSET_INFO *cs= &my_charset_bin;
unknown's avatar
unknown committed
2218
  uint length;
2219 2220
  uint mlength=max(field_length+1,22*cs->mbmaxlen);
  val_buffer->alloc(mlength);
unknown's avatar
unknown committed
2221 2222 2223 2224 2225 2226 2227 2228 2229
  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);

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


2239 2240 2241 2242 2243 2244
bool Field_longlong::send_binary(Protocol *protocol)
{
  return protocol->store_longlong(Field_longlong::val_int(), unsigned_flag);
}


unknown's avatar
unknown committed
2245 2246 2247 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
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
2274
      to[0] = (char) (ptr[0] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288
    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
2289
      to[0] = (char) (ptr[7] ^ 128);		/* Revers signbit */
unknown's avatar
unknown committed
2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302
    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
2303
  CHARSET_INFO *cs=res.charset();
2304
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
2305
			  "bigint(%d)",(int) field_length));
unknown's avatar
unknown committed
2306 2307 2308
  add_zerofill_and_unsigned(res);
}

unknown's avatar
unknown committed
2309

unknown's avatar
unknown committed
2310
/****************************************************************************
unknown's avatar
unknown committed
2311
  single precision float
unknown's avatar
unknown committed
2312 2313
****************************************************************************/

unknown's avatar
unknown committed
2314
int Field_float::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
2315
{
unknown's avatar
unknown committed
2316
  int error;
2317
  char *end;
unknown's avatar
unknown committed
2318
  double nr= my_strntod(cs,(char*) from,len,&end,&error);
unknown's avatar
unknown committed
2319 2320
  if (error || (!len || (uint) (end-from) != len &&
                table->in_use->count_cuted_fields))
2321
  {
unknown's avatar
unknown committed
2322 2323 2324
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                (error ? ER_WARN_DATA_OUT_OF_RANGE : ER_WARN_DATA_TRUNCATED),
                1);
unknown's avatar
unknown committed
2325
    error= 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);
unknown's avatar
unknown committed
2624 2625
  if (error || (!len || (uint) (end-from) != len &&
                table->in_use->count_cuted_fields))
unknown's avatar
unknown committed
2626
  {
unknown's avatar
unknown committed
2627 2628 2629
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                (error ? ER_WARN_DATA_OUT_OF_RANGE : ER_WARN_DATA_TRUNCATED),
                1);
unknown's avatar
unknown committed
2630
    error= 1;
unknown's avatar
unknown committed
2631
  }
unknown's avatar
unknown committed
2632 2633
  Field_double::store(nr);
  return error;
unknown's avatar
unknown committed
2634 2635 2636
}


unknown's avatar
unknown committed
2637
int Field_double::store(double nr)
unknown's avatar
unknown committed
2638
{
unknown's avatar
unknown committed
2639
  int error= 0;
2640

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

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


unknown's avatar
unknown committed
2694
int Field_double::store(longlong nr)
unknown's avatar
unknown committed
2695 2696
{
  double j= (double) nr;
unknown's avatar
unknown committed
2697
  int error= 0;
unknown's avatar
unknown committed
2698 2699
  if (unsigned_flag && j < 0)
  {
2700
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
unknown's avatar
unknown committed
2701
    error= 1;
unknown's avatar
unknown committed
2702 2703
    j=0;
  }
unknown's avatar
unknown committed
2704 2705 2706 2707 2708 2709 2710 2711
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    float8store(ptr,j);
  }
  else
#endif
    doublestore(ptr,j);
2712
  return error;
unknown's avatar
unknown committed
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 2755 2756 2757
}


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

2758
  uint to_length=max(field_length, DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE);
unknown's avatar
unknown committed
2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769
  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
2770
    char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
2771
    char *pos= buff;
unknown's avatar
unknown committed
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 2807 2808 2809
    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
2810
    to[to_length-1]=0;			// Safety
unknown's avatar
unknown committed
2811
    snprintf(to,to_length-1,"%.*f",dec,nr);
2812
    to=strend(to);
unknown's avatar
unknown committed
2813
#else
2814
    to+= my_sprintf(to,(to,"%.*f",dec,nr));
unknown's avatar
unknown committed
2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827
#endif
#endif
  }
#ifdef HAVE_FCONVERT
 end:
#endif

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

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

unknown's avatar
unknown committed
2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845

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
2846 2847
    doubleget(a, a_ptr);
    doubleget(b, b_ptr);
unknown's avatar
unknown committed
2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866
  }
  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
2867
    doubleget(nr,ptr);
unknown's avatar
unknown committed
2868 2869 2870 2871 2872 2873
  change_double_for_sort(nr, (byte*) to);
}


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


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 2929 2930 2931
/*
  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
2932 2933

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


2954
/*
2955 2956
  Get auto-set type for TIMESTAMP field.

2957
  SYNOPSIS
2958 2959 2960 2961 2962
    get_auto_set_type()

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


unknown's avatar
unknown committed
2993
int Field_timestamp::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
2994
{
2995 2996 2997 2998 2999 3000 3001
  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;

unknown's avatar
unknown committed
3002 3003 3004 3005 3006
  have_smth_to_conv= (str_to_datetime(from, len, &l_time,
                                      ((table->in_use->variables.sql_mode &
                                        MODE_NO_ZERO_DATE) |
                                       MODE_NO_ZERO_IN_DATE),
                                      &error) >
3007
                      MYSQL_TIMESTAMP_ERROR);
3008
  
unknown's avatar
unknown committed
3009 3010 3011
  if (error || !have_smth_to_conv)
  {
    error= 1;
3012
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
3013
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
unknown's avatar
unknown committed
3014
  }
3015

unknown's avatar
unknown committed
3016 3017
  /* Only convert a correct date (not a zero date) */
  if (have_smth_to_conv && l_time.month)
3018 3019 3020 3021 3022
  {
    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,
3023
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
3024 3025 3026 3027 3028 3029 3030
      
      error= 1;
    }
    else if (in_dst_time_gap)
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                           ER_WARN_INVALID_TIMESTAMP, 
3031
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
3032 3033 3034 3035
      error= 1;
    }
  }

unknown's avatar
unknown committed
3036 3037 3038 3039 3040 3041 3042 3043
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
3044
  return error;
unknown's avatar
unknown committed
3045 3046
}

unknown's avatar
unknown committed
3047

unknown's avatar
unknown committed
3048
int Field_timestamp::store(double nr)
unknown's avatar
unknown committed
3049
{
unknown's avatar
unknown committed
3050
  int error= 0;
unknown's avatar
unknown committed
3051 3052
  if (nr < 0 || nr > 99991231235959.0)
  {
3053 3054
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE, 
3055
                         nr, MYSQL_TIMESTAMP_DATETIME);
unknown's avatar
unknown committed
3056 3057
    nr= 0;					// Avoid overflow on buff
    error= 1;
unknown's avatar
unknown committed
3058
  }
unknown's avatar
unknown committed
3059
  error|= Field_timestamp::store((longlong) rint(nr));
3060
  return error;
unknown's avatar
unknown committed
3061 3062 3063
}


unknown's avatar
unknown committed
3064
int Field_timestamp::store(longlong nr)
unknown's avatar
unknown committed
3065 3066
{
  TIME l_time;
3067 3068 3069 3070
  my_time_t timestamp= 0;
  int error;
  bool in_dst_time_gap;
  THD *thd= table->in_use;
unknown's avatar
unknown committed
3071

3072
  if (number_to_TIME(nr, &l_time, 0, &error))
unknown's avatar
unknown committed
3073
  {
3074 3075 3076 3077
    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,
3078
                          nr, MYSQL_TIMESTAMP_DATETIME, 1);
3079 3080
      error= 1;
    }
3081
  
3082 3083 3084 3085
    if (in_dst_time_gap)
    {
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
                           ER_WARN_INVALID_TIMESTAMP, 
3086
                           nr, MYSQL_TIMESTAMP_DATETIME, !error);
3087 3088 3089 3090 3091 3092
      error= 1;
    }
  }
  else if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_TRUNCATED,
3093
                         nr, MYSQL_TIMESTAMP_DATETIME, 1);
3094

unknown's avatar
unknown committed
3095 3096 3097 3098 3099 3100 3101
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,timestamp);
  }
  else
#endif
unknown's avatar
unknown committed
3102
    longstore(ptr,(uint32) timestamp);
3103
    
unknown's avatar
unknown committed
3104
  return error;
unknown's avatar
unknown committed
3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115
}


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

longlong Field_timestamp::val_int(void)
{
  uint32 temp;
3116 3117
  TIME time_tmp;
  THD  *thd= table->in_use;
unknown's avatar
unknown committed
3118 3119 3120 3121 3122 3123 3124 3125 3126 3127

#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 */
3128 3129 3130 3131 3132 3133 3134
  
  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
3135 3136 3137
}


unknown's avatar
unknown committed
3138
String *Field_timestamp::val_str(String *val_buffer, String *val_ptr)
unknown's avatar
unknown committed
3139
{
3140
  uint32 temp, temp2;
3141 3142
  TIME time_tmp;
  THD *thd= table->in_use;
unknown's avatar
unknown committed
3143
  char *to;
unknown's avatar
unknown committed
3144 3145

  val_buffer->alloc(field_length+1);
unknown's avatar
unknown committed
3146
  to= (char*) val_buffer->ptr();
3147
  val_buffer->length(field_length);
unknown's avatar
unknown committed
3148 3149 3150 3151 3152 3153 3154 3155 3156 3157

#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
3158
    val_ptr->set("0000-00-00 00:00:00", 19, &my_charset_bin);
3159
    return val_ptr;
unknown's avatar
unknown committed
3160
  }
unknown's avatar
unknown committed
3161
  val_buffer->set_charset(&my_charset_bin);	// Safety
3162 3163 3164
  
  thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp,(my_time_t)temp);
  thd->time_zone_used= 1;
3165

3166
  temp= time_tmp.year % 100;
3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180
  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++= '-';
3181
  temp=time_tmp.month;
3182 3183 3184 3185
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= '-';
3186
  temp=time_tmp.day;
3187 3188 3189 3190
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ' ';
3191
  temp=time_tmp.hour;
3192 3193 3194 3195
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ':';
3196
  temp=time_tmp.minute;
3197 3198 3199 3200
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to++= ':';
3201
  temp=time_tmp.second;
3202 3203 3204 3205
  temp2=temp/10; temp=temp-temp2*10;
  *to++= (char) ('0'+(char) (temp2));
  *to++= (char) ('0'+(char) (temp));
  *to= 0;
unknown's avatar
unknown committed
3206 3207 3208
  return val_buffer;
}

3209

3210
bool Field_timestamp::get_date(TIME *ltime, uint fuzzydate)
unknown's avatar
unknown committed
3211 3212
{
  long temp;
3213
  THD *thd= table->in_use;
unknown's avatar
unknown committed
3214 3215 3216 3217 3218 3219 3220 3221
#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
3222
    if (fuzzydate & TIME_NO_ZERO_DATE)
unknown's avatar
unknown committed
3223
      return 1;
unknown's avatar
unknown committed
3224 3225 3226 3227
    bzero((char*) ltime,sizeof(*ltime));
  }
  else
  {
3228 3229
    thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)temp);
    thd->time_zone_used= 1;
unknown's avatar
unknown committed
3230 3231 3232 3233 3234 3235
  }
  return 0;
}

bool Field_timestamp::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
3236
  return Field_timestamp::get_date(ltime,0);
unknown's avatar
unknown committed
3237 3238
}

3239 3240 3241 3242

bool Field_timestamp::send_binary(Protocol *protocol)
{
  TIME tm;
unknown's avatar
unknown committed
3243
  Field_timestamp::get_date(&tm, 0);
3244 3245 3246 3247
  return protocol->store(&tm);
}


unknown's avatar
unknown committed
3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265
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;
}

3266

unknown's avatar
unknown committed
3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289
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
{
3290
  res.set_ascii("timestamp", 9);
unknown's avatar
unknown committed
3291 3292 3293 3294 3295
}


void Field_timestamp::set_time()
{
3296
  long tmp= (long) table->in_use->query_start();
3297
  set_notnull();
unknown's avatar
unknown committed
3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314
#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
3315
int Field_time::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3316 3317 3318
{
  TIME ltime;
  long tmp;
3319 3320 3321
  int error;

  if (str_to_time(from, len, &ltime, &error))
3322
  {
unknown's avatar
unknown committed
3323
    tmp=0L;
unknown's avatar
unknown committed
3324
    error= 1;
3325
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
3326
                         from, len, MYSQL_TIMESTAMP_TIME, 1);
3327
  }
unknown's avatar
unknown committed
3328 3329
  else
  {
3330 3331 3332
    if (error)
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                           ER_WARN_DATA_TRUNCATED,
3333
                           from, len, MYSQL_TIMESTAMP_TIME, 1);
3334

unknown's avatar
unknown committed
3335 3336 3337 3338 3339 3340
    if (ltime.month)
      ltime.day=0;
    tmp=(ltime.day*24L+ltime.hour)*10000L+(ltime.minute*100+ltime.second);
    if (tmp > 8385959)
    {
      tmp=8385959;
3341 3342
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                           ER_WARN_DATA_OUT_OF_RANGE,
3343
                           from, len, MYSQL_TIMESTAMP_TIME, !error);
unknown's avatar
unknown committed
3344
      error= 1;
unknown's avatar
unknown committed
3345 3346
    }
  }
3347
  
unknown's avatar
unknown committed
3348 3349
  if (ltime.neg)
    tmp= -tmp;
3350 3351
  error |= Field_time::store((longlong) tmp);
  return error;
unknown's avatar
unknown committed
3352 3353 3354
}


unknown's avatar
unknown committed
3355
int Field_time::store(double nr)
unknown's avatar
unknown committed
3356 3357
{
  long tmp;
unknown's avatar
unknown committed
3358
  int error= 0;
unknown's avatar
unknown committed
3359 3360 3361
  if (nr > 8385959.0)
  {
    tmp=8385959L;
3362
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3363
                         ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
3364
    error= 1;
unknown's avatar
unknown committed
3365 3366 3367 3368
  }
  else if (nr < -8385959.0)
  {
    tmp= -8385959L;
3369
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3370
                         ER_WARN_DATA_OUT_OF_RANGE, nr, MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
3371
    error= 1;
unknown's avatar
unknown committed
3372 3373 3374 3375 3376 3377 3378 3379 3380
  }
  else
  {
    tmp=(long) floor(fabs(nr));			// Remove fractions
    if (nr < 0)
      tmp= -tmp;
    if (tmp % 100 > 59 || tmp/100 % 100 > 59)
    {
      tmp=0;
3381
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3382 3383
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
3384
      error= 1;
unknown's avatar
unknown committed
3385 3386 3387
    }
  }
  int3store(ptr,tmp);
3388
  return error;
unknown's avatar
unknown committed
3389 3390 3391
}


unknown's avatar
unknown committed
3392
int Field_time::store(longlong nr)
unknown's avatar
unknown committed
3393 3394
{
  long tmp;
unknown's avatar
unknown committed
3395
  int error= 0;
unknown's avatar
unknown committed
3396 3397 3398
  if (nr > (longlong) 8385959L)
  {
    tmp=8385959L;
3399
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3400 3401
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
3402
    error= 1;
unknown's avatar
unknown committed
3403 3404 3405 3406
  }
  else if (nr < (longlong) -8385959L)
  {
    tmp= -8385959L;
3407
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3408 3409
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
3410
    error= 1;
unknown's avatar
unknown committed
3411 3412 3413 3414 3415 3416 3417
  }
  else
  {
    tmp=(long) nr;
    if (tmp % 100 > 59 || tmp/100 % 100 > 59)
    {
      tmp=0;
3418
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3419 3420
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_TIME, 1);
unknown's avatar
unknown committed
3421
      error= 1;
unknown's avatar
unknown committed
3422 3423 3424
    }
  }
  int3store(ptr,tmp);
3425
  return error;
unknown's avatar
unknown committed
3426 3427 3428 3429 3430
}


double Field_time::val_real(void)
{
unknown's avatar
unknown committed
3431
  uint32 j= (uint32) uint3korr(ptr);
unknown's avatar
unknown committed
3432 3433 3434 3435 3436 3437 3438 3439
  return (double) j;
}

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

3440 3441 3442 3443 3444 3445

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

unknown's avatar
unknown committed
3446 3447 3448
String *Field_time::val_str(String *val_buffer,
			    String *val_ptr __attribute__((unused)))
{
3449
  TIME ltime;
3450
  val_buffer->alloc(19);
unknown's avatar
unknown committed
3451
  long tmp=(long) sint3korr(ptr);
3452
  ltime.neg= 0;
unknown's avatar
unknown committed
3453 3454 3455
  if (tmp < 0)
  {
    tmp= -tmp;
3456 3457 3458 3459 3460 3461
    ltime.neg= 1;
  }
  ltime.day= (uint) 0;
  ltime.hour= (uint) (tmp/10000);
  ltime.minute= (uint) (tmp/100 % 100);
  ltime.second= (uint) (tmp % 100);
3462
  make_time((DATE_TIME_FORMAT*) 0, &ltime, val_buffer);
unknown's avatar
unknown committed
3463 3464 3465
  return val_buffer;
}

3466

unknown's avatar
unknown committed
3467 3468 3469 3470 3471 3472 3473
/*
  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)
3474
{
unknown's avatar
unknown committed
3475
  long tmp;
unknown's avatar
unknown committed
3476
  if (!(fuzzydate & TIME_FUZZY_DATE))
unknown's avatar
unknown committed
3477
  {
3478 3479 3480 3481
    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
3482 3483 3484
    return 1;
  }
  tmp=(long) sint3korr(ptr);
3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498
  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
3499

unknown's avatar
unknown committed
3500 3501 3502 3503 3504 3505 3506 3507 3508
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
3509
  ltime->day= 0;
unknown's avatar
unknown committed
3510
  ltime->hour=   (int) (tmp/10000);
unknown's avatar
unknown committed
3511
  tmp-=ltime->hour*10000;
unknown's avatar
unknown committed
3512 3513
  ltime->minute= (int) tmp/100;
  ltime->second= (int) tmp % 100;
unknown's avatar
unknown committed
3514
  ltime->second_part=0;
3515
  ltime->time_type= MYSQL_TIMESTAMP_TIME;
unknown's avatar
unknown committed
3516 3517 3518
  return 0;
}

3519 3520 3521 3522 3523

bool Field_time::send_binary(Protocol *protocol)
{
  TIME tm;
  Field_time::get_time(&tm);
3524 3525
  tm.day= tm.hour/24;				// Move hours to days
  tm.hour-= tm.day*24;
unknown's avatar
unknown committed
3526
  return protocol->store_time(&tm);
3527 3528 3529
}


unknown's avatar
unknown committed
3530 3531
int Field_time::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
3532 3533 3534
  int32 a,b;
  a=(int32) sint3korr(a_ptr);
  b=(int32) sint3korr(b_ptr);
unknown's avatar
unknown committed
3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546
  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
{
3547
  res.set_ascii("time", 4);
unknown's avatar
unknown committed
3548 3549 3550 3551 3552 3553 3554 3555
}

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

unknown's avatar
unknown committed
3556
int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3557
{
3558
  char *end;
unknown's avatar
unknown committed
3559 3560
  int error;
  long nr= my_strntol(cs, from, len, 10, &end, &error);
unknown's avatar
unknown committed
3561

unknown's avatar
unknown committed
3562
  if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155 || error)
unknown's avatar
unknown committed
3563 3564
  {
    *ptr=0;
3565
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3566
    return 1;
unknown's avatar
unknown committed
3567
  }
unknown's avatar
unknown committed
3568 3569 3570
  if (table->in_use->count_cuted_fields && check_int(from,len,end,cs))
    error= 1;

unknown's avatar
unknown committed
3571 3572 3573 3574 3575 3576 3577 3578
  if (nr != 0 || len != 4)
  {
    if (nr < YY_PART_YEAR)
      nr+=100;					// 2000 - 2069
    else if (nr > 1900)
      nr-= 1900;
  }
  *ptr= (char) (unsigned char) nr;
unknown's avatar
unknown committed
3579
  return error;
unknown's avatar
unknown committed
3580 3581
}

unknown's avatar
unknown committed
3582

unknown's avatar
unknown committed
3583
int Field_year::store(double nr)
unknown's avatar
unknown committed
3584 3585
{
  if (nr < 0.0 || nr >= 2155.0)
3586 3587 3588 3589
  {
    (void) Field_year::store((longlong) -1);
    return 1;
  }
unknown's avatar
unknown committed
3590
  else
3591
    return Field_year::store((longlong) nr);
unknown's avatar
unknown committed
3592 3593
}

unknown's avatar
unknown committed
3594
int Field_year::store(longlong nr)
unknown's avatar
unknown committed
3595 3596 3597 3598
{
  if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155)
  {
    *ptr=0;
3599
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
3600
    return 1;
unknown's avatar
unknown committed
3601 3602 3603 3604 3605 3606 3607 3608 3609
  }
  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;
3610
  return 0;
unknown's avatar
unknown committed
3611 3612
}

unknown's avatar
unknown committed
3613 3614 3615
bool Field_year::send_binary(Protocol *protocol)
{
  ulonglong tmp= Field_year::val_int();
3616
  return protocol->store_short(tmp);
unknown's avatar
unknown committed
3617
}
unknown's avatar
unknown committed
3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645

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
3646
  CHARSET_INFO *cs=res.charset();
3647
  res.length(cs->cset->snprintf(cs,(char*)res.ptr(),res.alloced_length(),
3648
			  "year(%d)",(int) field_length));
unknown's avatar
unknown committed
3649 3650 3651 3652 3653 3654 3655 3656 3657 3658
}


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

unknown's avatar
unknown committed
3659
int Field_date::store(const char *from, uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3660 3661
{
  TIME l_time;
unknown's avatar
unknown committed
3662
  uint32 tmp;
3663 3664
  int error;
  
unknown's avatar
unknown committed
3665 3666 3667 3668 3669
  if (str_to_datetime(from, len, &l_time, TIME_FUZZY_DATE |
                      (table->in_use->variables.sql_mode &
                       (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                        MODE_INVALID_DATES)),
                      &error) <= MYSQL_TIMESTAMP_ERROR)
3670
  {
unknown's avatar
unknown committed
3671
    tmp=0;
unknown's avatar
unknown committed
3672
    error= 1;
3673
  }
unknown's avatar
unknown committed
3674
  else
unknown's avatar
unknown committed
3675
    tmp=(uint32) l_time.year*10000L + (uint32) (l_time.month*100+l_time.day);
3676 3677 3678

  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
3679
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
3680

unknown's avatar
unknown committed
3681 3682 3683 3684 3685 3686 3687 3688
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
3689
  return error;
unknown's avatar
unknown committed
3690 3691 3692
}


unknown's avatar
unknown committed
3693
int Field_date::store(double nr)
unknown's avatar
unknown committed
3694 3695
{
  long tmp;
unknown's avatar
unknown committed
3696
  int error= 0;
unknown's avatar
unknown committed
3697 3698 3699 3700 3701
  if (nr >= 19000000000000.0 && nr <= 99991231235959.0)
    nr=floor(nr/1000000.0);			// Timestamp to date
  if (nr < 0.0 || nr > 99991231.0)
  {
    tmp=0L;
3702 3703
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE, 
3704
                         nr, MYSQL_TIMESTAMP_DATE);
unknown's avatar
unknown committed
3705
    error= 1;
unknown's avatar
unknown committed
3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716
  }
  else
    tmp=(long) rint(nr);
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
3717
  return error;
unknown's avatar
unknown committed
3718 3719 3720
}


unknown's avatar
unknown committed
3721
int Field_date::store(longlong nr)
unknown's avatar
unknown committed
3722 3723
{
  long tmp;
unknown's avatar
unknown committed
3724
  int error= 0;
unknown's avatar
unknown committed
3725 3726 3727 3728 3729
  if (nr >= LL(19000000000000) && nr < LL(99991231235959))
    nr=nr/LL(1000000);			// Timestamp to date
  if (nr < 0 || nr > LL(99991231))
  {
    tmp=0L;
3730 3731
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE,
3732
                         nr, MYSQL_TIMESTAMP_DATE, 0);
unknown's avatar
unknown committed
3733
    error= 1;
unknown's avatar
unknown committed
3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744
  }
  else
    tmp=(long) nr;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int4store(ptr,tmp);
  }
  else
#endif
    longstore(ptr,tmp);
3745
  return error;
unknown's avatar
unknown committed
3746 3747 3748
}


unknown's avatar
unknown committed
3749 3750 3751 3752 3753 3754 3755 3756 3757 3758
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
3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786

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)))
{
3787
  TIME ltime;
unknown's avatar
unknown committed
3788 3789 3790 3791 3792 3793 3794 3795
  val_buffer->alloc(field_length);
  int32 tmp;
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
    tmp=sint4korr(ptr);
  else
#endif
    longget(tmp,ptr);
3796 3797 3798 3799
  ltime.neg= 0;
  ltime.year= (int) ((uint32) tmp/10000L % 10000);
  ltime.month= (int) ((uint32) tmp/100 % 100);
  ltime.day= (int) ((uint32) tmp % 100);
3800
  make_date((DATE_TIME_FORMAT *) 0, &ltime, val_buffer);
unknown's avatar
unknown committed
3801 3802 3803
  return val_buffer;
}

3804

unknown's avatar
unknown committed
3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845
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
{
3846
  res.set_ascii("date", 4);
unknown's avatar
unknown committed
3847 3848 3849 3850 3851 3852 3853 3854
}

/****************************************************************************
** 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
3855
int Field_newdate::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
3856 3857 3858
{
  TIME l_time;
  long tmp;
3859
  int error;
unknown's avatar
unknown committed
3860 3861 3862 3863 3864 3865
  if (str_to_datetime(from, len, &l_time,
                      (TIME_FUZZY_DATE |
                       (table->in_use->variables.sql_mode &
                        (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                         MODE_INVALID_DATES))),
                      &error) <= MYSQL_TIMESTAMP_ERROR)
3866
  {
unknown's avatar
unknown committed
3867
    tmp=0L;
unknown's avatar
unknown committed
3868
    error= 1;
3869
  }
unknown's avatar
unknown committed
3870 3871
  else
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
3872 3873 3874

  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
3875
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
3876
    
unknown's avatar
unknown committed
3877
  int3store(ptr,tmp);
3878
  return error;
unknown's avatar
unknown committed
3879 3880
}

unknown's avatar
unknown committed
3881
int Field_newdate::store(double nr)
unknown's avatar
unknown committed
3882 3883
{
  if (nr < 0.0 || nr > 99991231235959.0)
3884 3885
  {
    (void) Field_newdate::store((longlong) -1);
3886
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3887
                         ER_WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATE);
3888 3889
    return 1;
  }
unknown's avatar
unknown committed
3890
  else
3891
    return Field_newdate::store((longlong) rint(nr));
unknown's avatar
unknown committed
3892 3893 3894
}


unknown's avatar
unknown committed
3895
int Field_newdate::store(longlong nr)
unknown's avatar
unknown committed
3896
{
unknown's avatar
unknown committed
3897
  int32 tmp;
unknown's avatar
unknown committed
3898
  int error= 0;
unknown's avatar
unknown committed
3899 3900 3901 3902 3903
  if (nr >= LL(100000000) && nr <= LL(99991231235959))
    nr=nr/LL(1000000);			// Timestamp to date
  if (nr < 0L || nr > 99991231L)
  {
    tmp=0;
3904
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3905 3906
                         ER_WARN_DATA_OUT_OF_RANGE, nr,
                         MYSQL_TIMESTAMP_DATE, 1);
unknown's avatar
unknown committed
3907
    error= 1;
unknown's avatar
unknown committed
3908 3909 3910
  }
  else
  {
unknown's avatar
unknown committed
3911
    tmp=(int32) nr;
unknown's avatar
unknown committed
3912 3913 3914
    if (tmp)
    {
      if (tmp < YY_PART_YEAR*10000L)			// Fix short dates
unknown's avatar
unknown committed
3915
	tmp+= (uint32) 20000000L;
unknown's avatar
unknown committed
3916
      else if (tmp < 999999L)
unknown's avatar
unknown committed
3917
	tmp+= (uint32) 19000000L;
unknown's avatar
unknown committed
3918
    }
unknown's avatar
unknown committed
3919 3920
    uint month= (uint) ((tmp/100) % 100);
    uint day=   (uint) (tmp%100);
unknown's avatar
unknown committed
3921 3922 3923
    if (month > 12 || day > 31)
    {
      tmp=0L;					// Don't allow date to change
3924
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
3925 3926
                           ER_WARN_DATA_OUT_OF_RANGE, nr,
                           MYSQL_TIMESTAMP_DATE, 1);
unknown's avatar
unknown committed
3927
      error= 1;
unknown's avatar
unknown committed
3928 3929 3930 3931
    }
    else
      tmp= day + month*32 + (tmp/10000)*16*32;
  }
unknown's avatar
unknown committed
3932
  int3store(ptr,(int32) tmp);
3933
  return error;
unknown's avatar
unknown committed
3934 3935 3936 3937 3938
}

void Field_newdate::store_time(TIME *ltime,timestamp_type type)
{
  long tmp;
3939
  if (type == MYSQL_TIMESTAMP_DATE || type == MYSQL_TIMESTAMP_DATETIME)
unknown's avatar
unknown committed
3940 3941 3942 3943
    tmp=ltime->year*16*32+ltime->month*32+ltime->day;
  else
  {
    tmp=0;
3944
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
3945 3946 3947 3948
  }
  int3store(ptr,tmp);
}

unknown's avatar
unknown committed
3949 3950 3951 3952 3953 3954
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
3955 3956 3957 3958 3959 3960 3961 3962

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

longlong Field_newdate::val_int(void)
{
unknown's avatar
unknown committed
3963
  ulong j= uint3korr(ptr);
unknown's avatar
unknown committed
3964 3965 3966 3967 3968 3969 3970 3971 3972
  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
3973
  uint32 tmp=(uint32) uint3korr(ptr);
unknown's avatar
unknown committed
3974 3975 3976 3977
  int part;
  char *pos=(char*) val_buffer->ptr()+10;

  /* Open coded to get more speed */
unknown's avatar
unknown committed
3978
  *pos--=0;					// End NULL
unknown's avatar
unknown committed
3979
  part=(int) (tmp & 31);
unknown's avatar
unknown committed
3980 3981 3982
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
unknown's avatar
unknown committed
3983
  part=(int) (tmp >> 5 & 15);
unknown's avatar
unknown committed
3984 3985 3986
  *pos--= (char) ('0'+part%10);
  *pos--= (char) ('0'+part/10);
  *pos--= '-';
unknown's avatar
unknown committed
3987
  part=(int) (tmp >> 9);
unknown's avatar
unknown committed
3988 3989 3990 3991
  *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
3992 3993 3994
  return val_buffer;
}

3995
bool Field_newdate::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
3996 3997 3998
{
  if (is_null())
    return 1;
unknown's avatar
unknown committed
3999
  uint32 tmp=(uint32) uint3korr(ptr);
unknown's avatar
unknown committed
4000 4001 4002
  ltime->day=   tmp & 31;
  ltime->month= (tmp >> 5) & 15;
  ltime->year=  (tmp >> 9);
4003
  ltime->time_type= MYSQL_TIMESTAMP_DATE;
4004
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
unknown's avatar
unknown committed
4005 4006
  return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
          1 : 0);
unknown's avatar
unknown committed
4007 4008 4009 4010
}

bool Field_newdate::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
4011
  return Field_newdate::get_date(ltime,0);
unknown's avatar
unknown committed
4012 4013 4014 4015
}

int Field_newdate::cmp(const char *a_ptr, const char *b_ptr)
{
unknown's avatar
unknown committed
4016 4017 4018
  uint32 a,b;
  a=(uint32) uint3korr(a_ptr);
  b=(uint32) uint3korr(b_ptr);
unknown's avatar
unknown committed
4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030
  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
{
4031
  res.set_ascii("date", 4);
unknown's avatar
unknown committed
4032 4033 4034 4035 4036 4037 4038 4039 4040 4041
}


/****************************************************************************
** 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
4042
int Field_datetime::store(const char *from,uint len,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4043
{
4044 4045 4046 4047
  TIME time_tmp;
  int error;
  ulonglong tmp= 0;
  
unknown's avatar
unknown committed
4048 4049 4050 4051 4052 4053
  if (str_to_datetime(from, len, &time_tmp,
                      (TIME_FUZZY_DATE |
                       (table->in_use->variables.sql_mode &
                        (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
                         MODE_INVALID_DATES))),
                      &error) > MYSQL_TIMESTAMP_ERROR)
4054 4055 4056 4057 4058
    tmp= TIME_to_ulonglong_datetime(&time_tmp);
  
  if (error)
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE,
4059
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
4060

unknown's avatar
unknown committed
4061 4062 4063 4064 4065 4066 4067 4068
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
4069
  return error;
unknown's avatar
unknown committed
4070 4071 4072
}


unknown's avatar
unknown committed
4073
int Field_datetime::store(double nr)
unknown's avatar
unknown committed
4074
{
unknown's avatar
unknown committed
4075
  int error= 0;
unknown's avatar
unknown committed
4076 4077
  if (nr < 0.0 || nr > 99991231235959.0)
  {
4078 4079
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
                         ER_WARN_DATA_OUT_OF_RANGE,
4080
                         nr, MYSQL_TIMESTAMP_DATETIME);
unknown's avatar
unknown committed
4081
    nr=0.0;
unknown's avatar
unknown committed
4082
    error= 1;
unknown's avatar
unknown committed
4083
  }
4084 4085
  error |= Field_datetime::store((longlong) rint(nr));
  return error;
unknown's avatar
unknown committed
4086 4087 4088
}


unknown's avatar
unknown committed
4089
int Field_datetime::store(longlong nr)
unknown's avatar
unknown committed
4090
{
4091
  TIME not_used;
4092 4093
  int error;
  longlong initial_nr= nr;
4094
  
4095 4096 4097 4098 4099
  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, 
4100
                         MYSQL_TIMESTAMP_DATETIME, 1);
4101

unknown's avatar
unknown committed
4102 4103 4104 4105 4106 4107 4108 4109
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,nr);
  }
  else
#endif
    longlongstore(ptr,nr);
4110
  return error;
unknown's avatar
unknown committed
4111 4112
}

unknown's avatar
unknown committed
4113

unknown's avatar
unknown committed
4114 4115 4116
void Field_datetime::store_time(TIME *ltime,timestamp_type type)
{
  longlong tmp;
4117
  if (type == MYSQL_TIMESTAMP_DATE || type == MYSQL_TIMESTAMP_DATETIME)
unknown's avatar
unknown committed
4118 4119 4120 4121 4122
    tmp=((ltime->year*10000L+ltime->month*100+ltime->day)*LL(1000000)+
	 (ltime->hour*10000L+ltime->minute*100+ltime->second));
  else
  {
    tmp=0;
4123
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134
  }
#ifdef WORDS_BIGENDIAN
  if (table->db_low_byte_first)
  {
    int8store(ptr,tmp);
  }
  else
#endif
    longlongstore(ptr,tmp);
}

unknown's avatar
unknown committed
4135 4136 4137
bool Field_datetime::send_binary(Protocol *protocol)
{
  TIME tm;
4138
  Field_datetime::get_date(&tm, TIME_FUZZY_DATE);
unknown's avatar
unknown committed
4139 4140 4141
  return protocol->store(&tm);
}

unknown's avatar
unknown committed
4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186

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
4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205
  *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
4206 4207 4208
  return val_buffer;
}

4209
bool Field_datetime::get_date(TIME *ltime, uint fuzzydate)
unknown's avatar
unknown committed
4210 4211
{
  longlong tmp=Field_datetime::val_int();
unknown's avatar
unknown committed
4212 4213 4214
  uint32 part1,part2;
  part1=(uint32) (tmp/LL(1000000));
  part2=(uint32) (tmp - (ulonglong) part1*LL(1000000));
unknown's avatar
unknown committed
4215

4216
  ltime->time_type=	MYSQL_TIMESTAMP_DATETIME;
unknown's avatar
unknown committed
4217 4218 4219 4220 4221 4222 4223 4224
  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
4225
  return (!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ? 1 : 0;
unknown's avatar
unknown committed
4226 4227 4228 4229
}

bool Field_datetime::get_time(TIME *ltime)
{
unknown's avatar
unknown committed
4230
  return Field_datetime::get_date(ltime,0);
unknown's avatar
unknown committed
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 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282
}

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
{
4283
  res.set_ascii("datetime", 8);
unknown's avatar
unknown committed
4284 4285 4286 4287 4288 4289 4290 4291 4292
}

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

	/* Copy a string and fill with space */

unknown's avatar
unknown committed
4293
int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4294
{
unknown's avatar
unknown committed
4295
  int error= 0;
unknown's avatar
unknown committed
4296
  uint32 not_used;
unknown's avatar
unknown committed
4297 4298
  char buff[80];
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
4299
  uint copy_length;
4300 4301 4302 4303
  
  /* See the comment for Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
  
unknown's avatar
unknown committed
4304
  /* Convert character set if nesessary */
unknown's avatar
unknown committed
4305
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
4306
  { 
4307 4308
    uint conv_errors;
    tmpstr.copy(from, length, cs, field_charset, &conv_errors);
unknown's avatar
unknown committed
4309 4310
    from= tmpstr.ptr();
    length=  tmpstr.length();
4311 4312
    if (conv_errors)
      error= 1;
unknown's avatar
unknown committed
4313
  }
unknown's avatar
unknown committed
4314 4315

  /* 
4316
    Make sure we don't break a multibyte sequence
unknown's avatar
unknown committed
4317 4318
    as well as don't copy a malformed data.
  */
4319 4320 4321 4322
  copy_length= field_charset->cset->well_formed_len(field_charset,
						    from,from+length,
						    field_length/
						    field_charset->mbmaxlen);
unknown's avatar
unknown committed
4323 4324 4325 4326 4327
  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,' ');
  
4328
  if ((copy_length < length) && table->in_use->count_cuted_fields)
unknown's avatar
unknown committed
4329 4330 4331 4332 4333 4334
  {					// 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)
4335
      error= 1;
unknown's avatar
unknown committed
4336
  }
4337 4338 4339
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);

4340
  return error;
unknown's avatar
unknown committed
4341 4342 4343
}


4344 4345 4346 4347
/*
  Store double value in Field_string or Field_varstring.

  SYNOPSIS
unknown's avatar
unknown committed
4348
    store(double nr)
4349 4350 4351 4352 4353 4354
    nr            number

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

unknown's avatar
unknown committed
4355
int Field_str::store(double nr)
unknown's avatar
unknown committed
4356
{
4357
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
4358
  uint length;
unknown's avatar
unknown committed
4359 4360
  bool use_scientific_notation= TRUE;
  use_scientific_notation= TRUE;
unknown's avatar
unknown committed
4361
  if (field_length < 32 && fabs(nr) < log_10[field_length]-1)
unknown's avatar
unknown committed
4362
    use_scientific_notation= FALSE;
unknown's avatar
unknown committed
4363

unknown's avatar
unknown committed
4364 4365 4366 4367 4368
  length= (uint) my_sprintf(buff, (buff, "%-.*g",
                                   (use_scientific_notation ?
                                    max(0, (int)field_length-5) :
                                    field_length),
                                   nr));
4369 4370 4371 4372 4373
  /*
    +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)
4374 4375
    the test for field_length < 5 is for extreme cases,
    like inserting 500.0 in char(1)
4376
  */
4377
  DBUG_ASSERT(field_length < 5 || length <= field_length+1);
4378
  return store((const char *) buff, length, charset());
4379 4380
}

unknown's avatar
unknown committed
4381

unknown's avatar
unknown committed
4382
int Field_string::store(longlong nr)
unknown's avatar
unknown committed
4383
{
unknown's avatar
unknown committed
4384 4385 4386
  char buff[64];
  int  l;
  CHARSET_INFO *cs=charset();
4387
  l= (cs->cset->longlong10_to_str)(cs,buff,sizeof(buff),-10,nr);
unknown's avatar
unknown committed
4388
  return Field_string::store(buff,(uint)l,cs);
unknown's avatar
unknown committed
4389 4390 4391 4392 4393
}


double Field_string::val_real(void)
{
4394
  int not_used;
unknown's avatar
unknown committed
4395
  CHARSET_INFO *cs=charset();
4396
  return my_strntod(cs,ptr,field_length,(char**)0,&not_used);
unknown's avatar
unknown committed
4397 4398 4399 4400 4401
}


longlong Field_string::val_int(void)
{
4402
  int not_used;
4403
  CHARSET_INFO *cs=charset();
4404
  return my_strntoll(cs,ptr,field_length,10,NULL,&not_used);
unknown's avatar
unknown committed
4405 4406 4407 4408 4409 4410
}


String *Field_string::val_str(String *val_buffer __attribute__((unused)),
			      String *val_ptr)
{
unknown's avatar
unknown committed
4411
  uint length= field_charset->cset->lengthsp(field_charset, ptr, field_length);
4412 4413
  /* See the comment for Field_long::store(long long) */
  DBUG_ASSERT(table->in_use == current_thd);
unknown's avatar
unknown committed
4414
  val_ptr->set((const char*) ptr, length, field_charset);
unknown's avatar
unknown committed
4415 4416 4417 4418 4419 4420
  return val_ptr;
}


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

unknown's avatar
unknown committed
4423
  if (field_charset->strxfrm_multiply > 1)
4424 4425 4426 4427 4428
  {
    /*
      We have to remove end space to be able to compare multi-byte-characters
      like in latin_de 'ae' and 0xe4
    */
4429
    return field_charset->coll->strnncollsp(field_charset,
unknown's avatar
unknown committed
4430 4431 4432
                                            (const uchar*) a_ptr, field_length,
                                            (const uchar*) b_ptr,
                                            field_length);
4433
  }
unknown's avatar
unknown committed
4434 4435 4436 4437 4438 4439 4440 4441
  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;
4442 4443
  return my_strnncoll(field_charset,(const uchar*) a_ptr, a_len,
                                    (const uchar*) b_ptr, b_len);
unknown's avatar
unknown committed
4444 4445
}

4446

unknown's avatar
unknown committed
4447 4448
void Field_string::sort_string(char *to,uint length)
{
4449
  uint tmp=my_strnxfrm(field_charset,
4450 4451
		       (unsigned char *) to, length,
		       (unsigned char *) ptr, field_length);
4452
  if (tmp < length)
4453
    field_charset->cset->fill(field_charset, to + tmp, length - tmp, ' ');
unknown's avatar
unknown committed
4454 4455 4456 4457 4458
}


void Field_string::sql_type(String &res) const
{
4459
  THD *thd= table->in_use;
unknown's avatar
unknown committed
4460
  CHARSET_INFO *cs=res.charset();
4461
  ulong length= cs->cset->snprintf(cs,(char*) res.ptr(),
unknown's avatar
unknown committed
4462
			    res.alloced_length(), "%s(%d)",
4463 4464 4465
			    (field_length > 3 &&
			     (table->db_options_in_use &
			      HA_OPTION_PACK_RECORD) ?
4466
			      (has_charset() ? "varchar" : "varbinary") :
4467
			      (has_charset() ? "char" : "binary")),
4468
			    (int) field_length / charset()->mbmaxlen);
4469
  res.length(length);
4470 4471 4472
  if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
      has_charset() && (charset()->state & MY_CS_BINSORT))
    res.append(" binary");
unknown's avatar
unknown committed
4473 4474 4475
}

char *Field_string::pack(char *to, const char *from, uint max_length)
4476
{
unknown's avatar
unknown committed
4477 4478
  uint length=      min(field_length,max_length);
  uint char_length= max_length/field_charset->mbmaxlen;
4479
  if (length > char_length)
unknown's avatar
unknown committed
4480
    char_length= my_charpos(field_charset, from, from+length, char_length);
4481
  set_if_smaller(length, char_length);
unknown's avatar
unknown committed
4482 4483
  while (length && from[length-1] == ' ')
    length--;
4484
  *to++= (char) (uchar) length;
4485
  if (field_length > 255)
4486
    *to++= (char) (uchar) (length >> 8);
4487 4488
  memcpy(to, from, length);
  return to+length;
4489 4490 4491
}


unknown's avatar
unknown committed
4492 4493
const char *Field_string::unpack(char *to, const char *from)
{
4494 4495 4496 4497 4498 4499 4500 4501
  uint length;
  if (field_length > 255)
  {
    length= uint2korr(from);
    from+= 2;
  }
  else
    length= (uint) (uchar) *from++;
unknown's avatar
unknown committed
4502 4503 4504 4505 4506 4507 4508 4509
  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)
{
4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522
  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
4523 4524 4525
  return my_strnncoll(field_charset,
		      (const uchar*)a,a_length,
		      (const uchar*)b,b_length);
unknown's avatar
unknown committed
4526 4527 4528
}


4529 4530
int Field_string::pack_cmp(const char *b, uint length)
{
4531 4532 4533 4534 4535 4536 4537 4538
  uint b_length;
  if (field_length > 255)
  {
    b_length= uint2korr(b);
    b+= 2;
  }
  else
    b_length= (uint) (uchar) *b++;
4539 4540 4541 4542
  char *end= ptr + field_length;
  while (end > ptr && end[-1] == ' ')
    end--;
  uint a_length = (uint) (end - ptr);
unknown's avatar
unknown committed
4543 4544 4545
  return my_strnncoll(field_charset,
		     (const uchar*)ptr,a_length,
		     (const uchar*)b, b_length);
4546 4547 4548
}


4549
uint Field_string::packed_col_length(const char *data_ptr, uint length)
unknown's avatar
unknown committed
4550
{
4551
  if (length > 255)
4552
    return uint2korr(data_ptr)+2;
unknown's avatar
unknown committed
4553
  else
4554
    return (uint) ((uchar) *data_ptr)+1;
unknown's avatar
unknown committed
4555 4556 4557 4558
}

uint Field_string::max_packed_col_length(uint max_length)
{
4559
  return (max_length > 255 ? 2 : 1)+max_length;
unknown's avatar
unknown committed
4560 4561 4562 4563 4564 4565 4566 4567
}


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


unknown's avatar
unknown committed
4568
int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4569
{
unknown's avatar
unknown committed
4570
  int error= 0;
unknown's avatar
unknown committed
4571
  uint32 not_used;
unknown's avatar
unknown committed
4572 4573
  char buff[80];
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
4574

unknown's avatar
unknown committed
4575
  /* Convert character set if nesessary */
unknown's avatar
unknown committed
4576
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
4577
  { 
4578 4579
    uint conv_errors;
    tmpstr.copy(from, length, cs, field_charset, &conv_errors);
unknown's avatar
unknown committed
4580 4581
    from= tmpstr.ptr();
    length=  tmpstr.length();
4582 4583
    if (conv_errors)
      error= 1;
unknown's avatar
unknown committed
4584
  }
4585
  if (length > field_length)
unknown's avatar
unknown committed
4586 4587
  {
    length=field_length;
unknown's avatar
unknown committed
4588
    error= 1;
unknown's avatar
unknown committed
4589
  }
4590 4591
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
4592
  memcpy(ptr+HA_KEY_BLOB_LENGTH,from,length);
4593
  int2store(ptr, length);
4594
  return error;
unknown's avatar
unknown committed
4595 4596 4597
}


unknown's avatar
unknown committed
4598
int Field_varstring::store(longlong nr)
unknown's avatar
unknown committed
4599
{
unknown's avatar
unknown committed
4600 4601 4602
  char buff[64];
  int  l;
  CHARSET_INFO *cs=charset();
4603
  l= (cs->cset->longlong10_to_str)(cs,buff,sizeof(buff),-10,nr);
unknown's avatar
unknown committed
4604
  return Field_varstring::store(buff,(uint)l,cs);
unknown's avatar
unknown committed
4605 4606 4607 4608 4609
}


double Field_varstring::val_real(void)
{
4610
  int not_used;
4611
  uint length=uint2korr(ptr)+HA_KEY_BLOB_LENGTH;
unknown's avatar
unknown committed
4612
  CHARSET_INFO *cs=charset();
4613
  return my_strntod(cs, ptr+HA_KEY_BLOB_LENGTH, length, (char**)0, &not_used);
unknown's avatar
unknown committed
4614 4615 4616 4617 4618
}


longlong Field_varstring::val_int(void)
{
4619
  int not_used;
4620
  uint length=uint2korr(ptr)+HA_KEY_BLOB_LENGTH;
4621
  CHARSET_INFO *cs=charset();
4622
  return my_strntoll(cs,ptr+HA_KEY_BLOB_LENGTH,length,10,NULL, &not_used);
unknown's avatar
unknown committed
4623 4624 4625 4626 4627 4628 4629
}


String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
				 String *val_ptr)
{
  uint length=uint2korr(ptr);
4630
  val_ptr->set((const char*) ptr+HA_KEY_BLOB_LENGTH,length,field_charset);
unknown's avatar
unknown committed
4631 4632 4633 4634 4635 4636 4637 4638 4639
  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;
4640 4641 4642 4643 4644
  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
4645 4646 4647 4648 4649 4650
  return diff ? diff : (int) (a_length - b_length);
}

void Field_varstring::sort_string(char *to,uint length)
{
  uint tot_length=uint2korr(ptr);
4651 4652 4653 4654
  tot_length= my_strnxfrm(field_charset,
			  (uchar*) to, length,
			  (uchar*) ptr+HA_KEY_BLOB_LENGTH,
			  tot_length);
unknown's avatar
unknown committed
4655
  if (tot_length < length)
4656 4657
    field_charset->cset->fill(field_charset, to+tot_length,length-tot_length,
			      binary() ? (char) 0 : ' ');
unknown's avatar
unknown committed
4658 4659 4660 4661 4662
}


void Field_varstring::sql_type(String &res) const
{
unknown's avatar
unknown committed
4663
  CHARSET_INFO *cs=res.charset();
4664
  ulong length= cs->cset->snprintf(cs,(char*) res.ptr(),
unknown's avatar
unknown committed
4665
			     res.alloced_length(),"varchar(%u)",
4666
			     field_length / charset()->mbmaxlen);
4667
  res.length(length);
unknown's avatar
unknown committed
4668 4669 4670 4671
}

char *Field_varstring::pack(char *to, const char *from, uint max_length)
{
4672
  uint length=uint2korr(from);
unknown's avatar
unknown committed
4673 4674
  if (length > max_length)
    length=max_length;
unknown's avatar
unknown committed
4675
  *to++= (char) (length & 255);
unknown's avatar
unknown committed
4676
  if (max_length > 255)
unknown's avatar
unknown committed
4677
    *to++= (char) (length >> 8);
unknown's avatar
unknown committed
4678
  if (length)
4679
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
unknown's avatar
unknown committed
4680 4681 4682 4683
  return to+length;
}


4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701
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
4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716
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)
4717
    memcpy(to+HA_KEY_BLOB_LENGTH, from, length);
unknown's avatar
unknown committed
4718 4719 4720 4721 4722 4723 4724 4725 4726 4727
  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)
  {
4728 4729
    a_length=uint2korr(a); a+= 2;
    b_length=uint2korr(b); b+= 2;
unknown's avatar
unknown committed
4730 4731 4732 4733 4734 4735
  }
  else
  {
    a_length= (uint) (uchar) *a++;
    b_length= (uint) (uchar) *b++;
  }
unknown's avatar
unknown committed
4736
  return my_strnncoll(field_charset,
4737 4738
		     (const uchar*) a, a_length,
		     (const uchar*) b, b_length);
unknown's avatar
unknown committed
4739 4740
}

4741 4742
int Field_varstring::pack_cmp(const char *b, uint key_length)
{
4743 4744
  char *a= ptr+HA_KEY_BLOB_LENGTH;
  uint a_length= uint2korr(ptr);
4745 4746 4747
  uint b_length;
  if (key_length > 255)
  {
4748
    b_length=uint2korr(b); b+= 2;
4749 4750 4751 4752 4753
  }
  else
  {
    b_length= (uint) (uchar) *b++;
  }
unknown's avatar
unknown committed
4754
  return my_strnncoll(field_charset,
4755 4756
		     (const uchar*) a, a_length,
		     (const uchar*) b, b_length);
4757 4758
}

4759
uint Field_varstring::packed_col_length(const char *data_ptr, uint length)
unknown's avatar
unknown committed
4760
{
4761
  if (length > 255)
4762
    return uint2korr(data_ptr)+HA_KEY_BLOB_LENGTH;
unknown's avatar
unknown committed
4763
  else
4764
    return (uint) ((uchar) *data_ptr)+1;
unknown's avatar
unknown committed
4765 4766 4767 4768
}

uint Field_varstring::max_packed_col_length(uint max_length)
{
4769
  return (max_length > 255 ? 2 : 1)+max_length;
unknown's avatar
unknown committed
4770 4771
}

4772 4773
void Field_varstring::get_key_image(char *buff, uint length, CHARSET_INFO *cs,
				    imagetype type)
4774 4775 4776 4777 4778
{
  uint f_length=uint2korr(ptr);
  if (f_length > length)
    f_length= length;
  int2store(buff,length);
4779
  memcpy(buff+HA_KEY_BLOB_LENGTH, ptr+HA_KEY_BLOB_LENGTH, length);
4780 4781
#ifdef HAVE_purify
  if (f_length < length)
4782
    bzero(buff+HA_KEY_BLOB_LENGTH+f_length, (length-f_length));
4783 4784 4785
#endif
}

unknown's avatar
unknown committed
4786
void Field_varstring::set_key_image(char *buff,uint length, CHARSET_INFO *cs)
4787 4788
{
  length=uint2korr(buff);			// Real length is here
4789
  (void) Field_varstring::store(buff+HA_KEY_BLOB_LENGTH, length, cs);
4790 4791 4792 4793
}



unknown's avatar
unknown committed
4794 4795 4796 4797 4798 4799
/****************************************************************************
** 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
4800
Field_blob::Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
unknown's avatar
unknown committed
4801 4802
		       enum utype unireg_check_arg, const char *field_name_arg,
		       struct st_table *table_arg,uint blob_pack_length,
4803
		       CHARSET_INFO *cs)
unknown's avatar
unknown committed
4804 4805
  :Field_str(ptr_arg, (1L << min(blob_pack_length,3)*8)-1L,
	     null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
4806
	     table_arg, cs),
unknown's avatar
unknown committed
4807
   packlength(blob_pack_length)
unknown's avatar
unknown committed
4808 4809 4810 4811 4812 4813 4814
{
  flags|= BLOB_FLAG;
  if (table)
    table->blob_fields++;
}


unknown's avatar
unknown committed
4815
void Field_blob::store_length(uint32 number)
unknown's avatar
unknown committed
4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846
{
  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
4847
uint32 Field_blob::get_length(const char *pos)
unknown's avatar
unknown committed
4848 4849 4850
{
  switch (packlength) {
  case 1:
unknown's avatar
unknown committed
4851
    return (uint32) (uchar) pos[0];
unknown's avatar
unknown committed
4852 4853 4854 4855 4856 4857 4858 4859 4860
  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
4861
      return (uint32) tmp;
unknown's avatar
unknown committed
4862 4863
    }
  case 3:
unknown's avatar
unknown committed
4864
    return (uint32) uint3korr(pos);
unknown's avatar
unknown committed
4865 4866 4867 4868 4869 4870 4871 4872 4873
  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
4874
      return (uint32) tmp;
unknown's avatar
unknown committed
4875 4876 4877 4878 4879 4880
    }
  }
  return 0;					// Impossible
}


4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916
/*
  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
4917
int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
4918
{
4919
  int error= 0;
unknown's avatar
unknown committed
4920
  if (!length)
unknown's avatar
unknown committed
4921 4922 4923 4924 4925
  {
    bzero(ptr,Field_blob::pack_length());
  }
  else
  {
unknown's avatar
unknown committed
4926
    bool was_conversion;
unknown's avatar
unknown committed
4927 4928
    char buff[80];
    String tmpstr(buff,sizeof(buff), &my_charset_bin);
4929
    uint copy_length;
unknown's avatar
unknown committed
4930
    uint32 not_used;
unknown's avatar
unknown committed
4931

unknown's avatar
unknown committed
4932
    /* Convert character set if nesessary */
unknown's avatar
unknown committed
4933 4934
    if ((was_conversion= String::needs_conversion(length, cs, field_charset,
						  &not_used)))
unknown's avatar
unknown committed
4935
    { 
4936 4937
      uint conv_errors;
      tmpstr.copy(from, length, cs, field_charset, &conv_errors);
unknown's avatar
unknown committed
4938 4939
      from= tmpstr.ptr();
      length=  tmpstr.length();
4940 4941
      if (conv_errors)
        error= 1;
unknown's avatar
unknown committed
4942
    }
4943 4944
    
    copy_length= max_data_length();
4945 4946 4947 4948 4949 4950 4951 4952 4953
    /*
      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);
4954
    if (copy_length < length)
4955
      error= 1;
4956 4957
    Field_blob::store_length(copy_length);
    if (was_conversion || table->copy_blobs || copy_length <= MAX_FIELD_WIDTH)
unknown's avatar
unknown committed
4958
    {						// Must make a copy
unknown's avatar
unknown committed
4959 4960
      if (from != value.ptr())			// For valgrind
      {
4961
	value.copy(from,copy_length,charset());
unknown's avatar
unknown committed
4962
	from=value.ptr();
unknown's avatar
unknown committed
4963
      }
unknown's avatar
unknown committed
4964 4965 4966
    }
    bmove(ptr+packlength,(char*) &from,sizeof(char*));
  }
4967 4968
  if (error)
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
4969
  return 0;
unknown's avatar
unknown committed
4970 4971 4972
}


unknown's avatar
unknown committed
4973
int Field_blob::store(double nr)
unknown's avatar
unknown committed
4974
{
4975 4976 4977
  CHARSET_INFO *cs=charset();
  value.set(nr, 2, cs);
  return Field_blob::store(value.ptr(),(uint) value.length(), cs);
unknown's avatar
unknown committed
4978 4979 4980
}


unknown's avatar
unknown committed
4981
int Field_blob::store(longlong nr)
unknown's avatar
unknown committed
4982
{
4983 4984 4985
  CHARSET_INFO *cs=charset();
  value.set(nr, cs);
  return Field_blob::store(value.ptr(), (uint) value.length(), cs);
unknown's avatar
unknown committed
4986 4987 4988 4989 4990
}


double Field_blob::val_real(void)
{
4991
  int not_used;
unknown's avatar
unknown committed
4992 4993 4994 4995
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
    return 0.0;
unknown's avatar
unknown committed
4996
  uint32 length=get_length(ptr);
unknown's avatar
unknown committed
4997
  CHARSET_INFO *cs=charset();
4998
  return my_strntod(cs,blob,length,(char**)0, &not_used);
unknown's avatar
unknown committed
4999 5000 5001 5002 5003
}


longlong Field_blob::val_int(void)
{
5004
  int not_used;
unknown's avatar
unknown committed
5005 5006 5007 5008
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
    return 0;
unknown's avatar
unknown committed
5009
  uint32 length=get_length(ptr);
5010
  return my_strntoll(charset(),blob,length,10,NULL,&not_used);
unknown's avatar
unknown committed
5011 5012 5013 5014 5015 5016 5017 5018 5019
}


String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
			    String *val_ptr)
{
  char *blob;
  memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
  if (!blob)
5020
    val_ptr->set("",0,charset());	// A bit safer than ->length(0)
unknown's avatar
unknown committed
5021
  else
5022
    val_ptr->set((const char*) blob,get_length(ptr),charset());
unknown's avatar
unknown committed
5023 5024 5025 5026
  return val_ptr;
}


unknown's avatar
unknown committed
5027 5028
int Field_blob::cmp(const char *a,uint32 a_length, const char *b,
		    uint32 b_length)
unknown's avatar
unknown committed
5029
{
5030 5031 5032 5033
  return field_charset->coll->strnncoll(field_charset, 
                                        (const uchar*)a, a_length,
                                        (const uchar*)b, b_length,
                                        0);
unknown's avatar
unknown committed
5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059
}


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
5060
			   uint32 max_length)
unknown's avatar
unknown committed
5061 5062 5063
{
  char *a,*b;
  uint diff;
unknown's avatar
unknown committed
5064
  uint32 a_length,b_length;
unknown's avatar
unknown committed
5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079
  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 */

5080
void Field_blob::get_key_image(char *buff,uint length,
5081
			       CHARSET_INFO *cs, imagetype type)
unknown's avatar
unknown committed
5082
{
unknown's avatar
unknown committed
5083
  uint32 blob_length= get_length(ptr);
unknown's avatar
unknown committed
5084
  char *blob;
unknown's avatar
unknown committed
5085

unknown's avatar
unknown committed
5086
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
5087
  if (type == itMBR)
unknown's avatar
unknown committed
5088
  {
unknown's avatar
unknown committed
5089
    const char *dummy;
unknown's avatar
unknown committed
5090
    MBR mbr;
5091 5092
    Geometry_buffer buffer;
    Geometry *gobj;
unknown's avatar
unknown committed
5093 5094 5095 5096 5097 5098 5099

    if (blob_length < SRID_SIZE)
    {
      bzero(buff, SIZEOF_STORED_DOUBLE*4);
      return;
    }
    get_ptr(&blob);
5100 5101 5102
    gobj= Geometry::create_from_wkb(&buffer,
				    blob + SRID_SIZE, blob_length - SRID_SIZE);
    if (gobj->get_mbr(&mbr, &dummy))
unknown's avatar
unknown committed
5103 5104 5105 5106 5107 5108 5109 5110
      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
5111 5112
    return;
  }
unknown's avatar
unknown committed
5113
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
5114

5115 5116
  get_ptr(&blob);
  uint char_length= length / cs->mbmaxlen;
5117 5118
  char_length= my_charpos(cs, blob, blob + blob_length, char_length);
  set_if_smaller(blob_length, char_length);
5119

unknown's avatar
unknown committed
5120
  if ((uint32) length > blob_length)
unknown's avatar
unknown committed
5121
  {
5122 5123 5124 5125
    /*
      Must clear this as we do a memcmp in opt_range.cc to detect
      identical keys
    */
5126
    bzero(buff+HA_KEY_BLOB_LENGTH+blob_length, (length-blob_length));
unknown's avatar
unknown committed
5127
    length=(uint) blob_length;
unknown's avatar
unknown committed
5128
  }
unknown's avatar
unknown committed
5129
  int2store(buff,length);
5130
  memcpy(buff+HA_KEY_BLOB_LENGTH, blob, length);
unknown's avatar
unknown committed
5131 5132
}

unknown's avatar
unknown committed
5133
void Field_blob::set_key_image(char *buff,uint length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
5134
{
5135 5136
  length= uint2korr(buff);
  (void) Field_blob::store(buff+HA_KEY_BLOB_LENGTH, length, cs);
unknown's avatar
unknown committed
5137 5138
}

unknown's avatar
unknown committed
5139

unknown's avatar
unknown committed
5140 5141 5142 5143 5144
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*));
5145 5146 5147 5148
  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
5149
  return Field_blob::cmp(blob1,min(blob_length, max_key_length),
5150 5151
			 (char*) key_ptr+HA_KEY_BLOB_LENGTH,
			 uint2korr(key_ptr));
unknown's avatar
unknown committed
5152 5153 5154 5155
}

int Field_blob::key_cmp(const byte *a,const byte *b)
{
5156 5157
  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
5158 5159 5160 5161 5162 5163 5164
}


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

unknown's avatar
unknown committed
5166 5167 5168 5169 5170
  if (!blob_length)
    bzero(to,length);
  else
  {
    memcpy_fixed(&blob,ptr+packlength,sizeof(char*));
unknown's avatar
unknown committed
5171 5172
    
    blob_length=my_strnxfrm(field_charset,
5173 5174
                            (uchar*) to, length, 
                            (uchar*) blob, blob_length);
5175
    if (blob_length < length)
5176 5177 5178
      field_charset->cset->fill(field_charset, to+blob_length,
				length-blob_length,
				binary() ? (char) 0 : ' ');
unknown's avatar
unknown committed
5179 5180 5181 5182 5183 5184 5185
  }
}


void Field_blob::sql_type(String &res) const
{
  const char *str;
5186
  uint length;
unknown's avatar
unknown committed
5187
  switch (packlength) {
5188 5189 5190 5191 5192
  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;
  }
5193
  res.set_ascii(str,length);
5194
  if (charset() == &my_charset_bin)
5195 5196 5197 5198
    res.append("blob");
  else
  {
    res.append("text");
unknown's avatar
unknown committed
5199 5200 5201 5202
  }
}


5203 5204 5205 5206
char *Field_blob::pack(char *to, const char *from, uint max_length)
{
  char *save=ptr;
  ptr=(char*) from;
unknown's avatar
unknown committed
5207
  uint32 length=get_length();			// Length of from string
5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229
  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
5230
  uint32 length=get_length(from);
5231 5232 5233 5234 5235 5236 5237 5238
  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
5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254
/* 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
5255
  return my_strnncoll(field_charset,
5256 5257
		     (const uchar*) a, a_length,
		     (const uchar*) b, b_length);
unknown's avatar
unknown committed
5258 5259
}

5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277

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
5278
  return my_strnncoll(field_charset,
5279 5280
		     (const uchar*) a, a_length,
		     (const uchar*) b, b_length);
5281 5282
}

5283
/* Create a packed key that will be used for storage from a MySQL row */
5284

unknown's avatar
unknown committed
5285 5286
char *Field_blob::pack_key(char *to, const char *from, uint max_length)
{
5287 5288
  char *save=ptr;
  ptr=(char*) from;
unknown's avatar
unknown committed
5289
  uint32 length=get_length();			// Length of from string
5290 5291 5292 5293 5294 5295 5296
  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);
5297 5298 5299
  *to++= (uchar) length;
  if (max_length > 255)				// 2 byte length
    *to++= (uchar) (length >> 8);
5300
  memcpy(to, from, length);
5301 5302 5303 5304
  ptr=save;					// Restore org row pointer
  return to+length;
}

5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348

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

5349 5350 5351 5352 5353 5354
/* 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
5355 5356
  if (length > max_length)
    length=max_length;
unknown's avatar
unknown committed
5357
  *to++= (char) (length & 255);
unknown's avatar
unknown committed
5358
  if (max_length > 255)
unknown's avatar
unknown committed
5359
    *to++= (char) (length >> 8);
unknown's avatar
unknown committed
5360
  if (length)
5361
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
unknown's avatar
unknown committed
5362 5363 5364
  return to+length;
}

5365
uint Field_blob::packed_col_length(const char *data_ptr, uint length)
5366 5367
{
  if (length > 255)
5368
    return uint2korr(data_ptr)+2;
5369
  else
5370
    return (uint) ((uchar) *data_ptr)+1;
5371 5372 5373 5374 5375 5376
}

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

unknown's avatar
unknown committed
5378

unknown's avatar
unknown committed
5379
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
5380 5381 5382 5383 5384

void Field_geom::get_key_image(char *buff, uint length, CHARSET_INFO *cs,
			       imagetype type)
{
  char *blob;
unknown's avatar
unknown committed
5385
  const char *dummy;
unknown's avatar
unknown committed
5386
  MBR mbr;
5387 5388 5389
  ulong blob_length= get_length(ptr);
  Geometry_buffer buffer;
  Geometry *gobj;
unknown's avatar
unknown committed
5390 5391 5392 5393 5394 5395 5396

  if (blob_length < SRID_SIZE)
  {
    bzero(buff, SIZEOF_STORED_DOUBLE*4);
    return;
  }
  get_ptr(&blob);
5397 5398 5399
  gobj= Geometry::create_from_wkb(&buffer,
				  blob + SRID_SIZE, blob_length - SRID_SIZE);
  if (gobj->get_mbr(&mbr, &dummy))
unknown's avatar
unknown committed
5400 5401 5402 5403 5404 5405 5406 5407
    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
5408 5409 5410 5411 5412 5413 5414 5415 5416 5417
}


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
5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444
  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
5445 5446 5447 5448 5449 5450 5451 5452 5453
}


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
5454 5455 5456 5457 5458
    // 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);
5459
    if (wkb_type < (uint32) Geometry::wkb_point ||
unknown's avatar
unknown committed
5460
	wkb_type > (uint32) Geometry::wkb_end)
unknown's avatar
unknown committed
5461
      return -1;
unknown's avatar
unknown committed
5462 5463 5464 5465 5466 5467 5468 5469 5470
    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
5471 5472 5473

err:
  bzero(ptr, Field_blob::pack_length());  
unknown's avatar
unknown committed
5474
  return -1;
unknown's avatar
unknown committed
5475 5476
}

unknown's avatar
unknown committed
5477
#endif /*HAVE_SPATIAL*/
unknown's avatar
unknown committed
5478

unknown's avatar
unknown committed
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 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538
/****************************************************************************
** 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
5539
int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5540
{
5541
  int err= 0;
unknown's avatar
unknown committed
5542
  uint32 not_used;
unknown's avatar
unknown committed
5543 5544
  char buff[80];
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
5545

unknown's avatar
unknown committed
5546
  /* Convert character set if nesessary */
unknown's avatar
unknown committed
5547
  if (String::needs_conversion(length, cs, field_charset, &not_used))
unknown's avatar
unknown committed
5548
  { 
5549 5550
    uint dummy_errors;
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
unknown's avatar
unknown committed
5551 5552 5553
    from= tmpstr.ptr();
    length=  tmpstr.length();
  }
5554 5555 5556 5557

  /* Remove end space */
  while (length > 0 && my_isspace(system_charset_info,from[length-1]))
    length--;
5558
  uint tmp=find_type2(typelib, from, length, field_charset);
unknown's avatar
unknown committed
5559
  if (!tmp)
unknown's avatar
unknown committed
5560
  {
5561
    if (length < 6) // Can't be more than 99999 enums
unknown's avatar
unknown committed
5562
    {
unknown's avatar
unknown committed
5563
      /* This is for reading numbers with LOAD DATA INFILE */
5564
      char *end;
5565 5566
      tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
      if (err || end != from+length || tmp > typelib->count)
unknown's avatar
unknown committed
5567 5568
      {
	tmp=0;
5569
	set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5570
      }
unknown's avatar
unknown committed
5571 5572
    }
    else
5573
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5574
  }
unknown's avatar
unknown committed
5575
  store_type((ulonglong) tmp);
5576
  return err;
unknown's avatar
unknown committed
5577 5578 5579
}


unknown's avatar
unknown committed
5580
int Field_enum::store(double nr)
unknown's avatar
unknown committed
5581
{
5582
  return Field_enum::store((longlong) nr);
unknown's avatar
unknown committed
5583 5584 5585
}


unknown's avatar
unknown committed
5586
int Field_enum::store(longlong nr)
unknown's avatar
unknown committed
5587
{
unknown's avatar
unknown committed
5588
  int error= 0;
unknown's avatar
unknown committed
5589 5590
  if ((uint) nr > typelib->count || nr == 0)
  {
5591
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5592
    nr=0;
5593
    error=1;
unknown's avatar
unknown committed
5594 5595
  }
  store_type((ulonglong) (uint) nr);
5596
  return error;
unknown's avatar
unknown committed
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 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655
}


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
5656
    val_ptr->set("", 0, field_charset);
unknown's avatar
unknown committed
5657 5658
  else
    val_ptr->set((const char*) typelib->type_names[tmp-1],
5659
		 (uint) strlen(typelib->type_names[tmp-1]),
5660
		 field_charset);
unknown's avatar
unknown committed
5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688
  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
{
5689 5690 5691
  char buffer[255];
  String enum_item(buffer, sizeof(buffer), res.charset());

unknown's avatar
unknown committed
5692 5693 5694 5695
  res.length(0);
  res.append("enum(");

  bool flag=0;
5696
  for (const char **pos= typelib->type_names; *pos; pos++)
unknown's avatar
unknown committed
5697
  {
5698
    uint dummy_errors;
unknown's avatar
unknown committed
5699 5700
    if (flag)
      res.append(',');
5701
    /* convert to res.charset() == utf8, then quote */
5702
    enum_item.copy(*pos, strlen(*pos), charset(), res.charset(), &dummy_errors);
5703 5704
    append_unescaped(&res, enum_item.ptr(), enum_item.length());
    flag= 1;
unknown's avatar
unknown committed
5705 5706 5707 5708 5709
  }
  res.append(')');
}


5710 5711 5712 5713 5714 5715 5716 5717
/*
   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
5718 5719


unknown's avatar
unknown committed
5720
int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
unknown's avatar
unknown committed
5721
{
unknown's avatar
unknown committed
5722
  bool got_warning= 0;
5723
  int err= 0;
5724 5725
  char *not_used;
  uint not_used2;
unknown's avatar
unknown committed
5726
  uint32 not_used_offset;
unknown's avatar
unknown committed
5727 5728
  char buff[80];
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
unknown's avatar
unknown committed
5729

unknown's avatar
unknown committed
5730
  /* Convert character set if nesessary */
unknown's avatar
unknown committed
5731
  if (String::needs_conversion(length, cs, field_charset, &not_used_offset))
unknown's avatar
unknown committed
5732
  { 
5733 5734
    uint dummy_errors;
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
unknown's avatar
unknown committed
5735 5736 5737
    from= tmpstr.ptr();
    length=  tmpstr.length();
  }
5738 5739
  ulonglong tmp= find_set(typelib, from, length, field_charset,
                          &not_used, &not_used2, &got_warning);
unknown's avatar
unknown committed
5740 5741 5742
  if (!tmp && length && length < 22)
  {
    /* This is for reading numbers with LOAD DATA INFILE */
5743
    char *end;
5744 5745
    tmp=my_strntoull(cs,from,length,10,&end,&err);
    if (err || end != from+length ||
unknown's avatar
unknown committed
5746
	tmp > (ulonglong) (((longlong) 1 << typelib->count) - (longlong) 1))
5747
    {
5748
      tmp=0;      
5749
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
5750
    }
unknown's avatar
unknown committed
5751
  }
unknown's avatar
unknown committed
5752
  else if (got_warning)
5753
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
unknown's avatar
unknown committed
5754
  store_type(tmp);
5755
  return err;
unknown's avatar
unknown committed
5756 5757 5758
}


unknown's avatar
unknown committed
5759
int Field_set::store(longlong nr)
unknown's avatar
unknown committed
5760
{
unknown's avatar
unknown committed
5761
  int error= 0;
unknown's avatar
unknown committed
5762 5763 5764
  if ((ulonglong) nr > (ulonglong) (((longlong) 1 << typelib->count) -
				    (longlong) 1))
  {
5765
    nr&= (longlong) (((longlong) 1 << typelib->count) - (longlong) 1);    
5766
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
5767
    error=1;
unknown's avatar
unknown committed
5768 5769
  }
  store_type((ulonglong) nr);
5770
  return error;
unknown's avatar
unknown committed
5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787
}


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],
5788
		 (uint) strlen(typelib->type_names[bitnr]),
5789
		 field_charset);
unknown's avatar
unknown committed
5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800
      val_buffer->append(str);
    }
    tmp>>=1;
    bitnr++;
  }
  return val_buffer;
}


void Field_set::sql_type(String &res) const
{
5801 5802 5803
  char buffer[255];
  String set_item(buffer, sizeof(buffer), res.charset());

unknown's avatar
unknown committed
5804 5805 5806 5807
  res.length(0);
  res.append("set(");

  bool flag=0;
5808
  for (const char **pos= typelib->type_names; *pos; pos++)
unknown's avatar
unknown committed
5809
  {
5810
    uint dummy_errors;
unknown's avatar
unknown committed
5811 5812
    if (flag)
      res.append(',');
5813
    /* convert to res.charset() == utf8, then quote */
5814
    set_item.copy(*pos, strlen(*pos), charset(), res.charset(), &dummy_errors);
5815 5816
    append_unescaped(&res, set_item.ptr(), set_item.length());
    flag= 1;
unknown's avatar
unknown committed
5817 5818 5819 5820 5821 5822 5823 5824
  }
  res.append(')');
}

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

bool Field::eq_def(Field *field)
{
5825
  if (real_type() != field->real_type() || charset() != field->charset() ||
unknown's avatar
unknown committed
5826 5827 5828 5829 5830 5831 5832 5833 5834 5835
      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
5836

unknown's avatar
unknown committed
5837 5838 5839
  if (typelib->count < from_lib->count)
    return 0;
  for (uint i=0 ; i < from_lib->count ; i++)
5840 5841 5842 5843 5844
    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
5845 5846 5847 5848 5849
      return 0;
  return 1;
}

bool Field_num::eq_def(Field *field)
unknown's avatar
unknown committed
5850
{
unknown's avatar
unknown committed
5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866
  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
*****************************************************************************/

5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880
void create_field::create_length_to_internal_length(void)
{
  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;
unknown's avatar
unknown committed
5881 5882 5883 5884
    case MYSQL_TYPE_ENUM:
    case MYSQL_TYPE_SET:
      length*= charset->mbmaxlen;
      break;
5885 5886 5887 5888 5889 5890
    default:
      /* do nothing */
      break;
  }
}

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

uint32 calc_pack_length(enum_field_types type,uint32 length)
{
  switch (type) {
  case FIELD_TYPE_STRING:
  case FIELD_TYPE_DECIMAL: return (length);
5900
  case FIELD_TYPE_VAR_STRING: return (length+HA_KEY_BLOB_LENGTH);
unknown's avatar
unknown committed
5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915
  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
5916
  case FIELD_TYPE_BLOB:		return 2+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
5917 5918
  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
5919
  case FIELD_TYPE_GEOMETRY:	return 4+portable_sizeof_char_ptr;
unknown's avatar
unknown committed
5920 5921
  case FIELD_TYPE_SET:
  case FIELD_TYPE_ENUM: abort(); return 0;	// This shouldn't happen
unknown's avatar
unknown committed
5922
  default: return 0;
unknown's avatar
unknown committed
5923
  }
unknown's avatar
unknown committed
5924
  return 0;					// Keep compiler happy
unknown's avatar
unknown committed
5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941
}


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
5942
		  uchar *null_pos, uchar null_bit,
unknown's avatar
unknown committed
5943
		  uint pack_flag,
5944
		  enum_field_types field_type,
5945
		  CHARSET_INFO *field_charset,
unknown's avatar
unknown committed
5946
		  Field::geometry_type geom_type,
unknown's avatar
unknown committed
5947 5948 5949 5950 5951 5952 5953 5954 5955 5956
		  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
5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968

  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
5969 5970 5971
  if (f_is_alpha(pack_flag))
  {
    if (!f_is_packed(pack_flag))
unknown's avatar
unknown committed
5972 5973 5974 5975 5976 5977 5978 5979
    {
      if (field_type == FIELD_TYPE_STRING ||
          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
5980 5981 5982 5983 5984

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

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

6008
  switch (field_type) {
unknown's avatar
unknown committed
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 6052
  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:
6053 6054 6055
    return new Field_timestamp(ptr,field_length, null_pos, null_bit,
                               unireg_check, field_name, table,
                               field_charset);
unknown's avatar
unknown committed
6056 6057 6058 6059 6060
  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,
6061
			  unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
6062 6063
  case FIELD_TYPE_NEWDATE:
    return new Field_newdate(ptr,null_pos,null_bit,
6064
			     unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
6065 6066
  case FIELD_TYPE_TIME:
    return new Field_time(ptr,null_pos,null_bit,
6067
			  unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
6068 6069
  case FIELD_TYPE_DATETIME:
    return new Field_datetime(ptr,null_pos,null_bit,
6070
			      unireg_check, field_name, table, field_charset);
unknown's avatar
unknown committed
6071
  case FIELD_TYPE_NULL:
6072
    return new Field_null(ptr,field_length,unireg_check,field_name,table, field_charset);
6073 6074
  default:					// Impossible (Wrong version)
    break;
unknown's avatar
unknown committed
6075
  }
unknown's avatar
unknown committed
6076
  return 0;
unknown's avatar
unknown committed
6077 6078 6079 6080 6081
}


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

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

  /* 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);
6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108

  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;
      }
6109
      length=(length+charset->mbmaxlen-1)/charset->mbmaxlen; // QQ: Probably not needed
6110 6111 6112
      break;
    case FIELD_TYPE_STRING:
    case FIELD_TYPE_VAR_STRING:
6113
      length=(length+charset->mbmaxlen-1)/charset->mbmaxlen;
6114 6115 6116 6117
      break;
    default:
      break;
  }
6118

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

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


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

/*
  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)
6180
{
6181
  THD *thd= table->in_use;
unknown's avatar
unknown committed
6182 6183
  if (thd->count_cuted_fields)
  {
6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196
    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
unknown's avatar
unknown committed
6197
    set_datime_warning()
6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214
      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)
{
unknown's avatar
unknown committed
6215 6216 6217 6218
  if (table->in_use->really_abort_on_warning() ||
      set_warning(level, code, cuted_increment))
    make_truncated_value_warning(table->in_use, str, str_length, ts_type,
                                 field_name);
6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242
}


/*
  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)
{
unknown's avatar
unknown committed
6243 6244
  if (table->in_use->really_abort_on_warning() ||
      set_warning(level, code, cuted_increment))
6245 6246 6247 6248
  {
    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, 
unknown's avatar
unknown committed
6249
                                 ts_type, field_name);
6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272
  }
}


/*
  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)
{
unknown's avatar
unknown committed
6273 6274
  if (table->in_use->really_abort_on_warning() ||
      set_warning(level, code, 1))
6275 6276 6277 6278
  {
    /* DBL_DIG is enough to print '-[digits].E+###' */
    char str_nr[DBL_DIG + 8];
    uint str_len= my_sprintf(str_nr, (str_nr, "%g", nr));
unknown's avatar
unknown committed
6279 6280
    make_truncated_value_warning(table->in_use, str_nr, str_len, ts_type,
                                 field_name);
unknown's avatar
unknown committed
6281
  }
6282
}
unknown's avatar
unknown committed
6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303

/*
  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:
6304
    return (uint32) 4294967295U;
unknown's avatar
unknown committed
6305 6306 6307 6308 6309
  default:
    DBUG_ASSERT(0); // we should never go here
    return 0;
  }
}