field.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:179k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /*****************************************************************************
  14. ** This file implements classes defined in field.h
  15. *****************************************************************************/
  16. #ifdef USE_PRAGMA_IMPLEMENTATION
  17. #pragma implementation // gcc: Class implementation
  18. #endif
  19. #include "mysql_priv.h"
  20. #include "sql_select.h"
  21. #include <m_ctype.h>
  22. #include <errno.h>
  23. #ifdef HAVE_FCONVERT
  24. #include <floatingpoint.h>
  25. #endif
  26. // Maximum allowed exponent value for converting string to decimal
  27. #define MAX_EXPONENT 1024
  28. /*****************************************************************************
  29.   Instansiate templates and static variables
  30. *****************************************************************************/
  31. #ifdef __GNUC__
  32. template class List<create_field>;
  33. template class List_iterator<create_field>;
  34. #endif
  35. uchar Field_null::null[1]={1};
  36. const char field_separator=',';
  37. #define DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE 320
  38. #define BLOB_PACK_LENGTH_TO_MAX_LENGH(arg) 
  39. ((ulong) ((LL(1) << min(arg, 4) * 8) - LL(1)))
  40. /*
  41.   Rules for merging different types of fields in UNION
  42.   NOTE: to avoid 256*256 table, gap in table types numeration is skiped
  43.   following #defines describe that gap and how to canculate number of fields
  44.   and index of field in thia array.
  45. */
  46. #define FIELDTYPE_TEAR_FROM (MYSQL_TYPE_NEWDATE+1)
  47. #define FIELDTYPE_TEAR_TO   (MYSQL_TYPE_ENUM-1)
  48. #define FIELDTYPE_NUM (FIELDTYPE_TEAR_FROM + (255-FIELDTYPE_TEAR_TO))
  49. inline int field_type2index (enum_field_types field_type)
  50. {
  51.   return (field_type < FIELDTYPE_TEAR_FROM ?
  52.           field_type :
  53.           ((int)FIELDTYPE_TEAR_FROM) + (field_type - FIELDTYPE_TEAR_TO) - 1);
  54. }
  55. static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
  56. {
  57.   /* MYSQL_TYPE_DECIMAL -> */
  58.   {
  59.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  60.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_DECIMAL,
  61.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  62.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_DECIMAL,
  63.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  64.     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  65.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  66.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_VAR_STRING,
  67.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  68.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_DECIMAL,
  69.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  70.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  71.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  72.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  73.   //MYSQL_TYPE_NEWDATE      <14>
  74.     MYSQL_TYPE_VAR_STRING,
  75.   //<246>                   MYSQL_TYPE_ENUM
  76.                             MYSQL_TYPE_VAR_STRING,
  77.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  78.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  79.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  80.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  81.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  82.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  83.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  84.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  85.   },
  86.   /* MYSQL_TYPE_TINY -> */
  87.   {
  88.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  89.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_TINY,
  90.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  91.     MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
  92.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  93.     MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  94.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  95.     MYSQL_TYPE_TINY,        MYSQL_TYPE_VAR_STRING,
  96.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  97.     MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
  98.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  99.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  100.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  101.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY,
  102.   //MYSQL_TYPE_NEWDATE      <14>
  103.     MYSQL_TYPE_VAR_STRING,
  104.   //<246>                   MYSQL_TYPE_ENUM
  105.                             MYSQL_TYPE_VAR_STRING,
  106.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  107.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  108.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  109.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  110.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  111.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  112.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  113.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  114.   },
  115.   /* MYSQL_TYPE_SHORT -> */
  116.   {
  117.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  118.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_SHORT,
  119.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  120.     MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
  121.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  122.     MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  123.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  124.     MYSQL_TYPE_SHORT,       MYSQL_TYPE_VAR_STRING,
  125.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  126.     MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
  127.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  128.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  129.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  130.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_SHORT,
  131.   //MYSQL_TYPE_NEWDATE      <14>
  132.     MYSQL_TYPE_VAR_STRING,
  133.   //<246>                   MYSQL_TYPE_ENUM
  134.                             MYSQL_TYPE_VAR_STRING,
  135.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  136.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  137.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  138.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  139.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  140.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  141.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  142.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  143.   },
  144.   /* MYSQL_TYPE_LONG -> */
  145.   {
  146.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  147.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_LONG,
  148.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  149.     MYSQL_TYPE_LONG,        MYSQL_TYPE_LONG,
  150.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  151.     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  152.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  153.     MYSQL_TYPE_LONG,        MYSQL_TYPE_VAR_STRING,
  154.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  155.     MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_LONG,
  156.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  157.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  158.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  159.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_LONG,
  160.   //MYSQL_TYPE_NEWDATE      <14>
  161.     MYSQL_TYPE_VAR_STRING,
  162.   //<246>                   MYSQL_TYPE_ENUM
  163.                             MYSQL_TYPE_VAR_STRING,
  164.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  165.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  166.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  167.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  168.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  169.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  170.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  171.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  172.   },
  173.   /* MYSQL_TYPE_FLOAT -> */
  174.   {
  175.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  176.     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_FLOAT,
  177.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  178.     MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  179.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  180.     MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  181.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  182.     MYSQL_TYPE_FLOAT,       MYSQL_TYPE_VAR_STRING,
  183.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  184.     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_FLOAT,
  185.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  186.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  187.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  188.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_FLOAT,
  189.   //MYSQL_TYPE_NEWDATE      <14>
  190.     MYSQL_TYPE_VAR_STRING,
  191.   //<246>                   MYSQL_TYPE_ENUM
  192.                             MYSQL_TYPE_VAR_STRING,
  193.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  194.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  195.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  196.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  197.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  198.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  199.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  200.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  201.   },
  202.   /* MYSQL_TYPE_DOUBLE -> */
  203.   {
  204.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  205.     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  206.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  207.     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  208.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  209.     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  210.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  211.     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_VAR_STRING,
  212.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  213.     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  214.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  215.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  216.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  217.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_DOUBLE,
  218.   //MYSQL_TYPE_NEWDATE      <14>
  219.     MYSQL_TYPE_VAR_STRING,
  220.   //<246>                   MYSQL_TYPE_ENUM
  221.                             MYSQL_TYPE_VAR_STRING,
  222.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  223.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  224.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  225.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  226.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  227.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  228.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  229.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  230.   },
  231.   /* MYSQL_TYPE_NULL -> */
  232.   {
  233.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  234.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_TINY,
  235.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  236.     MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
  237.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  238.     MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  239.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  240.     MYSQL_TYPE_NULL,        MYSQL_TYPE_TIMESTAMP,
  241.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  242.     MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
  243.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  244.     MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_TIME,
  245.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  246.     MYSQL_TYPE_DATETIME,    MYSQL_TYPE_YEAR,
  247.   //MYSQL_TYPE_NEWDATE      <14>
  248.     MYSQL_TYPE_NEWDATE,
  249.   //<246>                   MYSQL_TYPE_ENUM
  250.                             MYSQL_TYPE_ENUM,
  251.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  252.     MYSQL_TYPE_SET,         MYSQL_TYPE_TINY_BLOB,
  253.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  254.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  255.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  256.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  257.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  258.     MYSQL_TYPE_STRING,      MYSQL_TYPE_GEOMETRY
  259.   },
  260.   /* MYSQL_TYPE_TIMESTAMP -> */
  261.   {
  262.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  263.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  264.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  265.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  266.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  267.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  268.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  269.     MYSQL_TYPE_TIMESTAMP,   MYSQL_TYPE_TIMESTAMP,
  270.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  271.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  272.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  273.     MYSQL_TYPE_DATETIME,    MYSQL_TYPE_DATETIME,
  274.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  275.     MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VAR_STRING,
  276.   //MYSQL_TYPE_NEWDATE      <14>
  277.     MYSQL_TYPE_DATETIME,
  278.   //<246>                   MYSQL_TYPE_ENUM
  279.                             MYSQL_TYPE_VAR_STRING,
  280.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  281.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  282.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  283.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  284.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  285.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  286.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  287.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  288.   },
  289.   /* MYSQL_TYPE_LONGLONG -> */
  290.   {
  291.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  292.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_LONGLONG,
  293.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  294.     MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_LONGLONG,
  295.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  296.     MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
  297.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  298.     MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_VAR_STRING,
  299.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  300.     MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_LONG,
  301.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  302.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  303.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  304.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_LONGLONG,
  305.   //MYSQL_TYPE_NEWDATE      <14>
  306.     MYSQL_TYPE_VAR_STRING,
  307.   //<246>                   MYSQL_TYPE_ENUM
  308.                             MYSQL_TYPE_VAR_STRING,
  309.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  310.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  311.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  312.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  313.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  314.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  315.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  316.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  317.   },
  318.   /* MYSQL_TYPE_INT24 -> */
  319.   {
  320.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  321.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_INT24,
  322.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  323.     MYSQL_TYPE_INT24,       MYSQL_TYPE_LONG,
  324.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  325.     MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  326.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  327.     MYSQL_TYPE_INT24,       MYSQL_TYPE_VAR_STRING,
  328.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  329.     MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
  330.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  331.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  332.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  333.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_INT24,
  334.   //MYSQL_TYPE_NEWDATE      <14>
  335.     MYSQL_TYPE_VAR_STRING,
  336.   //<246>                   MYSQL_TYPE_ENUM
  337.                             MYSQL_TYPE_VAR_STRING,
  338.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  339.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  340.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  341.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  342.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  343.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  344.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  345.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  346.   },
  347.   /* MYSQL_TYPE_DATE -> */
  348.   {
  349.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  350.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  351.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  352.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  353.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  354.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  355.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  356.     MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
  357.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  358.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  359.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  360.     MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
  361.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  362.     MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VAR_STRING,
  363.   //MYSQL_TYPE_NEWDATE      <14>
  364.     MYSQL_TYPE_NEWDATE,
  365.   //<246>                   MYSQL_TYPE_ENUM
  366.                             MYSQL_TYPE_VAR_STRING,
  367.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  368.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  369.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  370.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  371.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  372.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  373.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  374.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  375.   },
  376.   /* MYSQL_TYPE_TIME -> */
  377.   {
  378.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  379.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  380.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  381.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  382.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  383.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  384.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  385.     MYSQL_TYPE_TIME,        MYSQL_TYPE_DATETIME,
  386.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  387.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  388.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  389.     MYSQL_TYPE_DATETIME,    MYSQL_TYPE_TIME,
  390.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  391.     MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VAR_STRING,
  392.   //MYSQL_TYPE_NEWDATE      <14>
  393.     MYSQL_TYPE_DATETIME,
  394.   //<246>                   MYSQL_TYPE_ENUM
  395.                             MYSQL_TYPE_VAR_STRING,
  396.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  397.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  398.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  399.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  400.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  401.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  402.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  403.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  404.   },
  405.   /* MYSQL_TYPE_DATETIME -> */
  406.   {
  407.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  408.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  409.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  410.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  411.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  412.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  413.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  414.     MYSQL_TYPE_DATETIME,    MYSQL_TYPE_DATETIME,
  415.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  416.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  417.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  418.     MYSQL_TYPE_DATETIME,    MYSQL_TYPE_DATETIME,
  419.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  420.     MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VAR_STRING,
  421.   //MYSQL_TYPE_NEWDATE      <14>
  422.     MYSQL_TYPE_DATETIME,
  423.   //<246>                   MYSQL_TYPE_ENUM
  424.                             MYSQL_TYPE_VAR_STRING,
  425.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  426.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  427.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  428.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  429.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  430.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  431.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  432.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  433.   },
  434.   /* MYSQL_TYPE_YEAR -> */
  435.   {
  436.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  437.     MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_TINY,
  438.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  439.     MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
  440.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  441.     MYSQL_TYPE_FLOAT,       MYSQL_TYPE_DOUBLE,
  442.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  443.     MYSQL_TYPE_YEAR,        MYSQL_TYPE_VAR_STRING,
  444.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  445.     MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_INT24,
  446.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  447.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  448.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  449.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_YEAR,
  450.   //MYSQL_TYPE_NEWDATE      <14>
  451.     MYSQL_TYPE_VAR_STRING,
  452.   //<246>                   MYSQL_TYPE_ENUM
  453.                             MYSQL_TYPE_VAR_STRING,
  454.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  455.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  456.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  457.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  458.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  459.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  460.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  461.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  462.   },
  463.   /* MYSQL_TYPE_NEWDATE -> */
  464.   {
  465.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  466.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  467.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  468.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  469.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  470.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  471.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  472.     MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
  473.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  474.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  475.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  476.     MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
  477.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  478.     MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VAR_STRING,
  479.   //MYSQL_TYPE_NEWDATE      <14>
  480.     MYSQL_TYPE_NEWDATE,
  481.   //<246>                   MYSQL_TYPE_ENUM
  482.                             MYSQL_TYPE_VAR_STRING,
  483.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  484.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  485.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  486.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  487.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  488.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  489.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  490.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  491.   },
  492.   /* MYSQL_TYPE_ENUM -> */
  493.   {
  494.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  495.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  496.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  497.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  498.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  499.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  500.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  501.     MYSQL_TYPE_ENUM,        MYSQL_TYPE_VAR_STRING,
  502.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  503.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  504.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  505.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  506.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  507.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  508.   //MYSQL_TYPE_NEWDATE      <14>
  509.     MYSQL_TYPE_VAR_STRING,
  510.   //<246>                   MYSQL_TYPE_ENUM
  511.                             MYSQL_TYPE_VAR_STRING,
  512.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  513.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  514.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  515.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  516.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  517.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  518.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  519.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  520.   },
  521.   /* MYSQL_TYPE_SET -> */
  522.   {
  523.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  524.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  525.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  526.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  527.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  528.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  529.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  530.     MYSQL_TYPE_SET,         MYSQL_TYPE_VAR_STRING,
  531.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  532.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  533.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  534.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  535.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  536.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  537.   //MYSQL_TYPE_NEWDATE      <14>
  538.     MYSQL_TYPE_VAR_STRING,
  539.   //<246>                   MYSQL_TYPE_ENUM
  540.                             MYSQL_TYPE_VAR_STRING,
  541.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  542.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  543.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  544.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  545.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  546.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  547.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  548.     MYSQL_TYPE_STRING,      MYSQL_TYPE_VAR_STRING
  549.   },
  550.   /* MYSQL_TYPE_TINY_BLOB -> */
  551.   {
  552.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  553.     MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  554.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  555.     MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  556.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  557.     MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  558.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  559.     MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  560.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  561.     MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  562.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  563.     MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  564.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  565.     MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  566.   //MYSQL_TYPE_NEWDATE      <14>
  567.     MYSQL_TYPE_TINY_BLOB,
  568.   //<246>                   MYSQL_TYPE_ENUM
  569.                             MYSQL_TYPE_TINY_BLOB,
  570.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  571.     MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB,
  572.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  573.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  574.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  575.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_TINY_BLOB,
  576.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  577.     MYSQL_TYPE_TINY_BLOB,   MYSQL_TYPE_TINY_BLOB
  578.   },
  579.   /* MYSQL_TYPE_MEDIUM_BLOB -> */
  580.   {
  581.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  582.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  583.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  584.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  585.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  586.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  587.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  588.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  589.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  590.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  591.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  592.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  593.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  594.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  595.   //MYSQL_TYPE_NEWDATE      <14>
  596.     MYSQL_TYPE_MEDIUM_BLOB,
  597.   //<246>                   MYSQL_TYPE_ENUM
  598.                             MYSQL_TYPE_MEDIUM_BLOB,
  599.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  600.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  601.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  602.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  603.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  604.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB,
  605.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  606.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_MEDIUM_BLOB
  607.   },
  608.   /* MYSQL_TYPE_LONG_BLOB -> */
  609.   {
  610.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  611.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  612.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  613.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  614.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  615.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  616.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  617.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  618.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  619.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  620.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  621.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  622.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  623.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  624.   //MYSQL_TYPE_NEWDATE      <14>
  625.     MYSQL_TYPE_LONG_BLOB,
  626.   //<246>                   MYSQL_TYPE_ENUM
  627.                             MYSQL_TYPE_LONG_BLOB,
  628.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  629.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  630.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  631.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  632.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  633.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB,
  634.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  635.     MYSQL_TYPE_LONG_BLOB,   MYSQL_TYPE_LONG_BLOB
  636.   },
  637.   /* MYSQL_TYPE_BLOB -> */
  638.   {
  639.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  640.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  641.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  642.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  643.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  644.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  645.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  646.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  647.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  648.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  649.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  650.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  651.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  652.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  653.   //MYSQL_TYPE_NEWDATE      <14>
  654.     MYSQL_TYPE_BLOB,
  655.   //<246>                   MYSQL_TYPE_ENUM
  656.                             MYSQL_TYPE_BLOB,
  657.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  658.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  659.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  660.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  661.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  662.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
  663.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  664.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB
  665.   },
  666.   /* MYSQL_TYPE_VAR_STRING -> */
  667.   {
  668.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  669.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  670.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  671.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  672.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  673.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  674.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  675.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  676.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  677.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  678.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  679.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  680.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  681.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  682.   //MYSQL_TYPE_NEWDATE      <14>
  683.     MYSQL_TYPE_VAR_STRING,
  684.   //<246>                   MYSQL_TYPE_ENUM
  685.                             MYSQL_TYPE_VAR_STRING,
  686.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  687.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  688.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  689.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  690.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  691.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  692.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  693.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING
  694.   },
  695.   /* MYSQL_TYPE_STRING -> */
  696.   {
  697.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  698.     MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  699.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  700.     MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  701.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  702.     MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  703.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  704.     MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  705.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  706.     MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  707.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  708.     MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  709.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  710.     MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
  711.   //MYSQL_TYPE_NEWDATE      <14>
  712.     MYSQL_TYPE_STRING,
  713.   //<246>                   MYSQL_TYPE_ENUM
  714.                             MYSQL_TYPE_STRING,
  715.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  716.     MYSQL_TYPE_STRING,      MYSQL_TYPE_TINY_BLOB,
  717.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  718.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  719.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  720.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  721.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  722.     MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING
  723.   },
  724.   /* MYSQL_TYPE_GEOMETRY -> */
  725.   {
  726.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  727.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  728.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  729.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  730.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  731.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  732.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  733.     MYSQL_TYPE_GEOMETRY,    MYSQL_TYPE_VAR_STRING,
  734.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  735.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  736.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  737.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  738.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  739.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_VAR_STRING,
  740.   //MYSQL_TYPE_NEWDATE      <14>
  741.     MYSQL_TYPE_VAR_STRING,
  742.   //<246>                   MYSQL_TYPE_ENUM
  743.                             MYSQL_TYPE_VAR_STRING,
  744.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  745.     MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_TINY_BLOB,
  746.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  747.     MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB,
  748.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  749.     MYSQL_TYPE_BLOB,        MYSQL_TYPE_VAR_STRING,
  750.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  751.     MYSQL_TYPE_STRING,      MYSQL_TYPE_GEOMETRY
  752.   }
  753. };
  754. /*
  755.   Return type of which can carry value of both given types in UNION result
  756.   SYNOPSIS
  757.     Field::field_type_merge()
  758.     a, b  types for merging
  759.   RETURN
  760.     type of field
  761. */
  762. enum_field_types Field::field_type_merge(enum_field_types a,
  763.                                          enum_field_types b)
  764. {
  765.   DBUG_ASSERT(a < FIELDTYPE_TEAR_FROM || a > FIELDTYPE_TEAR_TO);
  766.   DBUG_ASSERT(b < FIELDTYPE_TEAR_FROM || b > FIELDTYPE_TEAR_TO);
  767.   return field_types_merge_rules[field_type2index(a)]
  768.                                 [field_type2index(b)];
  769. }
  770. static Item_result field_types_result_type [FIELDTYPE_NUM]=
  771. {
  772.   //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
  773.   REAL_RESULT,              INT_RESULT,
  774.   //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
  775.   INT_RESULT,               INT_RESULT,
  776.   //MYSQL_TYPE_FLOAT        MYSQL_TYPE_DOUBLE
  777.   REAL_RESULT,              REAL_RESULT,
  778.   //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
  779.   STRING_RESULT,            STRING_RESULT,
  780.   //MYSQL_TYPE_LONGLONG     MYSQL_TYPE_INT24
  781.   INT_RESULT,               INT_RESULT,
  782.   //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
  783.   STRING_RESULT,            STRING_RESULT,
  784.   //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
  785.   STRING_RESULT,            INT_RESULT,
  786.   //MYSQL_TYPE_NEWDATE      <14>
  787.   STRING_RESULT,
  788.   //<246>                   MYSQL_TYPE_ENUM
  789.                             STRING_RESULT,
  790.   //MYSQL_TYPE_SET          MYSQL_TYPE_TINY_BLOB
  791.   STRING_RESULT,            STRING_RESULT,
  792.   //MYSQL_TYPE_MEDIUM_BLOB  MYSQL_TYPE_LONG_BLOB
  793.   STRING_RESULT,            STRING_RESULT,
  794.   //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
  795.   STRING_RESULT,            STRING_RESULT,
  796.   //MYSQL_TYPE_STRING       MYSQL_TYPE_GEOMETRY
  797.   STRING_RESULT,            STRING_RESULT
  798. };
  799. /*
  800.   Detect Item_result by given field type of UNION merge result
  801.   SYNOPSIS
  802.     Field::result_merge_type()
  803.     field_type  given field type
  804.   RETURN
  805.     Item_result (type of internal MySQL expression result)
  806. */
  807. Item_result Field::result_merge_type(enum_field_types field_type)
  808. {
  809.   DBUG_ASSERT(field_type < FIELDTYPE_TEAR_FROM || field_type
  810.               > FIELDTYPE_TEAR_TO);
  811.   return field_types_result_type[field_type2index(field_type)];
  812. }
  813. /*****************************************************************************
  814.   Static help functions
  815. *****************************************************************************/
  816. void Field_num::prepend_zeros(String *value)
  817. {
  818.   int diff;
  819.   if ((diff= (int) (field_length - value->length())) > 0)
  820.   {
  821.     bmove_upp((char*) value->ptr()+field_length,value->ptr()+value->length(),
  822.       value->length());
  823.     bfill((char*) value->ptr(),diff,'0');
  824.     value->length(field_length);
  825.     (void) value->c_ptr_quick(); // Avoid warnings in purify
  826.   }
  827. }
  828. /*
  829.   Test if given number is a int (or a fixed format float with .000)
  830.   SYNOPSIS
  831.     test_if_int()
  832.     str String to test
  833.     end Pointer to char after last used digit
  834.     cs Character set
  835.   NOTES
  836.     This is called after one has called my_strntol() or similar function.
  837.     This is only used to give warnings in ALTER TABLE or LOAD DATA...
  838.   TODO
  839.     Make this multi-byte-character safe
  840.   RETURN
  841.     0 ok
  842.     1 error
  843. */
  844. bool test_if_int(const char *str, int length, const char *int_end,
  845.  CHARSET_INFO *cs)
  846. {
  847.   if (str == int_end)
  848.     return 0; // Empty string
  849.   const char *end=str+length;
  850.   if ((str= int_end) == end)
  851.     return 1; // All digits was used
  852.   /* Allow end .0000 */
  853.   if (*str == '.')
  854.   {
  855.     for (str++ ; str != end && *str == '0'; str++) ;
  856.   }
  857.   /* Allow end space */
  858.   for (str++ ; str != end ; str++)
  859.   {
  860.     if (!my_isspace(cs,*str))
  861.       return 0;
  862.   }
  863.   return 1;
  864. }
  865. #ifdef NOT_USED
  866. static bool test_if_real(const char *str,int length, CHARSET_INFO *cs)
  867. {
  868.   cs= system_charset_info; // QQ move test_if_real into CHARSET_INFO struct
  869.   while (length && my_isspace(cs,*str))
  870.   { // Allow start space
  871.     length--; str++;
  872.   }
  873.   if (!length)
  874.     return 0;
  875.   if (*str == '+' || *str == '-')
  876.   {
  877.     length--; str++;
  878.     if (!length || !(my_isdigit(cs,*str) || *str == '.'))
  879.       return 0;
  880.   }
  881.   while (length && my_isdigit(cs,*str))
  882.   {
  883.     length--; str++;
  884.   }
  885.   if (!length)
  886.     return 1;
  887.   if (*str == '.')
  888.   {
  889.     length--; str++;
  890.     while (length && my_isdigit(cs,*str))
  891.     {
  892.       length--; str++;
  893.     }
  894.   }
  895.   if (!length)
  896.     return 1;
  897.   if (*str == 'E' || *str == 'e')
  898.   {
  899.     if (length < 3 || (str[1] != '+' && str[1] != '-') || 
  900.         !my_isdigit(cs,str[2]))
  901.       return 0;
  902.     length-=3;
  903.     str+=3;
  904.     while (length && my_isdigit(cs,*str))
  905.     {
  906.       length--; str++;
  907.     }
  908.   }
  909.   for (; length ; length--, str++)
  910.   { // Allow end space
  911.     if (!my_isspace(cs,*str))
  912.       return 0;
  913.   }
  914.   return 1;
  915. }
  916. #endif
  917. /****************************************************************************
  918. ** Functions for the base classes
  919. ** This is an unpacked number.
  920. ****************************************************************************/
  921. Field::Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
  922.      uchar null_bit_arg,
  923.      utype unireg_check_arg, const char *field_name_arg,
  924.      struct st_table *table_arg)
  925.   :ptr(ptr_arg),null_ptr(null_ptr_arg),
  926.    table(table_arg),orig_table(table_arg),
  927.    table_name(table_arg ? table_arg->table_name : 0),
  928.    field_name(field_name_arg),
  929.    query_id(0), key_start(0), part_of_key(0), part_of_sortkey(0),
  930.    unireg_check(unireg_check_arg),
  931.    field_length(length_arg),null_bit(null_bit_arg)
  932. {
  933.   flags=null_ptr ? 0: NOT_NULL_FLAG;
  934.   comment.str= (char*) "";
  935.   comment.length=0;
  936. }
  937. uint Field::offset()
  938. {
  939.   return (uint) (ptr - (char*) table->record[0]);
  940. }
  941. void Field::copy_from_tmp(int row_offset)
  942. {
  943.   memcpy(ptr,ptr+row_offset,pack_length());
  944.   if (null_ptr)
  945.   {
  946.     *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) |
  947. null_ptr[row_offset] & (uchar) null_bit);
  948.   }
  949. }
  950. bool Field::send_binary(Protocol *protocol)
  951. {
  952.   char buff[MAX_FIELD_WIDTH];
  953.   String tmp(buff,sizeof(buff),charset());
  954.   val_str(&tmp);
  955.   return protocol->store(tmp.ptr(), tmp.length(), tmp.charset());
  956. }
  957. void Field_num::add_zerofill_and_unsigned(String &res) const
  958. {
  959.   if (unsigned_flag)
  960.     res.append(" unsigned");
  961.   if (zerofill)
  962.     res.append(" zerofill");
  963. }
  964. void Field_num::make_field(Send_field *field)
  965. {
  966.   /* table_cache_key is not set for temp tables */
  967.   if (orig_table->table_cache_key)
  968.   {
  969.     field->db_name= orig_table->table_cache_key;
  970.     field->org_table_name= orig_table->real_name;
  971.   }
  972.   else
  973.   {
  974.     field->db_name= field->org_table_name= "";
  975.   }
  976.   field->table_name= orig_table->table_name;
  977.   field->col_name=field->org_col_name=field_name;
  978.   field->charsetnr= charset()->number;
  979.   field->length=field_length;
  980.   field->type=type();
  981.   field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
  982.   field->decimals=dec;
  983. }
  984. void Field_str::make_field(Send_field *field)
  985. {
  986.   /* table_cache_key is not set for temp tables */
  987.   if (orig_table->table_cache_key)
  988.   {
  989.     field->db_name= orig_table->table_cache_key;
  990.     field->org_table_name= orig_table->real_name;
  991.   }
  992.   else
  993.   {
  994.     field->db_name= field->org_table_name= "";
  995.   }
  996.   field->table_name= orig_table->table_name;
  997.   field->col_name=field->org_col_name=field_name;
  998.   field->charsetnr= charset()->number;
  999.   field->length=field_length;
  1000.   field->type=type();
  1001.   field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
  1002.   field->decimals=0;
  1003. }
  1004. uint Field::fill_cache_field(CACHE_FIELD *copy)
  1005. {
  1006.   uint store_length;
  1007.   copy->str=ptr;
  1008.   copy->length=pack_length();
  1009.   copy->blob_field=0;
  1010.   if (flags & BLOB_FLAG)
  1011.   {
  1012.     copy->blob_field=(Field_blob*) this;
  1013.     copy->strip=0;
  1014.     copy->length-=table->blob_ptr_size;
  1015.     return copy->length;
  1016.   }
  1017.   else if (!zero_pack() && (type() == FIELD_TYPE_STRING && copy->length > 4 ||
  1018.     type() == FIELD_TYPE_VAR_STRING))
  1019.   {
  1020.     copy->strip=1; /* Remove end space */
  1021.     store_length= 2;
  1022.   }
  1023.   else
  1024.   {
  1025.     copy->strip=0;
  1026.     store_length= 0;
  1027.   }
  1028.   return copy->length+ store_length;
  1029. }
  1030. bool Field::get_date(TIME *ltime,uint fuzzydate)
  1031. {
  1032.   char buff[40];
  1033.   String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  1034.   if (!(res=val_str(&tmp)) ||
  1035.       str_to_datetime_with_warn(res->ptr(), res->length(),
  1036.                                 ltime, fuzzydate) <= MYSQL_TIMESTAMP_ERROR)
  1037.     return 1;
  1038.   return 0;
  1039. }
  1040. bool Field::get_time(TIME *ltime)
  1041. {
  1042.   char buff[40];
  1043.   String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  1044.   if (!(res=val_str(&tmp)) ||
  1045.       str_to_time_with_warn(res->ptr(), res->length(), ltime))
  1046.     return 1;
  1047.   return 0;
  1048. }
  1049. /*
  1050.   This is called when storing a date in a string
  1051.   NOTES
  1052.     Needs to be changed if/when we want to support different time formats
  1053. */
  1054. void Field::store_time(TIME *ltime,timestamp_type type)
  1055. {
  1056.   char buff[MAX_DATE_STRING_REP_LENGTH];
  1057.   uint length= (uint) my_TIME_to_str(ltime, buff);
  1058.   store(buff, length, &my_charset_bin);
  1059. }
  1060. bool Field::optimize_range(uint idx, uint part)
  1061. {
  1062.   return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
  1063. }
  1064. /****************************************************************************
  1065.   Field_null, a field that always return NULL
  1066. ****************************************************************************/
  1067. void Field_null::sql_type(String &res) const
  1068. {
  1069.   res.set_ascii("null", 4);
  1070. }
  1071. /****************************************************************************
  1072.   Functions for the Field_decimal class
  1073.   This is an number stored as a pre-space (or pre-zero) string
  1074. ****************************************************************************/
  1075. void
  1076. Field_decimal::reset(void)
  1077. {
  1078.   Field_decimal::store("0",1,&my_charset_bin);
  1079. }
  1080. void Field_decimal::overflow(bool negative)
  1081. {
  1082.   uint len=field_length;
  1083.   char *to=ptr, filler= '9';
  1084.   set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1085.   if (negative)
  1086.   {
  1087.     if (!unsigned_flag)
  1088.     {
  1089.       /* Put - sign as a first digit so we'll have -999..999 or 999..999 */
  1090.       *to++ = '-';
  1091.       len--;
  1092.     }
  1093.     else
  1094.     {
  1095.       filler= '0'; // Fill up with 0
  1096.       if (!zerofill)
  1097.       {
  1098. /*
  1099.   Handle unsigned integer without zerofill, in which case
  1100.   the number should be of format '   0' or '   0.000'
  1101. */
  1102. uint whole_part=field_length- (dec ? dec+2 : 1);
  1103. // Fill with spaces up to the first digit
  1104. bfill(to, whole_part, ' ');
  1105. to+=  whole_part;
  1106. len-= whole_part;
  1107. // The main code will also handle the 0 before the decimal point
  1108.       }
  1109.     }
  1110.   }
  1111.   bfill(to, len, filler);
  1112.   if (dec)
  1113.     ptr[field_length-dec-1]='.';
  1114.   return;
  1115. }
  1116. int Field_decimal::store(const char *from, uint len, CHARSET_INFO *cs)
  1117. {
  1118.   char buff[80];
  1119.   String tmp(buff,sizeof(buff), &my_charset_bin);
  1120.   /* Convert character set if the old one is multi byte */
  1121.   if (cs->mbmaxlen > 1)
  1122.   { 
  1123.     uint dummy_errors;
  1124.     tmp.copy(from, len, cs, &my_charset_bin, &dummy_errors);
  1125.     from= tmp.ptr();
  1126.     len=  tmp.length();
  1127.   }
  1128.   const char *end= from+len;
  1129.   /* The pointer where the field value starts (i.e., "where to write") */
  1130.   char *to=ptr;
  1131.   uint tmp_dec, tmp_uint;
  1132.   /*
  1133.     The sign of the number : will be 0 (means positive but sign not
  1134.     specified), '+' or '-'
  1135.   */
  1136.   char sign_char=0;
  1137.   /* The pointers where prezeros start and stop */
  1138.   const char *pre_zeros_from, *pre_zeros_end;
  1139.   /* The pointers where digits at the left of '.' start and stop */
  1140.   const char *int_digits_from, *int_digits_end;
  1141.   /* The pointers where digits at the right of '.' start and stop */
  1142.   const char *frac_digits_from, *frac_digits_end;
  1143.   /* The sign of the exponent : will be 0 (means no exponent), '+' or '-' */
  1144.   char expo_sign_char=0;
  1145.   uint exponent=0;                                // value of the exponent
  1146.   /*
  1147.     Pointers used when digits move from the left of the '.' to the
  1148.     right of the '.' (explained below)
  1149.   */
  1150.   const char *int_digits_tail_from;
  1151.   /* Number of 0 that need to be added at the left of the '.' (1E3: 3 zeros) */
  1152.   uint int_digits_added_zeros;
  1153.   /*
  1154.     Pointer used when digits move from the right of the '.' to the left
  1155.     of the '.'
  1156.   */
  1157.   const char *frac_digits_head_end;
  1158.   /* Number of 0 that need to be added at the right of the '.' (for 1E-3) */
  1159.   uint frac_digits_added_zeros;
  1160.   char *pos,*tmp_left_pos,*tmp_right_pos;
  1161.   /* Pointers that are used as limits (begin and end of the field buffer) */
  1162.   char *left_wall,*right_wall;
  1163.   char tmp_char;
  1164.   /*
  1165.     To remember if table->in_use->cuted_fields has already been incremented,
  1166.     to do that only once
  1167.   */
  1168.   bool is_cuted_fields_incr=0;
  1169.   LINT_INIT(int_digits_tail_from);
  1170.   LINT_INIT(int_digits_added_zeros);
  1171.   LINT_INIT(frac_digits_head_end);
  1172.   LINT_INIT(frac_digits_added_zeros);
  1173.   /*
  1174.     There are three steps in this function :
  1175.     - parse the input string
  1176.     - modify the position of digits around the decimal dot '.' 
  1177.       according to the exponent value (if specified)
  1178.     - write the formatted number
  1179.   */
  1180.   if ((tmp_dec=dec))
  1181.     tmp_dec++;
  1182.   /* skip pre-space */
  1183.   while (from != end && my_isspace(&my_charset_bin,*from))
  1184.     from++;
  1185.   if (from == end)
  1186.   {
  1187.     set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  1188.     is_cuted_fields_incr=1;
  1189.   }
  1190.   else if (*from == '+' || *from == '-') // Found some sign ?
  1191.   {
  1192.     sign_char= *from++;
  1193.     /*
  1194.       We allow "+" for unsigned decimal unless defined different
  1195.       Both options allowed as one may wish not to have "+" for unsigned numbers
  1196.       because of data processing issues
  1197.     */ 
  1198.     if (unsigned_flag)  
  1199.     { 
  1200.       if (sign_char=='-')
  1201.       {
  1202.         Field_decimal::overflow(1);
  1203.         return 1;
  1204.       }
  1205.       /* 
  1206.  Defining this will not store "+" for unsigned decimal type even if
  1207.  it is passed in numeric string. This will make some tests to fail
  1208.       */  
  1209. #ifdef DONT_ALLOW_UNSIGNED_PLUS      
  1210.       else 
  1211.         sign_char=0;
  1212. #endif 
  1213.     }
  1214.   }
  1215.   pre_zeros_from= from;
  1216.   for (; from!=end && *from == '0'; from++) ; // Read prezeros
  1217.   pre_zeros_end=int_digits_from=from;      
  1218.   /* Read non zero digits at the left of '.'*/
  1219.   for (; from != end && my_isdigit(&my_charset_bin, *from) ; from++) ;
  1220.   int_digits_end=from;
  1221.   if (from!=end && *from == '.') // Some '.' ?
  1222.     from++;
  1223.   frac_digits_from= from;
  1224.   /* Read digits at the right of '.' */
  1225.   for (;from!=end && my_isdigit(&my_charset_bin, *from); from++) ;
  1226.   frac_digits_end=from;
  1227.   // Some exponentiation symbol ?
  1228.   if (from != end && (*from == 'e' || *from == 'E'))
  1229.   {   
  1230.     from++;
  1231.     if (from != end && (*from == '+' || *from == '-'))  // Some exponent sign ?
  1232.       expo_sign_char= *from++;
  1233.     else
  1234.       expo_sign_char= '+';
  1235.     /*
  1236.       Read digits of the exponent and compute its value.  We must care about
  1237.       'exponent' overflow, because as unsigned arithmetic is "modulo", big 
  1238.       exponents will become small (e.g. 1e4294967296 will become 1e0, and the 
  1239.       field will finally contain 1 instead of its max possible value).
  1240.     */
  1241.     for (;from!=end && my_isdigit(&my_charset_bin, *from); from++)
  1242.     {
  1243.       exponent=10*exponent+(*from-'0');
  1244.       if (exponent>MAX_EXPONENT)
  1245.         break;
  1246.     }
  1247.   }
  1248.   
  1249.   /*
  1250.     We only have to generate warnings if count_cuted_fields is set.
  1251.     This is to avoid extra checks of the number when they are not needed.
  1252.     Even if this flag is not set, it's ok to increment warnings, if
  1253.     it makes the code easer to read.
  1254.   */
  1255.   if (table->in_use->count_cuted_fields)
  1256.   {
  1257.     // Skip end spaces
  1258.     for (;from != end && my_isspace(&my_charset_bin, *from); from++) ;
  1259.     if (from != end)                     // If still something left, warn
  1260.     {
  1261.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  1262.       is_cuted_fields_incr=1;
  1263.     }
  1264.   }
  1265.   
  1266.   /*
  1267.     Now "move" digits around the decimal dot according to the exponent value,
  1268.     and add necessary zeros.
  1269.     Examples :
  1270.     - 1E+3 : needs 3 more zeros at the left of '.' (int_digits_added_zeros=3)
  1271.     - 1E-3 : '1' moves at the right of '.', and 2 more zeros are needed
  1272.     between '.' and '1'
  1273.     - 1234.5E-3 : '234' moves at the right of '.'
  1274.     These moves are implemented with pointers which point at the begin
  1275.     and end of each moved segment. Examples :
  1276.     - 1234.5E-3 : before the code below is executed, the int_digits part is
  1277.     from '1' to '4' and the frac_digits part from '5' to '5'. After the code
  1278.     below, the int_digits part is from '1' to '1', the frac_digits_head
  1279.     part is from '2' to '4', and the frac_digits part from '5' to '5'.
  1280.     - 1234.5E3 : before the code below is executed, the int_digits part is
  1281.     from '1' to '4' and the frac_digits part from '5' to '5'. After the code
  1282.     below, the int_digits part is from '1' to '4', the int_digits_tail
  1283.     part is from '5' to '5', the frac_digits part is empty, and
  1284.     int_digits_added_zeros=2 (to make 1234500).
  1285.   */
  1286.   
  1287.   /* 
  1288.      Below tmp_uint cannot overflow with small enough MAX_EXPONENT setting,
  1289.      as int_digits_added_zeros<=exponent<4G and 
  1290.      (int_digits_end-int_digits_from)<=max_allowed_packet<=2G and
  1291.      (frac_digits_from-int_digits_tail_from)<=max_allowed_packet<=2G
  1292.   */
  1293.   if (!expo_sign_char)
  1294.     tmp_uint=tmp_dec+(uint)(int_digits_end-int_digits_from);
  1295.   else if (expo_sign_char == '-') 
  1296.   {
  1297.     tmp_uint=min(exponent,(uint)(int_digits_end-int_digits_from));
  1298.     frac_digits_added_zeros=exponent-tmp_uint;
  1299.     int_digits_end -= tmp_uint;
  1300.     frac_digits_head_end=int_digits_end+tmp_uint;
  1301.     tmp_uint=tmp_dec+(uint)(int_digits_end-int_digits_from);     
  1302.   }
  1303.   else // (expo_sign_char=='+') 
  1304.   {
  1305.     tmp_uint=min(exponent,(uint)(frac_digits_end-frac_digits_from));
  1306.     int_digits_added_zeros=exponent-tmp_uint;
  1307.     int_digits_tail_from=frac_digits_from;
  1308.     frac_digits_from=frac_digits_from+tmp_uint;
  1309.     /*
  1310.       We "eat" the heading zeros of the 
  1311.       int_digits.int_digits_tail.int_digits_added_zeros concatenation
  1312.       (for example 0.003e3 must become 3 and not 0003)
  1313.     */
  1314.     if (int_digits_from == int_digits_end) 
  1315.     {
  1316.       /*
  1317. There was nothing in the int_digits part, so continue
  1318. eating int_digits_tail zeros
  1319.       */
  1320.       for (; int_digits_tail_from != frac_digits_from &&
  1321.      *int_digits_tail_from == '0'; int_digits_tail_from++) ;
  1322.       if (int_digits_tail_from == frac_digits_from) 
  1323.       {
  1324. // there were only zeros in int_digits_tail too
  1325. int_digits_added_zeros=0;
  1326.       }
  1327.     }
  1328.     tmp_uint= (tmp_dec+(int_digits_end-int_digits_from)+
  1329.                (uint)(frac_digits_from-int_digits_tail_from)+
  1330.                int_digits_added_zeros);
  1331.   }
  1332.   
  1333.   /*
  1334.     Now write the formated number
  1335.     
  1336.     First the digits of the int_% parts.
  1337.     Do we have enough room to write these digits ?
  1338.     If the sign is defined and '-', we need one position for it
  1339.   */
  1340.   if (field_length < tmp_uint + (int) (sign_char == '-')) 
  1341.   {
  1342.     // too big number, change to max or min number
  1343.     Field_decimal::overflow(sign_char == '-');
  1344.     return 1;
  1345.   }
  1346.  
  1347.   /*
  1348.     Tmp_left_pos is the position where the leftmost digit of
  1349.     the int_% parts will be written
  1350.   */
  1351.   tmp_left_pos=pos=to+(uint)(field_length-tmp_uint);
  1352.   
  1353.   // Write all digits of the int_% parts
  1354.   while (int_digits_from != int_digits_end)
  1355.     *pos++ = *int_digits_from++ ;
  1356.   if (expo_sign_char == '+')
  1357.   {    
  1358.     while (int_digits_tail_from != frac_digits_from)
  1359.       *pos++= *int_digits_tail_from++;
  1360.     while (int_digits_added_zeros-- >0)
  1361.       *pos++= '0';  
  1362.   }
  1363.   /*
  1364.     Note the position where the rightmost digit of the int_% parts has been
  1365.     written (this is to later check if the int_% parts contained nothing,
  1366.     meaning an extra 0 is needed).
  1367.   */
  1368.   tmp_right_pos=pos;
  1369.   /*
  1370.     Step back to the position of the leftmost digit of the int_% parts,
  1371.     to write sign and fill with zeros or blanks or prezeros.
  1372.   */
  1373.   pos=tmp_left_pos-1;
  1374.   if (zerofill)
  1375.   {
  1376.     left_wall=to-1;
  1377.     while (pos > left_wall) // Fill with zeros
  1378.       *pos--='0';
  1379.   }
  1380.   else
  1381.   {
  1382.     left_wall=to+(sign_char != 0)-1;
  1383.     if (!expo_sign_char) // If exponent was specified, ignore prezeros
  1384.     {
  1385.       for (;pos > left_wall && pre_zeros_from !=pre_zeros_end;
  1386.    pre_zeros_from++)
  1387. *pos--= '0';
  1388.     }
  1389.     if (pos == tmp_right_pos-1)
  1390.       *pos--= '0'; // no 0 has ever been written, so write one
  1391.     left_wall= to-1;
  1392.     if (sign_char && pos != left_wall)
  1393.     {
  1394.       /* Write sign if possible (it is if sign is '-') */
  1395.       *pos--= sign_char;
  1396.     }
  1397.     while (pos != left_wall)
  1398.       *pos--=' ';  //fill with blanks
  1399.   }
  1400.   
  1401.   /*
  1402.     Write digits of the frac_% parts ;
  1403.     Depending on table->in_use->count_cutted_fields, we may also want
  1404.     to know if some non-zero tail of these parts will
  1405.     be truncated (for example, 0.002->0.00 will generate a warning,
  1406.     while 0.000->0.00 will not)
  1407.     (and 0E1000000000 will not, while 1E-1000000000 will)
  1408.   */
  1409.       
  1410.   pos=to+(uint)(field_length-tmp_dec); // Calculate post to '.'
  1411.   right_wall=to+field_length;
  1412.   if (pos != right_wall) 
  1413.     *pos++='.';
  1414.   if (expo_sign_char == '-')
  1415.   {
  1416.     while (frac_digits_added_zeros-- > 0)
  1417.     {
  1418.       if (pos == right_wall) 
  1419.       {
  1420.         if (table->in_use->count_cuted_fields && !is_cuted_fields_incr) 
  1421.           break; // Go on below to see if we lose non zero digits
  1422.         return 0;
  1423.       }
  1424.       *pos++='0';
  1425.     }
  1426.     while (int_digits_end != frac_digits_head_end)
  1427.     {
  1428.       tmp_char= *int_digits_end++;
  1429.       if (pos == right_wall)
  1430.       {
  1431.         if (tmp_char != '0') // Losing a non zero digit ?
  1432.         {
  1433.           if (!is_cuted_fields_incr)
  1434.             set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, 
  1435.                         ER_WARN_DATA_TRUNCATED, 1);
  1436.           return 0;
  1437.         }
  1438.         continue;
  1439.       }
  1440.       *pos++= tmp_char;
  1441.     }
  1442.   }
  1443.   for (;frac_digits_from!=frac_digits_end;) 
  1444.   {
  1445.     tmp_char= *frac_digits_from++;
  1446.     if (pos == right_wall)
  1447.     {
  1448.       if (tmp_char != '0') // Losing a non zero digit ?
  1449.       {
  1450.         if (!is_cuted_fields_incr)
  1451.   set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  1452.         return 0;
  1453.       }
  1454.       continue;
  1455.     }
  1456.     *pos++= tmp_char;
  1457.   }
  1458.       
  1459.   while (pos != right_wall)
  1460.    *pos++='0'; // Fill with zeros at right of '.'
  1461.   return 0;
  1462. }
  1463. int Field_decimal::store(double nr)
  1464. {
  1465.   if (unsigned_flag && nr < 0)
  1466.   {
  1467.     overflow(1);
  1468.     return 1;
  1469.   }
  1470.   
  1471. #ifdef HAVE_FINITE
  1472.   if (!finite(nr)) // Handle infinity as special case
  1473.   {
  1474.     overflow(nr < 0.0);
  1475.     return 1;
  1476.   }
  1477. #endif
  1478.   reg4 uint i,length;
  1479.   char fyllchar,*to;
  1480.   char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
  1481.   fyllchar = zerofill ? (char) '0' : (char) ' ';
  1482. #ifdef HAVE_SNPRINTF
  1483.   buff[sizeof(buff)-1]=0; // Safety
  1484.   snprintf(buff,sizeof(buff)-1, "%.*f",(int) dec,nr);
  1485.   length=(uint) strlen(buff);
  1486. #else
  1487.   length=(uint) my_sprintf(buff,(buff,"%.*f",dec,nr));
  1488. #endif
  1489.   if (length > field_length)
  1490.   {
  1491.     overflow(nr < 0.0);
  1492.     return 1;
  1493.   }
  1494.   else
  1495.   {
  1496.     to=ptr;
  1497.     for (i=field_length-length ; i-- > 0 ;)
  1498.       *to++ = fyllchar;
  1499.     memcpy(to,buff,length);
  1500.     return 0;
  1501.   }
  1502. }
  1503. int Field_decimal::store(longlong nr)
  1504. {
  1505.   if (unsigned_flag && nr < 0)
  1506.   {
  1507.     overflow(1);
  1508.     return 1;
  1509.   }
  1510.   char buff[22];
  1511.   uint length=(uint) (longlong10_to_str(nr,buff,-10)-buff);
  1512.   uint int_part=field_length- (dec  ? dec+1 : 0);
  1513.   if (length > int_part)
  1514.   {
  1515.     overflow(test(nr < 0L)); /* purecov: inspected */
  1516.     return 1;
  1517.   }
  1518.   else
  1519.   {
  1520.     char fyllchar = zerofill ? (char) '0' : (char) ' ';
  1521.     char *to=ptr;
  1522.     for (uint i=int_part-length ; i-- > 0 ;)
  1523.       *to++ = fyllchar;
  1524.     memcpy(to,buff,length);
  1525.     if (dec)
  1526.     {
  1527.       to[length]='.';
  1528.       bfill(to+length+1,dec,'0');
  1529.     }
  1530.     return 0;
  1531.   }
  1532. }
  1533. double Field_decimal::val_real(void)
  1534. {
  1535.   int not_used;
  1536.   char *end_not_used;
  1537.   return my_strntod(&my_charset_bin, ptr, field_length, &end_not_used,
  1538.                     &not_used);
  1539. }
  1540. longlong Field_decimal::val_int(void)
  1541. {
  1542.   int not_used;
  1543.   if (unsigned_flag)
  1544.     return my_strntoull(&my_charset_bin, ptr, field_length, 10, NULL,
  1545. &not_used);
  1546.   else
  1547.     return my_strntoll(&my_charset_bin, ptr, field_length, 10, NULL,
  1548. &not_used);
  1549. }
  1550. String *Field_decimal::val_str(String *val_buffer __attribute__((unused)),
  1551.        String *val_ptr)
  1552. {
  1553.   char *str;
  1554.   for (str=ptr ; *str == ' ' ; str++) ;
  1555.   uint tmp_length=(uint) (str-ptr);
  1556.   val_ptr->set_charset(&my_charset_bin);
  1557.   if (field_length < tmp_length) // Error in data
  1558.     val_ptr->length(0);
  1559.   else
  1560.     val_ptr->set_ascii((const char*) str, field_length-tmp_length);
  1561.   return val_ptr;
  1562. }
  1563. /*
  1564. ** Should be able to handle at least the following fixed decimal formats:
  1565. ** 5.00 , -1.0,  05,  -05, +5 with optional pre/end space
  1566. */
  1567. int Field_decimal::cmp(const char *a_ptr,const char *b_ptr)
  1568. {
  1569.   const char *end;
  1570.   int swap=0;
  1571.   /* First remove prefixes '0', ' ', and '-' */
  1572.   for (end=a_ptr+field_length;
  1573.        a_ptr != end &&
  1574.  (*a_ptr == *b_ptr ||
  1575.   ((my_isspace(&my_charset_bin,*a_ptr)  || *a_ptr == '+' || 
  1576.             *a_ptr == '0') &&
  1577.    (my_isspace(&my_charset_bin,*b_ptr) || *b_ptr == '+' || 
  1578.             *b_ptr == '0')));
  1579.        a_ptr++,b_ptr++)
  1580.   {
  1581.     if (*a_ptr == '-') // If both numbers are negative
  1582.       swap= -1 ^ 1; // Swap result      
  1583.   }
  1584.   if (a_ptr == end)
  1585.     return 0;
  1586.   if (*a_ptr == '-')
  1587.     return -1;
  1588.   if (*b_ptr == '-')
  1589.     return 1;
  1590.   while (a_ptr != end)
  1591.   {
  1592.     if (*a_ptr++ != *b_ptr++)
  1593.       return swap ^ (a_ptr[-1] < b_ptr[-1] ? -1 : 1); // compare digits
  1594.   }
  1595.   return 0;
  1596. }
  1597. void Field_decimal::sort_string(char *to,uint length)
  1598. {
  1599.   char *str,*end;
  1600.   for (str=ptr,end=ptr+length;
  1601.        str != end &&
  1602.  ((my_isspace(&my_charset_bin,*str) || *str == '+' ||
  1603.    *str == '0')) ;
  1604.        str++)
  1605.     *to++=' ';
  1606.   if (str == end)
  1607.     return; /* purecov: inspected */
  1608.   if (*str == '-')
  1609.   {
  1610.     *to++=1; // Smaller than any number
  1611.     str++;
  1612.     while (str != end)
  1613.       if (my_isdigit(&my_charset_bin,*str))
  1614. *to++= (char) ('9' - *str++);
  1615.       else
  1616. *to++= *str++;
  1617.   }
  1618.   else memcpy(to,str,(uint) (end-str));
  1619. }
  1620. void Field_decimal::sql_type(String &res) const
  1621. {
  1622.   CHARSET_INFO *cs=res.charset();
  1623.   uint tmp=field_length;
  1624.   if (!unsigned_flag)
  1625.     tmp--;
  1626.   if (dec)
  1627.     tmp--;
  1628.   res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
  1629.   "decimal(%d,%d)",tmp,dec));
  1630.   add_zerofill_and_unsigned(res);
  1631. }
  1632. /****************************************************************************
  1633. ** tiny int
  1634. ****************************************************************************/
  1635. int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs)
  1636. {
  1637.   int not_used; // We can ignore result from str2int
  1638.   char *end;
  1639.   long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
  1640.   int error= 0;
  1641.   if (unsigned_flag)
  1642.   {
  1643.     if (tmp < 0)
  1644.     {
  1645.       tmp=0; /* purecov: inspected */
  1646.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1647.       error= 1;
  1648.     }
  1649.     else if (tmp > 255)
  1650.     {
  1651.       tmp= 255;
  1652.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1653.       error= 1;
  1654.     }
  1655.     else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
  1656.     {
  1657.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  1658.       error= 1;
  1659.     }
  1660.   }
  1661.   else
  1662.   {
  1663.     if (tmp < -128)
  1664.     {
  1665.       tmp= -128;
  1666.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1667.       error= 1;
  1668.     }
  1669.     else if (tmp >= 128)
  1670.     {
  1671.       tmp= 127;
  1672.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1673.       error= 1;
  1674.     }
  1675.     else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
  1676.     {
  1677.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  1678.       error= 1;
  1679.     }
  1680.   }
  1681.   ptr[0]= (char) tmp;
  1682.   return error;
  1683. }
  1684. int Field_tiny::store(double nr)
  1685. {
  1686.   int error= 0;
  1687.   nr=rint(nr);
  1688.   if (unsigned_flag)
  1689.   {
  1690.     if (nr < 0.0)
  1691.     {
  1692.       *ptr=0;
  1693.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1694.       error= 1;
  1695.     }
  1696.     else if (nr > 255.0)
  1697.     {
  1698.       *ptr=(char) 255;
  1699.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1700.       error= 1;
  1701.     }
  1702.     else
  1703.       *ptr=(char) nr;
  1704.   }
  1705.   else
  1706.   {
  1707.     if (nr < -128.0)
  1708.     {
  1709.       *ptr= (char) -128;
  1710.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1711.       error= 1;
  1712.     }
  1713.     else if (nr > 127.0)
  1714.     {
  1715.       *ptr=127;
  1716.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1717.       error= 1;
  1718.     }
  1719.     else
  1720.       *ptr=(char) nr;
  1721.   }
  1722.   return error;
  1723. }
  1724. int Field_tiny::store(longlong nr)
  1725. {
  1726.   int error= 0;
  1727.   if (unsigned_flag)
  1728.   {
  1729.     if (nr < 0L)
  1730.     {
  1731.       *ptr=0;
  1732.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1733.       error= 1;
  1734.     }
  1735.     else if (nr > 255L)
  1736.     {
  1737.       *ptr= (char) 255;
  1738.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1739.       error= 1;
  1740.     }
  1741.     else
  1742.       *ptr=(char) nr;
  1743.   }
  1744.   else
  1745.   {
  1746.     if (nr < -128L)
  1747.     {
  1748.       *ptr= (char) -128;
  1749.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1750.       error= 1;
  1751.     }
  1752.     else if (nr > 127L)
  1753.     {
  1754.       *ptr=127;
  1755.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1756.       error= 1;
  1757.     }
  1758.     else
  1759.       *ptr=(char) nr;
  1760.   }
  1761.   return error;
  1762. }
  1763. double Field_tiny::val_real(void)
  1764. {
  1765.   int tmp= unsigned_flag ? (int) ((uchar*) ptr)[0] :
  1766.     (int) ((signed char*) ptr)[0];
  1767.   return (double) tmp;
  1768. }
  1769. longlong Field_tiny::val_int(void)
  1770. {
  1771.   int tmp= unsigned_flag ? (int) ((uchar*) ptr)[0] :
  1772.     (int) ((signed char*) ptr)[0];
  1773.   return (longlong) tmp;
  1774. }
  1775. String *Field_tiny::val_str(String *val_buffer,
  1776.     String *val_ptr __attribute__((unused)))
  1777. {
  1778.   CHARSET_INFO *cs= &my_charset_bin;
  1779.   uint length;
  1780.   uint mlength=max(field_length+1,5*cs->mbmaxlen);
  1781.   val_buffer->alloc(mlength);
  1782.   char *to=(char*) val_buffer->ptr();
  1783.   if (unsigned_flag)
  1784.     length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
  1785.    (long) *((uchar*) ptr));
  1786.   else
  1787.     length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
  1788.    (long) *((signed char*) ptr));
  1789.   
  1790.   val_buffer->length(length);
  1791.   if (zerofill)
  1792.     prepend_zeros(val_buffer);
  1793.   return val_buffer;
  1794. }
  1795. bool Field_tiny::send_binary(Protocol *protocol)
  1796. {
  1797.   return protocol->store_tiny((longlong) (int8) ptr[0]);
  1798. }
  1799. int Field_tiny::cmp(const char *a_ptr, const char *b_ptr)
  1800. {
  1801.   signed char a,b;
  1802.   a=(signed char) a_ptr[0]; b= (signed char) b_ptr[0];
  1803.   if (unsigned_flag)
  1804.     return ((uchar) a < (uchar) b) ? -1 : ((uchar) a > (uchar) b) ? 1 : 0;
  1805.   return (a < b) ? -1 : (a > b) ? 1 : 0;
  1806. }
  1807. void Field_tiny::sort_string(char *to,uint length __attribute__((unused)))
  1808. {
  1809.   if (unsigned_flag)
  1810.     *to= *ptr;
  1811.   else
  1812.     to[0] = (char) ((uchar) ptr[0] ^ (uchar) 128); /* Revers signbit */
  1813. }
  1814. void Field_tiny::sql_type(String &res) const
  1815. {
  1816.   CHARSET_INFO *cs=res.charset();
  1817.   res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
  1818.   "tinyint(%d)",(int) field_length));
  1819.   add_zerofill_and_unsigned(res);
  1820. }
  1821. /****************************************************************************
  1822.  Field type short int (2 byte)
  1823. ****************************************************************************/
  1824. int Field_short::store(const char *from,uint len,CHARSET_INFO *cs)
  1825. {
  1826.   int not_used; // We can ignore result from str2int
  1827.   char *end;
  1828.   long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
  1829.   int error= 0;
  1830.   if (unsigned_flag)
  1831.   {
  1832.     if (tmp < 0)
  1833.     {
  1834.       tmp=0;
  1835.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1836.       error= 1;
  1837.     }
  1838.     else if (tmp > (uint16) ~0)
  1839.     {
  1840.       tmp=(uint16) ~0;
  1841.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1842.       error= 1;
  1843.     }
  1844.     else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
  1845.     {
  1846.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  1847.       error= 1;
  1848.     }
  1849.   }
  1850.   else
  1851.   {
  1852.     if (tmp < INT_MIN16)
  1853.     {
  1854.       tmp= INT_MIN16;
  1855.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1856.       error= 1;
  1857.     }
  1858.     else if (tmp > INT_MAX16)
  1859.     {
  1860.       tmp=INT_MAX16;
  1861.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1862.       error= 1;
  1863.     }
  1864.     else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
  1865.     {
  1866.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  1867.       error= 1;
  1868.     }
  1869.   }
  1870. #ifdef WORDS_BIGENDIAN
  1871.   if (table->db_low_byte_first)
  1872.   {
  1873.     int2store(ptr,tmp);
  1874.   }
  1875.   else
  1876. #endif
  1877.     shortstore(ptr,(short) tmp);
  1878.   return error;
  1879. }
  1880. int Field_short::store(double nr)
  1881. {
  1882.   int error= 0;
  1883.   int16 res;
  1884.   nr=rint(nr);
  1885.   if (unsigned_flag)
  1886.   {
  1887.     if (nr < 0)
  1888.     {
  1889.       res=0;
  1890.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1891.       error= 1;
  1892.     }
  1893.     else if (nr > (double) (uint16) ~0)
  1894.     {
  1895.       res=(int16) (uint16) ~0;
  1896.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1897.       error= 1;
  1898.     }
  1899.     else
  1900.       res=(int16) (uint16) nr;
  1901.   }
  1902.   else
  1903.   {
  1904.     if (nr < (double) INT_MIN16)
  1905.     {
  1906.       res=INT_MIN16;
  1907.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1908.       error= 1;
  1909.     }
  1910.     else if (nr > (double) INT_MAX16)
  1911.     {
  1912.       res=INT_MAX16;
  1913.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1914.       error= 1;
  1915.     }
  1916.     else
  1917.       res=(int16) nr;
  1918.   }
  1919. #ifdef WORDS_BIGENDIAN
  1920.   if (table->db_low_byte_first)
  1921.   {
  1922.     int2store(ptr,res);
  1923.   }
  1924.   else
  1925. #endif
  1926.     shortstore(ptr,res);
  1927.   return error;
  1928. }
  1929. int Field_short::store(longlong nr)
  1930. {
  1931.   int error= 0;
  1932.   int16 res;
  1933.   if (unsigned_flag)
  1934.   {
  1935.     if (nr < 0L)
  1936.     {
  1937.       res=0;
  1938.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1939.       error= 1;
  1940.     }
  1941.     else if (nr > (longlong) (uint16) ~0)
  1942.     {
  1943.       res=(int16) (uint16) ~0;
  1944.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1945.       error= 1;
  1946.     }
  1947.     else
  1948.       res=(int16) (uint16) nr;
  1949.   }
  1950.   else
  1951.   {
  1952.     if (nr < INT_MIN16)
  1953.     {
  1954.       res=INT_MIN16;
  1955.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1956.       error= 1;
  1957.     }
  1958.     else if (nr > INT_MAX16)
  1959.     {
  1960.       res=INT_MAX16;
  1961.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  1962.       error= 1;
  1963.     }
  1964.     else
  1965.       res=(int16) nr;
  1966.   }
  1967. #ifdef WORDS_BIGENDIAN
  1968.   if (table->db_low_byte_first)
  1969.   {
  1970.     int2store(ptr,res);
  1971.   }
  1972.   else
  1973. #endif
  1974.     shortstore(ptr,res);
  1975.   return error;
  1976. }
  1977. double Field_short::val_real(void)
  1978. {
  1979.   short j;
  1980. #ifdef WORDS_BIGENDIAN
  1981.   if (table->db_low_byte_first)
  1982.     j=sint2korr(ptr);
  1983.   else
  1984. #endif
  1985.     shortget(j,ptr);
  1986.   return unsigned_flag ? (double) (unsigned short) j : (double) j;
  1987. }
  1988. longlong Field_short::val_int(void)
  1989. {
  1990.   short j;
  1991. #ifdef WORDS_BIGENDIAN
  1992.   if (table->db_low_byte_first)
  1993.     j=sint2korr(ptr);
  1994.   else
  1995. #endif
  1996.     shortget(j,ptr);
  1997.   return unsigned_flag ? (longlong) (unsigned short) j : (longlong) j;
  1998. }
  1999. String *Field_short::val_str(String *val_buffer,
  2000.      String *val_ptr __attribute__((unused)))
  2001. {
  2002.   CHARSET_INFO *cs= &my_charset_bin;
  2003.   uint length;
  2004.   uint mlength=max(field_length+1,7*cs->mbmaxlen);
  2005.   val_buffer->alloc(mlength);
  2006.   char *to=(char*) val_buffer->ptr();
  2007.   short j;
  2008. #ifdef WORDS_BIGENDIAN
  2009.   if (table->db_low_byte_first)
  2010.     j=sint2korr(ptr);
  2011.   else
  2012. #endif
  2013.     shortget(j,ptr);
  2014.   if (unsigned_flag)
  2015.     length=(uint) cs->cset->long10_to_str(cs, to, mlength, 10, 
  2016.   (long) (uint16) j);
  2017.   else
  2018.     length=(uint) cs->cset->long10_to_str(cs, to, mlength,-10, (long) j);
  2019.   val_buffer->length(length);
  2020.   if (zerofill)
  2021.     prepend_zeros(val_buffer);
  2022.   return val_buffer;
  2023. }
  2024. bool Field_short::send_binary(Protocol *protocol)
  2025. {
  2026.   return protocol->store_short(Field_short::val_int());
  2027. }
  2028. int Field_short::cmp(const char *a_ptr, const char *b_ptr)
  2029. {
  2030.   short a,b;
  2031. #ifdef WORDS_BIGENDIAN
  2032.   if (table->db_low_byte_first)
  2033.   {
  2034.     a=sint2korr(a_ptr);
  2035.     b=sint2korr(b_ptr);
  2036.   }
  2037.   else
  2038. #endif
  2039.   {
  2040.     shortget(a,a_ptr);
  2041.     shortget(b,b_ptr);
  2042.   }
  2043.   if (unsigned_flag)
  2044.     return ((unsigned short) a < (unsigned short) b) ? -1 :
  2045.     ((unsigned short) a > (unsigned short) b) ? 1 : 0;
  2046.   return (a < b) ? -1 : (a > b) ? 1 : 0;
  2047. }
  2048. void Field_short::sort_string(char *to,uint length __attribute__((unused)))
  2049. {
  2050. #ifdef WORDS_BIGENDIAN
  2051.   if (!table->db_low_byte_first)
  2052.   {
  2053.     if (unsigned_flag)
  2054.       to[0] = ptr[0];
  2055.     else
  2056.       to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
  2057.     to[1]   = ptr[1];
  2058.   }
  2059.   else
  2060. #endif
  2061.   {
  2062.     if (unsigned_flag)
  2063.       to[0] = ptr[1];
  2064.     else
  2065.       to[0] = (char) (ptr[1] ^ 128); /* Revers signbit */
  2066.     to[1]   = ptr[0];
  2067.   }
  2068. }
  2069. void Field_short::sql_type(String &res) const
  2070. {
  2071.   CHARSET_INFO *cs=res.charset();
  2072.   res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
  2073.   "smallint(%d)",(int) field_length));
  2074.   add_zerofill_and_unsigned(res);
  2075. }
  2076. /****************************************************************************
  2077.   Field type medium int (3 byte)
  2078. ****************************************************************************/
  2079. int Field_medium::store(const char *from,uint len,CHARSET_INFO *cs)
  2080. {
  2081.   int not_used; // We can ignore result from str2int
  2082.   char *end;
  2083.   long tmp= my_strntol(cs, from, len, 10, &end, &not_used);
  2084.   int error= 0;
  2085.   if (unsigned_flag)
  2086.   {
  2087.     if (tmp < 0)
  2088.     {
  2089.       tmp=0;
  2090.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2091.       error= 1;
  2092.     }
  2093.     else if (tmp >= (long) (1L << 24))
  2094.     {
  2095.       tmp=(long) (1L << 24)-1L;
  2096.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2097.       error= 1;
  2098.     }
  2099.     else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
  2100.     {
  2101.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  2102.       error= 1;
  2103.     }
  2104.   }
  2105.   else
  2106.   {
  2107.     if (tmp < INT_MIN24)
  2108.     {
  2109.       tmp= INT_MIN24;
  2110.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2111.       error= 1;
  2112.     }
  2113.     else if (tmp > INT_MAX24)
  2114.     {
  2115.       tmp=INT_MAX24;
  2116.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2117.       error= 1;
  2118.     }
  2119.     else if (table->in_use->count_cuted_fields && !test_if_int(from,len,end,cs))
  2120.     {
  2121.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  2122.       error= 1;
  2123.     }
  2124.   }
  2125.   int3store(ptr,tmp);
  2126.   return error;
  2127. }
  2128. int Field_medium::store(double nr)
  2129. {
  2130.   int error= 0;
  2131.   nr=rint(nr);
  2132.   if (unsigned_flag)
  2133.   {
  2134.     if (nr < 0)
  2135.     {
  2136.       int3store(ptr,0);
  2137.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2138.       error= 1;
  2139.     }
  2140.     else if (nr >= (double) (long) (1L << 24))
  2141.     {
  2142.       uint32 tmp=(uint32) (1L << 24)-1L;
  2143.       int3store(ptr,tmp);
  2144.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2145.       error= 1;
  2146.     }
  2147.     else
  2148.       int3store(ptr,(uint32) nr);
  2149.   }
  2150.   else
  2151.   {
  2152.     if (nr < (double) INT_MIN24)
  2153.     {
  2154.       long tmp=(long) INT_MIN24;
  2155.       int3store(ptr,tmp);
  2156.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2157.       error= 1;
  2158.     }
  2159.     else if (nr > (double) INT_MAX24)
  2160.     {
  2161.       long tmp=(long) INT_MAX24;
  2162.       int3store(ptr,tmp);
  2163.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2164.       error= 1;
  2165.     }
  2166.     else
  2167.       int3store(ptr,(long) nr);
  2168.   }
  2169.   return error;
  2170. }
  2171. int Field_medium::store(longlong nr)
  2172. {
  2173.   int error= 0;
  2174.   if (unsigned_flag)
  2175.   {
  2176.     if (nr < 0L)
  2177.     {
  2178.       int3store(ptr,0);
  2179.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2180.       error= 1;
  2181.     }
  2182.     else if (nr >= (longlong) (long) (1L << 24))
  2183.     {
  2184.       long tmp=(long) (1L << 24)-1L;;
  2185.       int3store(ptr,tmp);
  2186.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2187.       error= 1;
  2188.     }
  2189.     else
  2190.       int3store(ptr,(uint32) nr);
  2191.   }
  2192.   else
  2193.   {
  2194.     if (nr < (longlong) INT_MIN24)
  2195.     {
  2196.       long tmp=(long) INT_MIN24;
  2197.       int3store(ptr,tmp);
  2198.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2199.       error= 1;
  2200.     }
  2201.     else if (nr > (longlong) INT_MAX24)
  2202.     {
  2203.       long tmp=(long) INT_MAX24;
  2204.       int3store(ptr,tmp);
  2205.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2206.       error= 1;
  2207.     }
  2208.     else
  2209.       int3store(ptr,(long) nr);
  2210.   }
  2211.   return error;
  2212. }
  2213. double Field_medium::val_real(void)
  2214. {
  2215.   long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
  2216.   return (double) j;
  2217. }
  2218. longlong Field_medium::val_int(void)
  2219. {
  2220.   long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
  2221.   return (longlong) j;
  2222. }
  2223. String *Field_medium::val_str(String *val_buffer,
  2224.       String *val_ptr __attribute__((unused)))
  2225. {
  2226.   CHARSET_INFO *cs= &my_charset_bin;
  2227.   uint length;
  2228.   uint mlength=max(field_length+1,10*cs->mbmaxlen);
  2229.   val_buffer->alloc(mlength);
  2230.   char *to=(char*) val_buffer->ptr();
  2231.   long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
  2232.   length=(uint) cs->cset->long10_to_str(cs,to,mlength,-10,j);
  2233.   val_buffer->length(length);
  2234.   if (zerofill)
  2235.     prepend_zeros(val_buffer); /* purecov: inspected */
  2236.   return val_buffer;
  2237. }
  2238. bool Field_medium::send_binary(Protocol *protocol)
  2239. {
  2240.   return protocol->store_long(Field_medium::val_int());
  2241. }
  2242. int Field_medium::cmp(const char *a_ptr, const char *b_ptr)
  2243. {
  2244.   long a,b;
  2245.   if (unsigned_flag)
  2246.   {
  2247.     a=uint3korr(a_ptr);
  2248.     b=uint3korr(b_ptr);
  2249.   }
  2250.   else
  2251.   {
  2252.     a=sint3korr(a_ptr);
  2253.     b=sint3korr(b_ptr);
  2254.   }
  2255.   return (a < b) ? -1 : (a > b) ? 1 : 0;
  2256. }
  2257. void Field_medium::sort_string(char *to,uint length __attribute__((unused)))
  2258. {
  2259.   if (unsigned_flag)
  2260.     to[0] = ptr[2];
  2261.   else
  2262.     to[0] = (uchar) (ptr[2] ^ 128); /* Revers signbit */
  2263.   to[1] = ptr[1];
  2264.   to[2] = ptr[0];
  2265. }
  2266. void Field_medium::sql_type(String &res) const
  2267. {
  2268.   CHARSET_INFO *cs=res.charset();
  2269.   res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(), 
  2270.   "mediumint(%d)",(int) field_length));
  2271.   add_zerofill_and_unsigned(res);
  2272. }
  2273. /****************************************************************************
  2274. ** long int
  2275. ****************************************************************************/
  2276. /*
  2277.   A helper function to check whether the next character
  2278.   in the string "s" is MINUS SIGN. 
  2279. */
  2280. #ifdef HAVE_CHARSET_ucs2
  2281. static bool test_if_minus(CHARSET_INFO *cs,
  2282.                           const char *s, const char *e)
  2283. {
  2284.   my_wc_t wc;
  2285.   return cs->cset->mb_wc(cs, &wc, (uchar*) s, (uchar*) e) > 0 && wc == '-';
  2286. }
  2287. #else
  2288. /*
  2289.   If not UCS2 support is compiled then it is easier
  2290. */
  2291. #define test_if_minus(cs, s, e)  (*s == '-')
  2292. #endif
  2293. int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
  2294. {
  2295.   long tmp;
  2296.   int error= 0;
  2297.   char *end;
  2298.   
  2299.   tmp= cs->cset->scan(cs, from, from+len, MY_SEQ_SPACES);
  2300.   len-= tmp;
  2301.   from+= tmp;
  2302.   my_errno=0;
  2303.   if (unsigned_flag)
  2304.   {
  2305.     if (!len || test_if_minus(cs, from, from + len))
  2306.     {
  2307.       tmp=0; // Set negative to 0
  2308.       my_errno=ERANGE;
  2309.       error= 1;
  2310.     }
  2311.     else
  2312.       tmp=(long) my_strntoul(cs,from,len,10,&end,&error);
  2313.   }
  2314.   else
  2315.     tmp=my_strntol(cs,from,len,10,&end,&error);
  2316.   if (error ||
  2317.       (from+len != end && table->in_use->count_cuted_fields &&
  2318.        !test_if_int(from,len,end,cs)))
  2319.   {
  2320.     if (error != 1)
  2321.       error= 2;
  2322.   }
  2323. #if SIZEOF_LONG > 4
  2324.   if (unsigned_flag)
  2325.   {
  2326.     if ((ulong) tmp > UINT_MAX32)
  2327.     {
  2328.       tmp= UINT_MAX32;
  2329.       error= 1;
  2330.       my_errno=ERANGE;
  2331.     }
  2332.   }
  2333.   else
  2334.   {
  2335.     if (tmp > INT_MAX32)
  2336.     {
  2337.       tmp= INT_MAX32;
  2338.       error= 1;
  2339.       my_errno=ERANGE;
  2340.     }
  2341.     else if (tmp < INT_MIN32)
  2342.     {
  2343.       tmp= INT_MIN32;
  2344.       error= 1;
  2345.       my_errno=ERANGE;
  2346.     }
  2347.   }
  2348. #endif
  2349.   if (error)
  2350.     set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  2351. #ifdef WORDS_BIGENDIAN
  2352.   if (table->db_low_byte_first)
  2353.   {
  2354.     int4store(ptr,tmp);
  2355.   }
  2356.   else
  2357. #endif
  2358.     longstore(ptr,tmp);
  2359.   return error;
  2360. }
  2361. int Field_long::store(double nr)
  2362. {
  2363.   int error= 0;
  2364.   int32 res;
  2365.   nr=rint(nr);
  2366.   if (unsigned_flag)
  2367.   {
  2368.     if (nr < 0)
  2369.     {
  2370.       res=0;
  2371.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2372.       error= 1;
  2373.     }
  2374.     else if (nr > (double) UINT_MAX32)
  2375.     {
  2376.       res= UINT_MAX32;
  2377.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2378.       error= 1;
  2379.     }
  2380.     else
  2381.       res=(int32) (ulong) nr;
  2382.   }
  2383.   else
  2384.   {
  2385.     if (nr < (double) INT_MIN32)
  2386.     {
  2387.       res=(int32) INT_MIN32;
  2388.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2389.       error= 1;
  2390.     }
  2391.     else if (nr > (double) INT_MAX32)
  2392.     {
  2393.       res=(int32) INT_MAX32;
  2394.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2395.       error= 1;
  2396.     }
  2397.     else
  2398.       res=(int32) nr;
  2399.   }
  2400. #ifdef WORDS_BIGENDIAN
  2401.   if (table->db_low_byte_first)
  2402.   {
  2403.     int4store(ptr,res);
  2404.   }
  2405.   else
  2406. #endif
  2407.     longstore(ptr,res);
  2408.   return error;
  2409. }
  2410. int Field_long::store(longlong nr)
  2411. {
  2412.   int error= 0;
  2413.   int32 res;
  2414.   /* 
  2415.     This assert has nothing to do with this method per se, it was put here
  2416.     only because it is one of the best places for catching places there its 
  2417.     condition is broken.
  2418.   */
  2419.   DBUG_ASSERT(table->in_use == current_thd);
  2420.   
  2421.   if (unsigned_flag)
  2422.   {
  2423.     if (nr < 0)
  2424.     {
  2425.       res=0;
  2426.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2427.       error= 1;
  2428.     }
  2429.     else if (nr >= (LL(1) << 32))
  2430.     {
  2431.       res=(int32) (uint32) ~0L;
  2432.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2433.       error= 1;
  2434.     }
  2435.     else
  2436.       res=(int32) (uint32) nr;
  2437.   }
  2438.   else
  2439.   {
  2440.     if (nr < (longlong) INT_MIN32)
  2441.     {
  2442.       res=(int32) INT_MIN32;
  2443.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2444.       error= 1;
  2445.     }
  2446.     else if (nr > (longlong) INT_MAX32)
  2447.     {
  2448.       res=(int32) INT_MAX32;
  2449.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2450.       error= 1;
  2451.     }
  2452.     else
  2453.       res=(int32) nr;
  2454.   }
  2455. #ifdef WORDS_BIGENDIAN
  2456.   if (table->db_low_byte_first)
  2457.   {
  2458.     int4store(ptr,res);
  2459.   }
  2460.   else
  2461. #endif
  2462.     longstore(ptr,res);
  2463.   return error;
  2464. }
  2465. double Field_long::val_real(void)
  2466. {
  2467.   int32 j;
  2468. #ifdef WORDS_BIGENDIAN
  2469.   if (table->db_low_byte_first)
  2470.     j=sint4korr(ptr);
  2471.   else
  2472. #endif
  2473.     longget(j,ptr);
  2474.   return unsigned_flag ? (double) (uint32) j : (double) j;
  2475. }
  2476. longlong Field_long::val_int(void)
  2477. {
  2478.   int32 j;
  2479.   /* See the comment in Field_long::store(long long) */
  2480.   DBUG_ASSERT(table->in_use == current_thd);
  2481. #ifdef WORDS_BIGENDIAN
  2482.   if (table->db_low_byte_first)
  2483.     j=sint4korr(ptr);
  2484.   else
  2485. #endif
  2486.     longget(j,ptr);
  2487.   return unsigned_flag ? (longlong) (uint32) j : (longlong) j;
  2488. }
  2489. String *Field_long::val_str(String *val_buffer,
  2490.     String *val_ptr __attribute__((unused)))
  2491. {
  2492.   CHARSET_INFO *cs= &my_charset_bin;
  2493.   uint length;
  2494.   uint mlength=max(field_length+1,12*cs->mbmaxlen);
  2495.   val_buffer->alloc(mlength);
  2496.   char *to=(char*) val_buffer->ptr();
  2497.   int32 j;
  2498. #ifdef WORDS_BIGENDIAN
  2499.   if (table->db_low_byte_first)
  2500.     j=sint4korr(ptr);
  2501.   else
  2502. #endif
  2503.     longget(j,ptr);
  2504.   if (unsigned_flag)
  2505.     length=cs->cset->long10_to_str(cs,to,mlength, 10,(long) (uint32)j);
  2506.   else
  2507.     length=cs->cset->long10_to_str(cs,to,mlength,-10,(long) j);
  2508.   val_buffer->length(length);
  2509.   if (zerofill)
  2510.     prepend_zeros(val_buffer);
  2511.   return val_buffer;
  2512. }
  2513. bool Field_long::send_binary(Protocol *protocol)
  2514. {
  2515.   return protocol->store_long(Field_long::val_int());
  2516. }
  2517. int Field_long::cmp(const char *a_ptr, const char *b_ptr)
  2518. {
  2519.   int32 a,b;
  2520. #ifdef WORDS_BIGENDIAN
  2521.   if (table->db_low_byte_first)
  2522.   {
  2523.     a=sint4korr(a_ptr);
  2524.     b=sint4korr(b_ptr);
  2525.   }
  2526.   else
  2527. #endif
  2528.   {
  2529.     longget(a,a_ptr);
  2530.     longget(b,b_ptr);
  2531.   }
  2532.   if (unsigned_flag)
  2533.     return ((uint32) a < (uint32) b) ? -1 : ((uint32) a > (uint32) b) ? 1 : 0;
  2534.   return (a < b) ? -1 : (a > b) ? 1 : 0;
  2535. }
  2536. void Field_long::sort_string(char *to,uint length __attribute__((unused)))
  2537. {
  2538. #ifdef WORDS_BIGENDIAN
  2539.   if (!table->db_low_byte_first)
  2540.   {
  2541.     if (unsigned_flag)
  2542.       to[0] = ptr[0];
  2543.     else
  2544.       to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
  2545.     to[1]   = ptr[1];
  2546.     to[2]   = ptr[2];
  2547.     to[3]   = ptr[3];
  2548.   }
  2549.   else
  2550. #endif
  2551.   {
  2552.     if (unsigned_flag)
  2553.       to[0] = ptr[3];
  2554.     else
  2555.       to[0] = (char) (ptr[3] ^ 128); /* Revers signbit */
  2556.     to[1]   = ptr[2];
  2557.     to[2]   = ptr[1];
  2558.     to[3]   = ptr[0];
  2559.   }
  2560. }
  2561. void Field_long::sql_type(String &res) const
  2562. {
  2563.   CHARSET_INFO *cs=res.charset();
  2564.   res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
  2565.   "int(%d)",(int) field_length));
  2566.   add_zerofill_and_unsigned(res);
  2567. }
  2568. /****************************************************************************
  2569.  Field type longlong int (8 bytes)
  2570. ****************************************************************************/
  2571. int Field_longlong::store(const char *from,uint len,CHARSET_INFO *cs)
  2572. {
  2573.   longlong tmp;
  2574.   int error= 0;
  2575.   char *end;
  2576.   
  2577.   tmp= cs->cset->scan(cs, from, from+len, MY_SEQ_SPACES);
  2578.   len-= (uint)tmp;
  2579.   from+= tmp;
  2580.   my_errno=0;
  2581.   if (unsigned_flag)
  2582.   {
  2583.     if (!len || test_if_minus(cs, from, from + len))
  2584.     {
  2585.       tmp=0; // Set negative to 0
  2586.       my_errno= ERANGE;
  2587.       error= 1;
  2588.     }
  2589.     else
  2590.       tmp=(longlong) my_strntoull(cs,from,len,10,&end,&error);
  2591.   }
  2592.   else
  2593.     tmp=my_strntoll(cs,from,len,10,&end,&error);
  2594.   if (error ||
  2595.       (from+len != end && table->in_use->count_cuted_fields &&
  2596.        !test_if_int(from,len,end,cs)))
  2597.   {
  2598.     if (error != 1)
  2599.     {
  2600.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  2601.       error= 2;
  2602.     }
  2603.   }
  2604. #ifdef WORDS_BIGENDIAN
  2605.   if (table->db_low_byte_first)
  2606.   {
  2607.     int8store(ptr,tmp);
  2608.   }
  2609.   else
  2610. #endif
  2611.     longlongstore(ptr,tmp);
  2612.   return error;
  2613. }
  2614. int Field_longlong::store(double nr)
  2615. {
  2616.   int error= 0;
  2617.   longlong res;
  2618.   nr=rint(nr);
  2619.   if (unsigned_flag)
  2620.   {
  2621.     if (nr < 0)
  2622.     {
  2623.       res=0;
  2624.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2625.       error= 1;
  2626.     }
  2627.     else if (nr >= (double) ~ (ulonglong) 0)
  2628.     {
  2629.       res= ~(longlong) 0;
  2630.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2631.       error= 1;
  2632.     }
  2633.     else
  2634.       res=(longlong) (ulonglong) nr;
  2635.   }
  2636.   else
  2637.   {
  2638.     if (nr <= (double) LONGLONG_MIN)
  2639.     {
  2640.       res=(longlong) LONGLONG_MIN;
  2641.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2642.       error= 1;
  2643.     }
  2644.     else if (nr >= (double) (ulonglong) LONGLONG_MAX)
  2645.     {
  2646.       res=(longlong) LONGLONG_MAX;
  2647.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2648.       error= 1;
  2649.     }
  2650.     else
  2651.       res=(longlong) nr;
  2652.   }
  2653. #ifdef WORDS_BIGENDIAN
  2654.   if (table->db_low_byte_first)
  2655.   {
  2656.     int8store(ptr,res);
  2657.   }
  2658.   else
  2659. #endif
  2660.     longlongstore(ptr,res);
  2661.   return error;
  2662. }
  2663. int Field_longlong::store(longlong nr)
  2664. {
  2665. #ifdef WORDS_BIGENDIAN
  2666.   if (table->db_low_byte_first)
  2667.   {
  2668.     int8store(ptr,nr);
  2669.   }
  2670.   else
  2671. #endif
  2672.     longlongstore(ptr,nr);
  2673.   return 0;
  2674. }
  2675. double Field_longlong::val_real(void)
  2676. {
  2677.   longlong j;
  2678. #ifdef WORDS_BIGENDIAN
  2679.   if (table->db_low_byte_first)
  2680.   {
  2681.     j=sint8korr(ptr);
  2682.   }
  2683.   else
  2684. #endif
  2685.     longlongget(j,ptr);
  2686.   /* The following is open coded to avoid a bug in gcc 3.3 */
  2687.   if (unsigned_flag)
  2688.   {
  2689.     ulonglong tmp= (ulonglong) j;
  2690.     return ulonglong2double(tmp);
  2691.   }
  2692.   return (double) j;
  2693. }
  2694. longlong Field_longlong::val_int(void)
  2695. {
  2696.   longlong j;
  2697. #ifdef WORDS_BIGENDIAN
  2698.   if (table->db_low_byte_first)
  2699.     j=sint8korr(ptr);
  2700.   else
  2701. #endif
  2702.     longlongget(j,ptr);
  2703.   return j;
  2704. }
  2705. String *Field_longlong::val_str(String *val_buffer,
  2706. String *val_ptr __attribute__((unused)))
  2707. {
  2708.   CHARSET_INFO *cs= &my_charset_bin;
  2709.   uint length;
  2710.   uint mlength=max(field_length+1,22*cs->mbmaxlen);
  2711.   val_buffer->alloc(mlength);
  2712.   char *to=(char*) val_buffer->ptr();
  2713.   longlong j;
  2714. #ifdef WORDS_BIGENDIAN
  2715.   if (table->db_low_byte_first)
  2716.     j=sint8korr(ptr);
  2717.   else
  2718. #endif
  2719.     longlongget(j,ptr);
  2720.   length=(uint) (cs->cset->longlong10_to_str)(cs,to,mlength,
  2721. unsigned_flag ? 10 : -10, j);
  2722.   val_buffer->length(length);
  2723.   if (zerofill)
  2724.     prepend_zeros(val_buffer);
  2725.   return val_buffer;
  2726. }
  2727. bool Field_longlong::send_binary(Protocol *protocol)
  2728. {
  2729.   return protocol->store_longlong(Field_longlong::val_int(), unsigned_flag);
  2730. }
  2731. int Field_longlong::cmp(const char *a_ptr, const char *b_ptr)
  2732. {
  2733.   longlong a,b;
  2734. #ifdef WORDS_BIGENDIAN
  2735.   if (table->db_low_byte_first)
  2736.   {
  2737.     a=sint8korr(a_ptr);
  2738.     b=sint8korr(b_ptr);
  2739.   }
  2740.   else
  2741. #endif
  2742.   {
  2743.     longlongget(a,a_ptr);
  2744.     longlongget(b,b_ptr);
  2745.   }
  2746.   if (unsigned_flag)
  2747.     return ((ulonglong) a < (ulonglong) b) ? -1 :
  2748.     ((ulonglong) a > (ulonglong) b) ? 1 : 0;
  2749.   return (a < b) ? -1 : (a > b) ? 1 : 0;
  2750. }
  2751. void Field_longlong::sort_string(char *to,uint length __attribute__((unused)))
  2752. {
  2753. #ifdef WORDS_BIGENDIAN
  2754.   if (!table->db_low_byte_first)
  2755.   {
  2756.     if (unsigned_flag)
  2757.       to[0] = ptr[0];
  2758.     else
  2759.       to[0] = (char) (ptr[0] ^ 128); /* Revers signbit */
  2760.     to[1]   = ptr[1];
  2761.     to[2]   = ptr[2];
  2762.     to[3]   = ptr[3];
  2763.     to[4]   = ptr[4];
  2764.     to[5]   = ptr[5];
  2765.     to[6]   = ptr[6];
  2766.     to[7]   = ptr[7];
  2767.   }
  2768.   else
  2769. #endif
  2770.   {
  2771.     if (unsigned_flag)
  2772.       to[0] = ptr[7];
  2773.     else
  2774.       to[0] = (char) (ptr[7] ^ 128); /* Revers signbit */
  2775.     to[1]   = ptr[6];
  2776.     to[2]   = ptr[5];
  2777.     to[3]   = ptr[4];
  2778.     to[4]   = ptr[3];
  2779.     to[5]   = ptr[2];
  2780.     to[6]   = ptr[1];
  2781.     to[7]   = ptr[0];
  2782.   }
  2783. }
  2784. void Field_longlong::sql_type(String &res) const
  2785. {
  2786.   CHARSET_INFO *cs=res.charset();
  2787.   res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
  2788.   "bigint(%d)",(int) field_length));
  2789.   add_zerofill_and_unsigned(res);
  2790. }
  2791. /****************************************************************************
  2792.   single precision float
  2793. ****************************************************************************/
  2794. int Field_float::store(const char *from,uint len,CHARSET_INFO *cs)
  2795. {
  2796.   int error;
  2797.   char *end;
  2798.   double nr= my_strntod(cs,(char*) from,len,&end,&error);
  2799.   if (error || ((uint) (end-from) != len && table->in_use->count_cuted_fields))
  2800.   {
  2801.     error= 2;
  2802.     set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  2803.   }
  2804.   Field_float::store(nr);
  2805.   return error;
  2806. }
  2807. int Field_float::store(double nr)
  2808. {
  2809.   float j;
  2810.   int error= 0;
  2811.   if (isnan(nr))
  2812.   {
  2813.     j= 0;
  2814.     set_null();
  2815.     set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2816.     error= 1;
  2817.   }
  2818.   else if (unsigned_flag && nr < 0)
  2819.   {
  2820.     j= 0;
  2821.     set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2822.     error= 1;
  2823.   }
  2824.   else
  2825.   {
  2826.     double max_value;
  2827.     if (dec >= NOT_FIXED_DEC)
  2828.     {
  2829.       max_value= FLT_MAX;
  2830.     }
  2831.     else
  2832.     {
  2833.       uint tmp=min(field_length,array_elements(log_10)-1);
  2834.       max_value= (log_10[tmp]-1)/log_10[dec];
  2835.       /*
  2836. The following comparison is needed to not get an overflow if nr
  2837. is close to FLT_MAX
  2838.       */
  2839.       if (fabs(nr) < FLT_MAX/10.0e+32)
  2840. nr= floor(nr*log_10[dec]+0.5)/log_10[dec];
  2841.     }
  2842.     if (nr < -max_value)
  2843.     {
  2844.       j= (float)-max_value;
  2845.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2846.       error= 1;
  2847.     }
  2848.     else if (nr > max_value)
  2849.     {
  2850.       j= (float)max_value;
  2851.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  2852.       error= 1;
  2853.     }
  2854.     else
  2855.       j= (float) nr;
  2856.   }
  2857.   
  2858. #ifdef WORDS_BIGENDIAN
  2859.   if (table->db_low_byte_first)
  2860.   {
  2861.     float4store(ptr,j);
  2862.   }
  2863.   else
  2864. #endif
  2865.     memcpy_fixed(ptr,(byte*) &j,sizeof(j));
  2866.   return error;
  2867. }
  2868. int Field_float::store(longlong nr)
  2869. {
  2870.   return store((double)nr);
  2871. }
  2872. double Field_float::val_real(void)
  2873. {
  2874.   float j;
  2875. #ifdef WORDS_BIGENDIAN
  2876.   if (table->db_low_byte_first)
  2877.   {
  2878.     float4get(j,ptr);
  2879.   }
  2880.   else
  2881. #endif
  2882.     memcpy_fixed((byte*) &j,ptr,sizeof(j));
  2883.   return ((double) j);
  2884. }
  2885. longlong Field_float::val_int(void)
  2886. {
  2887.   float j;
  2888. #ifdef WORDS_BIGENDIAN
  2889.   if (table->db_low_byte_first)
  2890.   {
  2891.     float4get(j,ptr);
  2892.   }
  2893.   else
  2894. #endif
  2895.     memcpy_fixed((byte*) &j,ptr,sizeof(j));
  2896.   return ((longlong) j);
  2897. }
  2898. String *Field_float::val_str(String *val_buffer,
  2899.      String *val_ptr __attribute__((unused)))
  2900. {
  2901.   float nr;
  2902. #ifdef WORDS_BIGENDIAN
  2903.   if (table->db_low_byte_first)
  2904.   {
  2905.     float4get(nr,ptr);
  2906.   }
  2907.   else
  2908. #endif
  2909.     memcpy_fixed((byte*) &nr,ptr,sizeof(nr));
  2910.   uint to_length=max(field_length,70);
  2911.   val_buffer->alloc(to_length);
  2912.   char *to=(char*) val_buffer->ptr();
  2913.   if (dec >= NOT_FIXED_DEC)
  2914.   {
  2915.     sprintf(to,"%-*.*g",(int) field_length,FLT_DIG,nr);
  2916.     to=strcend(to,' ');
  2917.     *to=0;
  2918.   }
  2919.   else
  2920.   {
  2921. #ifdef HAVE_FCONVERT
  2922.     char buff[70],*pos=buff;
  2923.     int decpt,sign,tmp_dec=dec;
  2924.     VOID(sfconvert(&nr,tmp_dec,&decpt,&sign,buff));
  2925.     if (sign)
  2926.     {
  2927.       *to++='-';
  2928.     }
  2929.     if (decpt < 0)
  2930.     { /* val_buffer is < 0 */
  2931.       *to++='0';
  2932.       if (!tmp_dec)
  2933. goto end;
  2934.       *to++='.';
  2935.       if (-decpt > tmp_dec)
  2936. decpt= - (int) tmp_dec;
  2937.       tmp_dec=(uint) ((int) tmp_dec+decpt);
  2938.       while (decpt++ < 0)
  2939. *to++='0';
  2940.     }
  2941.     else if (decpt == 0)
  2942.     {
  2943.       *to++= '0';
  2944.       if (!tmp_dec)
  2945. goto end;
  2946.       *to++='.';
  2947.     }
  2948.     else
  2949.     {
  2950.       while (decpt-- > 0)
  2951. *to++= *pos++;
  2952.       if (!tmp_dec)
  2953. goto end;
  2954.       *to++='.';
  2955.     }
  2956.     while (tmp_dec--)
  2957.       *to++= *pos++;
  2958. #else
  2959. #ifdef HAVE_SNPRINTF
  2960.     to[to_length-1]=0; // Safety
  2961.     snprintf(to,to_length-1,"%.*f",dec,nr);
  2962.     to=strend(to);
  2963. #else
  2964.     to+= my_sprintf(to,(to,"%.*f",dec,nr));
  2965. #endif
  2966. #endif
  2967.   }
  2968. #ifdef HAVE_FCONVERT
  2969.  end:
  2970. #endif
  2971.   val_buffer->length((uint) (to-val_buffer->ptr()));
  2972.   if (zerofill)
  2973.     prepend_zeros(val_buffer);
  2974.   return val_buffer;
  2975. }
  2976. int Field_float::cmp(const char *a_ptr, const char *b_ptr)
  2977. {
  2978.   float a,b;
  2979. #ifdef WORDS_BIGENDIAN
  2980.   if (table->db_low_byte_first)
  2981.   {
  2982.     float4get(a,a_ptr);
  2983.     float4get(b,b_ptr);
  2984.   }
  2985.   else
  2986. #endif
  2987.   {
  2988.     memcpy_fixed(&a,a_ptr,sizeof(float));
  2989.     memcpy_fixed(&b,b_ptr,sizeof(float));
  2990.   }
  2991.   return (a < b) ? -1 : (a > b) ? 1 : 0;
  2992. }
  2993. #define FLT_EXP_DIG (sizeof(float)*8-FLT_MANT_DIG)
  2994. void Field_float::sort_string(char *to,uint length __attribute__((unused)))
  2995. {
  2996.   float nr;
  2997. #ifdef WORDS_BIGENDIAN
  2998.   if (table->db_low_byte_first)
  2999.   {
  3000.     float4get(nr,ptr);
  3001.   }
  3002.   else
  3003. #endif
  3004.     memcpy_fixed(&nr,ptr,sizeof(float));
  3005.   uchar *tmp= (uchar*) to;
  3006.   if (nr == (float) 0.0)
  3007.   { /* Change to zero string */
  3008.     tmp[0]=(uchar) 128;
  3009.     bzero((char*) tmp+1,sizeof(nr)-1);
  3010.   }
  3011.   else
  3012.   {
  3013. #ifdef WORDS_BIGENDIAN
  3014.     memcpy_fixed(tmp,&nr,sizeof(nr));
  3015. #else
  3016.     tmp[0]= ptr[3]; tmp[1]=ptr[2]; tmp[2]= ptr[1]; tmp[3]=ptr[0];
  3017. #endif
  3018.     if (tmp[0] & 128) /* Negative */
  3019.     { /* make complement */
  3020.       uint i;
  3021.       for (i=0 ; i < sizeof(nr); i++)
  3022. tmp[i]= (uchar) (tmp[i] ^ (uchar) 255);
  3023.     }
  3024.     else
  3025.     {
  3026.       ushort exp_part=(((ushort) tmp[0] << 8) | (ushort) tmp[1] |
  3027.        (ushort) 32768);
  3028.       exp_part+= (ushort) 1 << (16-1-FLT_EXP_DIG);
  3029.       tmp[0]= (uchar) (exp_part >> 8);
  3030.       tmp[1]= (uchar) exp_part;
  3031.     }
  3032.   }
  3033. }
  3034. bool Field_float::send_binary(Protocol *protocol)
  3035. {
  3036.   return protocol->store((float) Field_float::val_real(), dec, (String*) 0);
  3037. }
  3038. void Field_float::sql_type(String &res) const
  3039. {
  3040.   if (dec == NOT_FIXED_DEC)
  3041.   {
  3042.     res.set_ascii("float", 5);
  3043.   }
  3044.   else
  3045.   {
  3046.     CHARSET_INFO *cs= res.charset();
  3047.     res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
  3048.     "float(%d,%d)",(int) field_length,dec));
  3049.   }
  3050.   add_zerofill_and_unsigned(res);
  3051. }
  3052. /****************************************************************************
  3053.   double precision floating point numbers
  3054. ****************************************************************************/
  3055. int Field_double::store(const char *from,uint len,CHARSET_INFO *cs)
  3056. {
  3057.   int error;
  3058.   char *end;
  3059.   double nr= my_strntod(cs,(char*) from, len, &end, &error);
  3060.   if (error || ((uint) (end-from) != len && table->in_use->count_cuted_fields))
  3061.   {
  3062.     error= 2;
  3063.     set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
  3064.   }
  3065.   Field_double::store(nr);
  3066.   return error;
  3067. }
  3068. int Field_double::store(double nr)
  3069. {
  3070.   int error= 0;
  3071.   if (isnan(nr))
  3072.   {
  3073.     nr= 0;
  3074.     set_null();
  3075.     set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  3076.     error= 1;
  3077.   }
  3078.   else if (unsigned_flag && nr < 0)
  3079.   {
  3080.     nr= 0;
  3081.     set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  3082.     error= 1;
  3083.   }
  3084.   else 
  3085.   {
  3086.     double max_value;
  3087.     if (dec >= NOT_FIXED_DEC)
  3088.     {
  3089.       max_value= DBL_MAX;
  3090.     }
  3091.     else
  3092.     {
  3093.       uint tmp=min(field_length,array_elements(log_10)-1);
  3094.       max_value= (log_10[tmp]-1)/log_10[dec];
  3095.       if (fabs(nr) < DBL_MAX/10.0e+32)
  3096. nr= floor(nr*log_10[dec]+0.5)/log_10[dec];
  3097.     }
  3098.     if (nr < -max_value)
  3099.     {
  3100.       nr= -max_value;
  3101.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  3102.       error= 1;
  3103.     }
  3104.     else if (nr > max_value)
  3105.     {
  3106.       nr= max_value;
  3107.       set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
  3108.       error= 1;
  3109.     }
  3110.   }
  3111. #ifdef WORDS_BIGENDIAN
  3112.   if (table->db_low_byte_first)
  3113.   {
  3114.     float8store(ptr,nr);
  3115.   }
  3116.   else
  3117. #endif
  3118.     doublestore(ptr,nr);
  3119.   return error;
  3120. }
  3121. int Field_double::store(longlong nr)
  3122. {
  3123.   return store((double)nr);
  3124. }
  3125. double Field_double::val_real(void)
  3126. {
  3127.   double j;
  3128. #ifdef WORDS_BIGENDIAN
  3129.   if (table->db_low_byte_first)
  3130.   {
  3131.     float8get(j,ptr);
  3132.   }
  3133.   else
  3134. #endif
  3135.     doubleget(j,ptr);
  3136.   return j;
  3137. }
  3138. longlong Field_double::val_int(void)
  3139. {
  3140.   double j;
  3141. #ifdef WORDS_BIGENDIAN
  3142.   if (table->db_low_byte_first)
  3143.   {
  3144.     float8get(j,ptr);
  3145.   }
  3146.   else
  3147. #endif
  3148.     doubleget(j,ptr);
  3149.   return ((longlong) j);
  3150. }
  3151. String *Field_double::val_str(String *val_buffer,
  3152.       String *val_ptr __attribute__((unused)))
  3153. {
  3154.   double nr;
  3155. #ifdef WORDS_BIGENDIAN
  3156.   if (table->db_low_byte_first)
  3157.   {
  3158.     float8get(nr,ptr);
  3159.   }
  3160.   else
  3161. #endif
  3162.     doubleget(nr,ptr);
  3163.   uint to_length=max(field_length, DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE);
  3164.   val_buffer->alloc(to_length);
  3165.   char *to=(char*) val_buffer->ptr();
  3166.   if (dec >= NOT_FIXED_DEC)
  3167.   {
  3168.     sprintf(to,"%-*.*g",(int) field_length,DBL_DIG,nr);
  3169.     to=strcend(to,' ');
  3170.   }
  3171.   else
  3172.   {
  3173. #ifdef HAVE_FCONVERT
  3174.     char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
  3175.     char *pos= buff;
  3176.     int decpt,sign,tmp_dec=dec;
  3177.     VOID(fconvert(nr,tmp_dec,&decpt,&sign,buff));
  3178.     if (sign)
  3179.     {
  3180.       *to++='-';
  3181.     }
  3182.     if (decpt < 0)
  3183.     { /* val_buffer is < 0 */
  3184.       *to++='0';
  3185.       if (!tmp_dec)
  3186. goto end;
  3187.       *to++='.';
  3188.       if (-decpt > tmp_dec)
  3189. decpt= - (int) tmp_dec;
  3190.       tmp_dec=(uint) ((int) tmp_dec+decpt);
  3191.       while (decpt++ < 0)
  3192. *to++='0';
  3193.     }
  3194.     else if (decpt == 0)
  3195.     {
  3196.       *to++= '0';
  3197.       if (!tmp_dec)
  3198. goto end;
  3199.       *to++='.';
  3200.     }
  3201.     else
  3202.     {
  3203.       while (decpt-- > 0)
  3204. *to++= *pos++;
  3205.       if (!tmp_dec)
  3206. goto end;
  3207.       *to++='.';
  3208.     }
  3209.     while (tmp_dec--)
  3210.       *to++= *pos++;
  3211. #else
  3212. #ifdef HAVE_SNPRINTF
  3213.     to[to_length-1]=0; // Safety
  3214.     snprintf(to,to_length-1,"%.*f",dec,nr);
  3215.     to=strend(to);
  3216. #else
  3217.     to+= my_sprintf(to,(to,"%.*f",dec,nr));
  3218. #endif
  3219. #endif
  3220.   }
  3221. #ifdef HAVE_FCONVERT
  3222.  end:
  3223. #endif
  3224.   val_buffer->length((uint) (to-val_buffer->ptr()));
  3225.   if (zerofill)
  3226.     prepend_zeros(val_buffer);
  3227.   return val_buffer;
  3228. }
  3229. bool Field_double::send_binary(Protocol *protocol)
  3230. {
  3231.   return protocol->store((double) Field_double::val_real(), dec, (String*) 0);
  3232. }
  3233. int Field_double::cmp(const char *a_ptr, const char *b_ptr)
  3234. {