← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Brian Aker
  • Date: 2008-10-12 01:59:02 UTC
  • Revision ID: brian@tangent.org-20081012015902-prhy6wsimdqr28om
Dead code around unsigned (first pass)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.cc
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 MySQL
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
 
1
/* Copyright (C) 2000-2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
20
16
 
21
17
/**
22
 
 * @file This file implements the Field class and API
23
 
 */
 
18
  @file
24
19
 
25
 
#include "config.h"
26
 
#include <cstdio>
 
20
  @brief
 
21
  This file implements classes defined in field.h
 
22
*/
 
23
#include <drizzled/server_includes.h>
 
24
#include "sql_select.h"
27
25
#include <errno.h>
28
 
#include <float.h>
29
 
#include "drizzled/sql_select.h"
30
 
#include "drizzled/error.h"
31
 
#include "drizzled/field/str.h"
32
 
#include "drizzled/field/num.h"
33
 
#include "drizzled/field/blob.h"
34
 
#include "drizzled/field/enum.h"
35
 
#include "drizzled/field/null.h"
36
 
#include "drizzled/field/date.h"
37
 
#include "drizzled/field/decimal.h"
38
 
#include "drizzled/field/real.h"
39
 
#include "drizzled/field/double.h"
40
 
#include "drizzled/field/int32.h"
41
 
#include "drizzled/field/int64.h"
42
 
#include "drizzled/field/num.h"
43
 
#include "drizzled/field/timestamp.h"
44
 
#include "drizzled/field/datetime.h"
45
 
#include "drizzled/field/varstring.h"
46
 
#include "drizzled/field/uuid.h"
47
 
#include "drizzled/time_functions.h"
48
 
#include "drizzled/internal/m_string.h"
49
 
 
50
 
#include "drizzled/display.h"
51
 
 
52
 
namespace drizzled
53
 
{
 
26
#include <drizzled/drizzled_error_messages.h>
 
27
 
 
28
// Maximum allowed exponent value for converting string to decimal
 
29
#define MAX_EXPONENT 1024
54
30
 
55
31
/*****************************************************************************
56
32
  Instansiate templates and static variables
57
33
*****************************************************************************/
58
34
 
59
 
static enum_field_types
60
 
field_types_merge_rules [enum_field_types_size][enum_field_types_size]=
61
 
{
 
35
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
36
template class List<Create_field>;
 
37
template class List_iterator<Create_field>;
 
38
#endif
 
39
 
 
40
 
 
41
/*
 
42
  Rules for merging different types of fields in UNION
 
43
 
 
44
  NOTE: to avoid 256*256 table, gap in table types numeration is skiped
 
45
  following #defines describe that gap and how to canculate number of fields
 
46
  and index of field in thia array.
 
47
*/
 
48
#define FIELDTYPE_TEAR_FROM (DRIZZLE_TYPE_VARCHAR + 1)
 
49
#define FIELDTYPE_TEAR_TO   (DRIZZLE_TYPE_NEWDECIMAL - 1)
 
50
#define FIELDTYPE_NUM (FIELDTYPE_TEAR_FROM + (255 - FIELDTYPE_TEAR_TO))
 
51
inline int field_type2index (enum_field_types field_type)
 
52
{
 
53
  return (field_type < FIELDTYPE_TEAR_FROM ?
 
54
          field_type :
 
55
          ((int)FIELDTYPE_TEAR_FROM) + (field_type - FIELDTYPE_TEAR_TO) - 1);
 
56
}
 
57
 
 
58
 
 
59
static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
 
60
{
 
61
  /* DRIZZLE_TYPE_DECIMAL -> */
 
62
  {
 
63
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
64
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
 
65
  //DRIZZLE_TYPE_LONG
 
66
    DRIZZLE_TYPE_NEWDECIMAL,
 
67
  //DRIZZLE_TYPE_DOUBLE
 
68
    DRIZZLE_TYPE_DOUBLE,
 
69
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
70
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
71
  //DRIZZLE_TYPE_LONGLONG
 
72
    DRIZZLE_TYPE_NEWDECIMAL,
 
73
  //DRIZZLE_TYPE_TIME
 
74
    DRIZZLE_TYPE_VARCHAR,
 
75
  //DRIZZLE_TYPE_DATETIME
 
76
    DRIZZLE_TYPE_VARCHAR,
 
77
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
78
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
79
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
80
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
81
  //DRIZZLE_TYPE_BLOB
 
82
    DRIZZLE_TYPE_BLOB,
 
83
  },
 
84
  /* DRIZZLE_TYPE_TINY -> */
 
85
  {
 
86
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
87
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_TINY,
 
88
  //DRIZZLE_TYPE_LONG
 
89
    DRIZZLE_TYPE_LONG,
 
90
  //DRIZZLE_TYPE_DOUBLE
 
91
    DRIZZLE_TYPE_DOUBLE,
 
92
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
93
    DRIZZLE_TYPE_TINY,        DRIZZLE_TYPE_VARCHAR,
 
94
  //DRIZZLE_TYPE_LONGLONG
 
95
    DRIZZLE_TYPE_LONGLONG,
 
96
  //DRIZZLE_TYPE_TIME
 
97
    DRIZZLE_TYPE_VARCHAR,
 
98
  //DRIZZLE_TYPE_DATETIME
 
99
    DRIZZLE_TYPE_VARCHAR,
 
100
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
101
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
102
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
103
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
104
  //DRIZZLE_TYPE_BLOB
 
105
    DRIZZLE_TYPE_BLOB,
 
106
  },
62
107
  /* DRIZZLE_TYPE_LONG -> */
63
108
  {
64
 
    //DRIZZLE_TYPE_LONG
 
109
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
110
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_LONG,
 
111
  //DRIZZLE_TYPE_LONG
65
112
    DRIZZLE_TYPE_LONG,
66
 
    //DRIZZLE_TYPE_DOUBLE
 
113
  //DRIZZLE_TYPE_DOUBLE
67
114
    DRIZZLE_TYPE_DOUBLE,
68
 
    //DRIZZLE_TYPE_NULL
69
 
    DRIZZLE_TYPE_LONG,
70
 
    //DRIZZLE_TYPE_TIMESTAMP
71
 
    DRIZZLE_TYPE_VARCHAR,
72
 
    //DRIZZLE_TYPE_LONGLONG
 
115
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
116
    DRIZZLE_TYPE_LONG,         DRIZZLE_TYPE_VARCHAR,
 
117
  //DRIZZLE_TYPE_LONGLONG
73
118
    DRIZZLE_TYPE_LONGLONG,
74
 
    //DRIZZLE_TYPE_DATETIME
75
 
    DRIZZLE_TYPE_VARCHAR,
76
 
    //DRIZZLE_TYPE_DATE
77
 
    DRIZZLE_TYPE_VARCHAR,
78
 
    //DRIZZLE_TYPE_VARCHAR
79
 
    DRIZZLE_TYPE_VARCHAR,
80
 
    //DRIZZLE_TYPE_DECIMAL
81
 
    DRIZZLE_TYPE_DECIMAL,
82
 
    //DRIZZLE_TYPE_ENUM
83
 
    DRIZZLE_TYPE_VARCHAR,
84
 
    //DRIZZLE_TYPE_BLOB
 
119
  //DRIZZLE_TYPE_TIME
 
120
    DRIZZLE_TYPE_VARCHAR,
 
121
  //DRIZZLE_TYPE_DATETIME
 
122
    DRIZZLE_TYPE_VARCHAR,
 
123
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
124
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
125
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
126
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
127
  //DRIZZLE_TYPE_BLOB
85
128
    DRIZZLE_TYPE_BLOB,
86
 
    //DRIZZLE_TYPE_UUID
87
 
    DRIZZLE_TYPE_VARCHAR,
88
129
  },
89
130
  /* DRIZZLE_TYPE_DOUBLE -> */
90
131
  {
91
 
    //DRIZZLE_TYPE_LONG
92
 
    DRIZZLE_TYPE_DOUBLE,
93
 
    //DRIZZLE_TYPE_DOUBLE
94
 
    DRIZZLE_TYPE_DOUBLE,
95
 
    //DRIZZLE_TYPE_NULL
96
 
    DRIZZLE_TYPE_DOUBLE,
97
 
    //DRIZZLE_TYPE_TIMESTAMP
98
 
    DRIZZLE_TYPE_VARCHAR,
99
 
    //DRIZZLE_TYPE_LONGLONG
100
 
    DRIZZLE_TYPE_DOUBLE,
101
 
    //DRIZZLE_TYPE_DATETIME
102
 
    DRIZZLE_TYPE_VARCHAR,
103
 
    //DRIZZLE_TYPE_DATE
104
 
    DRIZZLE_TYPE_VARCHAR,
105
 
    //DRIZZLE_TYPE_VARCHAR
106
 
    DRIZZLE_TYPE_VARCHAR,
107
 
    //DRIZZLE_TYPE_DECIMAL
108
 
    DRIZZLE_TYPE_DOUBLE,
109
 
    //DRIZZLE_TYPE_ENUM
110
 
    DRIZZLE_TYPE_VARCHAR,
111
 
    //DRIZZLE_TYPE_BLOB
 
132
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
133
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_DOUBLE,
 
134
  //DRIZZLE_TYPE_LONG
 
135
    DRIZZLE_TYPE_DOUBLE,
 
136
  //DRIZZLE_TYPE_DOUBLE
 
137
    DRIZZLE_TYPE_DOUBLE,
 
138
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
139
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_VARCHAR,
 
140
  //DRIZZLE_TYPE_LONGLONG
 
141
    DRIZZLE_TYPE_DOUBLE,
 
142
  //DRIZZLE_TYPE_TIME
 
143
    DRIZZLE_TYPE_VARCHAR,
 
144
  //DRIZZLE_TYPE_DATETIME
 
145
    DRIZZLE_TYPE_VARCHAR,
 
146
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
147
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
148
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
149
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_VARCHAR,
 
150
  //DRIZZLE_TYPE_BLOB
112
151
    DRIZZLE_TYPE_BLOB,
113
 
    //DRIZZLE_TYPE_UUID
114
 
    DRIZZLE_TYPE_VARCHAR,
115
152
  },
116
153
  /* DRIZZLE_TYPE_NULL -> */
117
154
  {
118
 
    //DRIZZLE_TYPE_LONG
 
155
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
156
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_TINY,
 
157
  //DRIZZLE_TYPE_LONG
119
158
    DRIZZLE_TYPE_LONG,
120
 
    //DRIZZLE_TYPE_DOUBLE
 
159
  //DRIZZLE_TYPE_DOUBLE
121
160
    DRIZZLE_TYPE_DOUBLE,
122
 
    //DRIZZLE_TYPE_NULL
123
 
    DRIZZLE_TYPE_NULL,
124
 
    //DRIZZLE_TYPE_TIMESTAMP
125
 
    DRIZZLE_TYPE_TIMESTAMP,
126
 
    //DRIZZLE_TYPE_LONGLONG
 
161
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
162
    DRIZZLE_TYPE_NULL,        DRIZZLE_TYPE_TIMESTAMP,
 
163
  //DRIZZLE_TYPE_LONGLONG
127
164
    DRIZZLE_TYPE_LONGLONG,
128
 
    //DRIZZLE_TYPE_DATETIME
 
165
  //DRIZZLE_TYPE_TIME
 
166
    DRIZZLE_TYPE_TIME,
 
167
  //DRIZZLE_TYPE_DATETIME
129
168
    DRIZZLE_TYPE_DATETIME,
130
 
    //DRIZZLE_TYPE_DATE
131
 
    DRIZZLE_TYPE_DATE,
132
 
    //DRIZZLE_TYPE_VARCHAR
133
 
    DRIZZLE_TYPE_VARCHAR,
134
 
    //DRIZZLE_TYPE_DECIMAL
135
 
    DRIZZLE_TYPE_DECIMAL,
136
 
    //DRIZZLE_TYPE_ENUM
137
 
    DRIZZLE_TYPE_ENUM,
138
 
    //DRIZZLE_TYPE_BLOB
 
169
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
170
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
 
171
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
172
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_ENUM,
 
173
  //DRIZZLE_TYPE_BLOB
139
174
    DRIZZLE_TYPE_BLOB,
140
 
    //DRIZZLE_TYPE_UUID
141
 
    DRIZZLE_TYPE_UUID,
142
175
  },
143
176
  /* DRIZZLE_TYPE_TIMESTAMP -> */
144
177
  {
145
 
    //DRIZZLE_TYPE_LONG
146
 
    DRIZZLE_TYPE_VARCHAR,
147
 
    //DRIZZLE_TYPE_DOUBLE
148
 
    DRIZZLE_TYPE_VARCHAR,
149
 
    //DRIZZLE_TYPE_NULL
150
 
    DRIZZLE_TYPE_TIMESTAMP,
151
 
    //DRIZZLE_TYPE_TIMESTAMP
152
 
    DRIZZLE_TYPE_TIMESTAMP,
153
 
    //DRIZZLE_TYPE_LONGLONG
154
 
    DRIZZLE_TYPE_VARCHAR,
155
 
    //DRIZZLE_TYPE_DATETIME
156
 
    DRIZZLE_TYPE_DATETIME,
157
 
    //DRIZZLE_TYPE_DATE
158
 
    DRIZZLE_TYPE_DATE,
159
 
    //DRIZZLE_TYPE_VARCHAR
160
 
    DRIZZLE_TYPE_VARCHAR,
161
 
    //DRIZZLE_TYPE_DECIMAL
162
 
    DRIZZLE_TYPE_VARCHAR,
163
 
    //DRIZZLE_TYPE_ENUM
164
 
    DRIZZLE_TYPE_VARCHAR,
165
 
    //DRIZZLE_TYPE_BLOB
 
178
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
179
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
180
  //DRIZZLE_TYPE_LONG
 
181
    DRIZZLE_TYPE_VARCHAR,
 
182
  //DRIZZLE_TYPE_DOUBLE
 
183
    DRIZZLE_TYPE_VARCHAR,
 
184
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
185
    DRIZZLE_TYPE_TIMESTAMP,   DRIZZLE_TYPE_TIMESTAMP,
 
186
  //DRIZZLE_TYPE_LONGLONG
 
187
    DRIZZLE_TYPE_VARCHAR,
 
188
  //DRIZZLE_TYPE_TIME
 
189
    DRIZZLE_TYPE_DATETIME,
 
190
  //DRIZZLE_TYPE_DATETIME
 
191
    DRIZZLE_TYPE_DATETIME,
 
192
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
193
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
 
194
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
195
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
196
  //DRIZZLE_TYPE_BLOB
166
197
    DRIZZLE_TYPE_BLOB,
167
 
    //DRIZZLE_TYPE_UUID
168
 
    DRIZZLE_TYPE_VARCHAR,
169
198
  },
170
199
  /* DRIZZLE_TYPE_LONGLONG -> */
171
200
  {
172
 
    //DRIZZLE_TYPE_LONG
 
201
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
202
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_LONGLONG,
 
203
  //DRIZZLE_TYPE_LONG
173
204
    DRIZZLE_TYPE_LONGLONG,
174
 
    //DRIZZLE_TYPE_DOUBLE
 
205
  //DRIZZLE_TYPE_DOUBLE
175
206
    DRIZZLE_TYPE_DOUBLE,
176
 
    //DRIZZLE_TYPE_NULL
177
 
    DRIZZLE_TYPE_LONGLONG,
178
 
    //DRIZZLE_TYPE_TIMESTAMP
179
 
    DRIZZLE_TYPE_VARCHAR,
180
 
    //DRIZZLE_TYPE_LONGLONG
181
 
    DRIZZLE_TYPE_LONGLONG,
182
 
    //DRIZZLE_TYPE_DATETIME
183
 
    DRIZZLE_TYPE_VARCHAR,
184
 
    //DRIZZLE_TYPE_DATE
185
 
    DRIZZLE_TYPE_DATE,
186
 
    //DRIZZLE_TYPE_VARCHAR
187
 
    DRIZZLE_TYPE_VARCHAR,
188
 
    //DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_ENUM
189
 
    DRIZZLE_TYPE_DECIMAL,
190
 
    DRIZZLE_TYPE_VARCHAR,
191
 
    //DRIZZLE_TYPE_BLOB
192
 
    DRIZZLE_TYPE_BLOB,
193
 
    //DRIZZLE_TYPE_UUID
194
 
    DRIZZLE_TYPE_VARCHAR,
 
207
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
208
    DRIZZLE_TYPE_LONGLONG,    DRIZZLE_TYPE_VARCHAR,
 
209
  //DRIZZLE_TYPE_LONGLONG
 
210
    DRIZZLE_TYPE_LONGLONG,
 
211
  //DRIZZLE_TYPE_TIME
 
212
    DRIZZLE_TYPE_VARCHAR,
 
213
  //DRIZZLE_TYPE_DATETIME
 
214
    DRIZZLE_TYPE_VARCHAR,
 
215
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
216
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
 
217
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
218
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
219
  //DRIZZLE_TYPE_BLOB
 
220
    DRIZZLE_TYPE_BLOB,
 
221
  },
 
222
  /* DRIZZLE_TYPE_TIME -> */
 
223
  {
 
224
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
225
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
226
  //DRIZZLE_TYPE_LONG
 
227
    DRIZZLE_TYPE_VARCHAR,
 
228
  //DRIZZLE_TYPE_DOUBLE
 
229
    DRIZZLE_TYPE_VARCHAR,
 
230
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
231
    DRIZZLE_TYPE_TIME,        DRIZZLE_TYPE_DATETIME,
 
232
  //DRIZZLE_TYPE_LONGLONG
 
233
    DRIZZLE_TYPE_VARCHAR,
 
234
  //DRIZZLE_TYPE_TIME
 
235
    DRIZZLE_TYPE_TIME,
 
236
  //DRIZZLE_TYPE_DATETIME
 
237
    DRIZZLE_TYPE_DATETIME,
 
238
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
239
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
 
240
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
241
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
242
  //DRIZZLE_TYPE_BLOB
 
243
    DRIZZLE_TYPE_BLOB,
195
244
  },
196
245
  /* DRIZZLE_TYPE_DATETIME -> */
197
246
  {
198
 
    //DRIZZLE_TYPE_LONG
199
 
    DRIZZLE_TYPE_VARCHAR,
200
 
    //DRIZZLE_TYPE_DOUBLE
201
 
    DRIZZLE_TYPE_VARCHAR,
202
 
    //DRIZZLE_TYPE_NULL
203
 
    DRIZZLE_TYPE_DATETIME,
204
 
    //DRIZZLE_TYPE_TIMESTAMP
205
 
    DRIZZLE_TYPE_DATETIME,
206
 
    //DRIZZLE_TYPE_LONGLONG
207
 
    DRIZZLE_TYPE_VARCHAR,
208
 
    //DRIZZLE_TYPE_DATETIME
209
 
    DRIZZLE_TYPE_DATETIME,
210
 
    //DRIZZLE_TYPE_DATE
211
 
    DRIZZLE_TYPE_DATE,
212
 
    //DRIZZLE_TYPE_VARCHAR
213
 
    DRIZZLE_TYPE_VARCHAR,
214
 
    //DRIZZLE_TYPE_DECIMAL
215
 
    DRIZZLE_TYPE_VARCHAR,
216
 
    //DRIZZLE_TYPE_ENUM
217
 
    DRIZZLE_TYPE_VARCHAR,
218
 
    //DRIZZLE_TYPE_BLOB
 
247
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
248
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
249
  //DRIZZLE_TYPE_LONG
 
250
    DRIZZLE_TYPE_VARCHAR,
 
251
  //DRIZZLE_TYPE_DOUBLE
 
252
    DRIZZLE_TYPE_VARCHAR,
 
253
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
254
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_DATETIME,
 
255
  //DRIZZLE_TYPE_LONGLONG
 
256
    DRIZZLE_TYPE_VARCHAR,
 
257
  //DRIZZLE_TYPE_TIME
 
258
    DRIZZLE_TYPE_DATETIME,
 
259
  //DRIZZLE_TYPE_DATETIME
 
260
    DRIZZLE_TYPE_DATETIME,
 
261
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
262
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
 
263
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
264
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
265
  //DRIZZLE_TYPE_BLOB
219
266
    DRIZZLE_TYPE_BLOB,
220
 
    //DRIZZLE_TYPE_UUID
221
 
    DRIZZLE_TYPE_VARCHAR,
222
267
  },
223
 
  /* DRIZZLE_TYPE_DATE -> */
 
268
  /* DRIZZLE_TYPE_NEWDATE -> */
224
269
  {
225
 
    //DRIZZLE_TYPE_LONG
226
 
    DRIZZLE_TYPE_VARCHAR,
227
 
    //DRIZZLE_TYPE_DOUBLE
228
 
    DRIZZLE_TYPE_VARCHAR,
229
 
    //DRIZZLE_TYPE_NULL
230
 
    DRIZZLE_TYPE_DATE,
231
 
    //DRIZZLE_TYPE_TIMESTAMP
232
 
    DRIZZLE_TYPE_DATETIME,
233
 
    //DRIZZLE_TYPE_LONGLONG
234
 
    DRIZZLE_TYPE_VARCHAR,
235
 
    //DRIZZLE_TYPE_DATETIME
236
 
    DRIZZLE_TYPE_DATETIME,
237
 
    //DRIZZLE_TYPE_DATE
238
 
    DRIZZLE_TYPE_DATE,
239
 
    //DRIZZLE_TYPE_VARCHAR
240
 
    DRIZZLE_TYPE_VARCHAR,
241
 
    //DRIZZLE_TYPE_DECIMAL
242
 
    DRIZZLE_TYPE_VARCHAR,
243
 
    //DRIZZLE_TYPE_ENUM
244
 
    DRIZZLE_TYPE_VARCHAR,
245
 
    //DRIZZLE_TYPE_BLOB
 
270
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
271
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
272
  //DRIZZLE_TYPE_LONG
 
273
    DRIZZLE_TYPE_VARCHAR,
 
274
  //DRIZZLE_TYPE_DOUBLE
 
275
    DRIZZLE_TYPE_VARCHAR,
 
276
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
277
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
 
278
  //DRIZZLE_TYPE_LONGLONG
 
279
    DRIZZLE_TYPE_VARCHAR,
 
280
  //DRIZZLE_TYPE_TIME
 
281
    DRIZZLE_TYPE_DATETIME,
 
282
  //DRIZZLE_TYPE_DATETIME
 
283
    DRIZZLE_TYPE_DATETIME,
 
284
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
285
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
 
286
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
287
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
288
  //DRIZZLE_TYPE_BLOB
246
289
    DRIZZLE_TYPE_BLOB,
247
 
    //DRIZZLE_TYPE_UUID
248
 
    DRIZZLE_TYPE_VARCHAR,
249
290
  },
250
291
  /* DRIZZLE_TYPE_VARCHAR -> */
251
292
  {
252
 
    //DRIZZLE_TYPE_LONG
253
 
    DRIZZLE_TYPE_VARCHAR,
254
 
    //DRIZZLE_TYPE_DOUBLE
255
 
    DRIZZLE_TYPE_VARCHAR,
256
 
    //DRIZZLE_TYPE_NULL
257
 
    DRIZZLE_TYPE_VARCHAR,
258
 
    //DRIZZLE_TYPE_TIMESTAMP
259
 
    DRIZZLE_TYPE_VARCHAR,
260
 
    //DRIZZLE_TYPE_LONGLONG
261
 
    DRIZZLE_TYPE_VARCHAR,
262
 
    //DRIZZLE_TYPE_DATETIME
263
 
    DRIZZLE_TYPE_VARCHAR,
264
 
    //DRIZZLE_TYPE_DATE
265
 
    DRIZZLE_TYPE_VARCHAR,
266
 
    //DRIZZLE_TYPE_VARCHAR
267
 
    DRIZZLE_TYPE_VARCHAR,
268
 
    //DRIZZLE_TYPE_DECIMAL
269
 
    DRIZZLE_TYPE_VARCHAR,
270
 
    //DRIZZLE_TYPE_ENUM
271
 
    DRIZZLE_TYPE_VARCHAR,
272
 
    //DRIZZLE_TYPE_BLOB
 
293
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
294
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
295
  //DRIZZLE_TYPE_LONG
 
296
    DRIZZLE_TYPE_VARCHAR,
 
297
  //DRIZZLE_TYPE_DOUBLE
 
298
    DRIZZLE_TYPE_VARCHAR,
 
299
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
300
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
301
  //DRIZZLE_TYPE_LONGLONG
 
302
    DRIZZLE_TYPE_VARCHAR,
 
303
  //DRIZZLE_TYPE_TIME
 
304
    DRIZZLE_TYPE_VARCHAR,
 
305
  //DRIZZLE_TYPE_DATETIME
 
306
    DRIZZLE_TYPE_VARCHAR,
 
307
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
308
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
309
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
310
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
311
  //DRIZZLE_TYPE_BLOB
273
312
    DRIZZLE_TYPE_BLOB,
274
 
    //DRIZZLE_TYPE_UUID
275
 
    DRIZZLE_TYPE_VARCHAR,
276
313
  },
277
 
  /* DRIZZLE_TYPE_DECIMAL -> */
 
314
  /* DRIZZLE_TYPE_NEWDECIMAL -> */
278
315
  {
279
 
    //DRIZZLE_TYPE_LONG
280
 
    DRIZZLE_TYPE_DECIMAL,
281
 
    //DRIZZLE_TYPE_DOUBLE
 
316
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
317
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
 
318
  //DRIZZLE_TYPE_LONG
 
319
    DRIZZLE_TYPE_NEWDECIMAL,
 
320
  //DRIZZLE_TYPE_DOUBLE
282
321
    DRIZZLE_TYPE_DOUBLE,
283
 
    //DRIZZLE_TYPE_NULL
284
 
    DRIZZLE_TYPE_DECIMAL,
285
 
    //DRIZZLE_TYPE_TIMESTAMP
286
 
    DRIZZLE_TYPE_VARCHAR,
287
 
    //DRIZZLE_TYPE_LONGLONG
288
 
    DRIZZLE_TYPE_DECIMAL,
289
 
    //DRIZZLE_TYPE_DATETIME
290
 
    DRIZZLE_TYPE_VARCHAR,
291
 
    //DRIZZLE_TYPE_DATE
292
 
    DRIZZLE_TYPE_VARCHAR,
293
 
    //DRIZZLE_TYPE_VARCHAR
294
 
    DRIZZLE_TYPE_VARCHAR,
295
 
    //DRIZZLE_TYPE_DECIMAL
296
 
    DRIZZLE_TYPE_DECIMAL,
297
 
    //DRIZZLE_TYPE_ENUM
298
 
    DRIZZLE_TYPE_VARCHAR,
299
 
    //DRIZZLE_TYPE_BLOB
 
322
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
323
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
324
  //DRIZZLE_TYPE_LONGLONG
 
325
    DRIZZLE_TYPE_NEWDECIMAL,
 
326
  //DRIZZLE_TYPE_TIME
 
327
    DRIZZLE_TYPE_VARCHAR,
 
328
  //DRIZZLE_TYPE_DATETIME
 
329
    DRIZZLE_TYPE_VARCHAR,
 
330
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
331
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
332
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
333
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
334
  //DRIZZLE_TYPE_BLOB
300
335
    DRIZZLE_TYPE_BLOB,
301
 
    //DRIZZLE_TYPE_UUID
302
 
    DRIZZLE_TYPE_VARCHAR,
303
336
  },
304
337
  /* DRIZZLE_TYPE_ENUM -> */
305
338
  {
306
 
    //DRIZZLE_TYPE_LONG
307
 
    DRIZZLE_TYPE_VARCHAR,
308
 
    //DRIZZLE_TYPE_DOUBLE
309
 
    DRIZZLE_TYPE_VARCHAR,
310
 
    //DRIZZLE_TYPE_NULL
311
 
    DRIZZLE_TYPE_ENUM,
312
 
    //DRIZZLE_TYPE_TIMESTAMP
313
 
    DRIZZLE_TYPE_VARCHAR,
314
 
    //DRIZZLE_TYPE_LONGLONG
315
 
    DRIZZLE_TYPE_VARCHAR,
316
 
    //DRIZZLE_TYPE_DATETIME
317
 
    DRIZZLE_TYPE_VARCHAR,
318
 
    //DRIZZLE_TYPE_DATE
319
 
    DRIZZLE_TYPE_VARCHAR,
320
 
    //DRIZZLE_TYPE_VARCHAR
321
 
    DRIZZLE_TYPE_VARCHAR,
322
 
    //DRIZZLE_TYPE_DECIMAL
323
 
    DRIZZLE_TYPE_VARCHAR,
324
 
    //DRIZZLE_TYPE_ENUM
325
 
    DRIZZLE_TYPE_VARCHAR,
326
 
    //DRIZZLE_TYPE_BLOB
 
339
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
340
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
341
  //DRIZZLE_TYPE_LONG
 
342
    DRIZZLE_TYPE_VARCHAR,
 
343
  //DRIZZLE_TYPE_DOUBLE
 
344
    DRIZZLE_TYPE_VARCHAR,
 
345
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
346
    DRIZZLE_TYPE_ENUM,        DRIZZLE_TYPE_VARCHAR,
 
347
  //DRIZZLE_TYPE_LONGLONG
 
348
    DRIZZLE_TYPE_VARCHAR,
 
349
  //DRIZZLE_TYPE_TIME
 
350
    DRIZZLE_TYPE_VARCHAR,
 
351
  //DRIZZLE_TYPE_DATETIME
 
352
    DRIZZLE_TYPE_VARCHAR,
 
353
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
354
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
355
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
356
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
357
  //DRIZZLE_TYPE_BLOB
327
358
    DRIZZLE_TYPE_BLOB,
328
 
    //DRIZZLE_TYPE_UUID
329
 
    DRIZZLE_TYPE_VARCHAR,
330
 
   },
 
359
  },
331
360
  /* DRIZZLE_TYPE_BLOB -> */
332
361
  {
333
 
    //DRIZZLE_TYPE_LONG
334
 
    DRIZZLE_TYPE_BLOB,
335
 
    //DRIZZLE_TYPE_DOUBLE
336
 
    DRIZZLE_TYPE_BLOB,
337
 
    //DRIZZLE_TYPE_NULL
338
 
    DRIZZLE_TYPE_BLOB,
339
 
    //DRIZZLE_TYPE_TIMESTAMP
340
 
    DRIZZLE_TYPE_BLOB,
341
 
    //DRIZZLE_TYPE_LONGLONG
342
 
    DRIZZLE_TYPE_BLOB,
343
 
    //DRIZZLE_TYPE_DATETIME
344
 
    DRIZZLE_TYPE_BLOB,
345
 
    //DRIZZLE_TYPE_DATE
346
 
    DRIZZLE_TYPE_BLOB,
347
 
    //DRIZZLE_TYPE_VARCHAR
348
 
    DRIZZLE_TYPE_BLOB,
349
 
    //DRIZZLE_TYPE_DECIMAL
350
 
    DRIZZLE_TYPE_BLOB,
351
 
    //DRIZZLE_TYPE_ENUM
352
 
    DRIZZLE_TYPE_BLOB,
353
 
    //DRIZZLE_TYPE_BLOB
354
 
    DRIZZLE_TYPE_BLOB,
355
 
    //DRIZZLE_TYPE_UUID
356
 
    DRIZZLE_TYPE_VARCHAR,
357
 
  },
358
 
  /* DRIZZLE_TYPE_UUID -> */
359
 
  {
360
 
    //DRIZZLE_TYPE_LONG
361
 
    DRIZZLE_TYPE_VARCHAR,
362
 
    //DRIZZLE_TYPE_DOUBLE
363
 
    DRIZZLE_TYPE_VARCHAR,
364
 
    //DRIZZLE_TYPE_NULL
365
 
    DRIZZLE_TYPE_UUID,
366
 
    //DRIZZLE_TYPE_TIMESTAMP
367
 
    DRIZZLE_TYPE_VARCHAR,
368
 
    //DRIZZLE_TYPE_LONGLONG
369
 
    DRIZZLE_TYPE_VARCHAR,
370
 
    //DRIZZLE_TYPE_DATETIME
371
 
    DRIZZLE_TYPE_VARCHAR,
372
 
    //DRIZZLE_TYPE_DATE
373
 
    DRIZZLE_TYPE_VARCHAR,
374
 
    //DRIZZLE_TYPE_VARCHAR
375
 
    DRIZZLE_TYPE_VARCHAR,
376
 
    //DRIZZLE_TYPE_DECIMAL
377
 
    DRIZZLE_TYPE_VARCHAR,
378
 
    //DRIZZLE_TYPE_VARCHAR,
379
 
    DRIZZLE_TYPE_VARCHAR,
380
 
    //DRIZZLE_TYPE_BLOB
381
 
    DRIZZLE_TYPE_BLOB,
382
 
    //DRIZZLE_TYPE_UUID
383
 
    DRIZZLE_TYPE_UUID,
 
362
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
363
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
 
364
  //DRIZZLE_TYPE_LONG
 
365
    DRIZZLE_TYPE_BLOB,
 
366
  //DRIZZLE_TYPE_DOUBLE
 
367
    DRIZZLE_TYPE_BLOB,
 
368
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
369
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
 
370
  //DRIZZLE_TYPE_LONGLONG
 
371
    DRIZZLE_TYPE_BLOB,
 
372
  //DRIZZLE_TYPE_TIME
 
373
    DRIZZLE_TYPE_BLOB,
 
374
  //DRIZZLE_TYPE_DATETIME
 
375
    DRIZZLE_TYPE_BLOB,
 
376
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
377
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
 
378
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
379
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
 
380
  //DRIZZLE_TYPE_BLOB
 
381
    DRIZZLE_TYPE_BLOB,
384
382
  },
385
383
};
386
384
 
387
 
static Item_result field_types_result_type [enum_field_types_size]=
388
 
{
 
385
/**
 
386
  Return type of which can carry value of both given types in UNION result.
 
387
 
 
388
  @param a  type for merging
 
389
  @param b  type for merging
 
390
 
 
391
  @return
 
392
    type of field
 
393
*/
 
394
 
 
395
enum_field_types Field::field_type_merge(enum_field_types a,
 
396
                                         enum_field_types b)
 
397
{
 
398
  assert(a < FIELDTYPE_TEAR_FROM || a > FIELDTYPE_TEAR_TO);
 
399
  assert(b < FIELDTYPE_TEAR_FROM || b > FIELDTYPE_TEAR_TO);
 
400
  return field_types_merge_rules[field_type2index(a)]
 
401
                                [field_type2index(b)];
 
402
}
 
403
 
 
404
 
 
405
static Item_result field_types_result_type [FIELDTYPE_NUM]=
 
406
{
 
407
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
408
  DECIMAL_RESULT,           INT_RESULT,
389
409
  //DRIZZLE_TYPE_LONG
390
410
  INT_RESULT,
391
411
  //DRIZZLE_TYPE_DOUBLE
392
412
  REAL_RESULT,
393
 
  //DRIZZLE_TYPE_NULL
394
 
  STRING_RESULT,
395
 
  //DRIZZLE_TYPE_TIMESTAMP
396
 
  STRING_RESULT,
 
413
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
414
  STRING_RESULT,            STRING_RESULT,
397
415
  //DRIZZLE_TYPE_LONGLONG
398
416
  INT_RESULT,
 
417
  //DRIZZLE_TYPE_TIME
 
418
  STRING_RESULT,
399
419
  //DRIZZLE_TYPE_DATETIME
400
420
  STRING_RESULT,
401
 
  //DRIZZLE_TYPE_DATE
402
 
  STRING_RESULT,
403
 
  //DRIZZLE_TYPE_VARCHAR
404
 
  STRING_RESULT,
405
 
  //DRIZZLE_TYPE_DECIMAL   
406
 
  DECIMAL_RESULT,           
407
 
  //DRIZZLE_TYPE_ENUM
408
 
  STRING_RESULT,
 
421
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
422
  STRING_RESULT,            STRING_RESULT,
 
423
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
424
  DECIMAL_RESULT,           STRING_RESULT,
409
425
  //DRIZZLE_TYPE_BLOB
410
426
  STRING_RESULT,
411
 
  //DRIZZLE_TYPE_UUID
412
 
  STRING_RESULT,
413
427
};
414
428
 
415
 
bool test_if_important_data(const CHARSET_INFO * const cs, 
416
 
                            const char *str,
417
 
                            const char *strend)
 
429
 
 
430
/*
 
431
  Test if the given string contains important data:
 
432
  not spaces for character string,
 
433
  or any data for binary string.
 
434
 
 
435
  SYNOPSIS
 
436
    test_if_important_data()
 
437
    cs          Character set
 
438
    str         String to test
 
439
    strend      String end
 
440
 
 
441
  RETURN
 
442
    false - If string does not have important data
 
443
    true  - If string has some important data
 
444
*/
 
445
 
 
446
bool
 
447
test_if_important_data(const CHARSET_INFO * const cs, const char *str,
 
448
                       const char *strend)
418
449
{
419
450
  if (cs != &my_charset_bin)
420
451
    str+= cs->cset->scan(cs, str, strend, MY_SEQ_SPACES);
421
452
  return (str < strend);
422
453
}
423
454
 
424
 
void *Field::operator new(size_t size)
425
 
{
426
 
  return memory::sql_alloc(size);
427
 
}
428
 
 
429
 
void *Field::operator new(size_t size, memory::Root *mem_root)
430
 
{
431
 
  return mem_root->alloc_root(static_cast<uint32_t>(size));
432
 
}
433
 
 
434
 
enum_field_types Field::field_type_merge(enum_field_types a,
435
 
                                         enum_field_types b)
436
 
{
437
 
  assert(a < enum_field_types_size);
438
 
  assert(b < enum_field_types_size);
439
 
  return field_types_merge_rules[a][b];
440
 
}
 
455
 
 
456
/**
 
457
  Detect Item_result by given field type of UNION merge result.
 
458
 
 
459
  @param field_type  given field type
 
460
 
 
461
  @return
 
462
    Item_result (type of internal MySQL expression result)
 
463
*/
441
464
 
442
465
Item_result Field::result_merge_type(enum_field_types field_type)
443
466
{
444
 
  assert(field_type < enum_field_types_size);
445
 
  return field_types_result_type[field_type];
446
 
}
447
 
 
448
 
bool Field::eq(Field *field)
449
 
{
450
 
  return (ptr == field->ptr && null_ptr == field->null_ptr &&
451
 
          null_bit == field->null_bit);
452
 
}
453
 
 
454
 
uint32_t Field::pack_length() const
455
 
{
456
 
  return field_length;
457
 
}
458
 
 
459
 
uint32_t Field::pack_length_in_rec() const
460
 
{
461
 
  return pack_length();
462
 
}
463
 
 
464
 
uint32_t Field::data_length()
465
 
{
466
 
  return pack_length();
467
 
}
468
 
 
469
 
uint32_t Field::used_length()
470
 
{
471
 
  return pack_length();
472
 
}
473
 
 
474
 
uint32_t Field::sort_length() const
475
 
{
476
 
  return pack_length();
477
 
}
478
 
 
479
 
uint32_t Field::max_data_length() const
480
 
{
481
 
  return pack_length();
482
 
}
483
 
 
484
 
int Field::reset(void)
485
 
{
486
 
  memset(ptr, 0, pack_length());
487
 
  return 0;
488
 
}
489
 
 
490
 
void Field::reset_fields()
491
 
{}
492
 
 
493
 
void Field::set_default()
494
 
{
495
 
  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->getInsertRecord());
496
 
  memcpy(ptr, ptr + l_offset, pack_length());
497
 
  if (null_ptr)
498
 
    *null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
499
 
 
500
 
  if (this == table->next_number_field)
501
 
    table->auto_increment_field_not_null= false;
502
 
}
503
 
 
504
 
bool Field::binary() const
505
 
{
506
 
  return true;
507
 
}
508
 
 
509
 
bool Field::zero_pack() const
510
 
{
511
 
  return true;
512
 
}
513
 
 
514
 
enum ha_base_keytype Field::key_type() const
515
 
{
516
 
  return HA_KEYTYPE_BINARY;
517
 
}
518
 
 
519
 
uint32_t Field::key_length() const
520
 
{
521
 
  return pack_length();
522
 
}
523
 
 
524
 
enum_field_types Field::real_type() const
525
 
{
526
 
  return type();
527
 
}
528
 
 
529
 
int Field::cmp_max(const unsigned char *a, const unsigned char *b, uint32_t)
530
 
{
531
 
  return cmp(a, b);
532
 
}
533
 
 
534
 
int Field::cmp_binary(const unsigned char *a,const unsigned char *b, uint32_t)
535
 
{
536
 
  return memcmp(a,b,pack_length());
537
 
}
538
 
 
539
 
int Field::cmp_offset(uint32_t row_offset)
540
 
{
541
 
  return cmp(ptr,ptr+row_offset);
542
 
}
543
 
 
544
 
int Field::cmp_binary_offset(uint32_t row_offset)
545
 
{
546
 
  return cmp_binary(ptr, ptr+row_offset);
547
 
}
548
 
 
549
 
int Field::key_cmp(const unsigned char *a,const unsigned char *b)
550
 
{
551
 
  return cmp(a, b);
552
 
}
553
 
 
554
 
int Field::key_cmp(const unsigned char *str, uint32_t)
555
 
{
556
 
  return cmp(ptr,str);
557
 
}
558
 
 
559
 
uint32_t Field::decimals() const
560
 
{
561
 
  return 0;
562
 
}
563
 
 
564
 
bool Field::is_null(ptrdiff_t row_offset)
565
 
{
566
 
  return null_ptr ?
567
 
    (null_ptr[row_offset] & null_bit ? true : false) :
568
 
    table->null_row;
569
 
}
570
 
 
571
 
bool Field::is_real_null(ptrdiff_t row_offset)
572
 
{
573
 
  return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : false;
574
 
}
575
 
 
576
 
bool Field::is_null_in_record(const unsigned char *record)
577
 
{
578
 
  if (! null_ptr)
579
 
    return false;
580
 
  return test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
581
 
}
582
 
 
583
 
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset)
584
 
{
585
 
  if (! null_ptr)
586
 
    return false;
587
 
  return test(null_ptr[with_offset] & null_bit);
588
 
}
589
 
 
590
 
void Field::set_null(ptrdiff_t row_offset)
591
 
{
592
 
  if (null_ptr)
593
 
    null_ptr[row_offset]|= null_bit;
594
 
}
595
 
 
596
 
void Field::set_notnull(ptrdiff_t row_offset)
597
 
{
598
 
  if (null_ptr)
599
 
    null_ptr[row_offset]&= (unsigned char) ~null_bit;
600
 
}
601
 
 
602
 
bool Field::maybe_null(void)
603
 
{
604
 
  return null_ptr != 0 || table->maybe_null;
605
 
}
606
 
 
607
 
bool Field::real_maybe_null(void)
608
 
{
609
 
  return null_ptr != 0;
610
 
}
 
467
  assert(field_type < FIELDTYPE_TEAR_FROM || field_type
 
468
              > FIELDTYPE_TEAR_TO);
 
469
  return field_types_result_type[field_type2index(field_type)];
 
470
}
 
471
 
 
472
/*****************************************************************************
 
473
  Static help functions
 
474
*****************************************************************************/
 
475
 
 
476
 
 
477
/**
 
478
  Check whether a field type can be partially indexed by a key.
 
479
 
 
480
  This is a static method, rather than a virtual function, because we need
 
481
  to check the type of a non-Field in mysql_alter_table().
 
482
 
 
483
  @param type  field type
 
484
 
 
485
  @retval
 
486
    true  Type can have a prefixed key
 
487
  @retval
 
488
    false Type can not have a prefixed key
 
489
*/
611
490
 
612
491
bool Field::type_can_have_key_part(enum enum_field_types type)
613
492
{
620
499
  }
621
500
}
622
501
 
 
502
 
 
503
/**
 
504
  Process decimal library return codes and issue warnings for overflow and
 
505
  truncation.
 
506
 
 
507
  @param op_result  decimal library return code (E_DEC_* see include/decimal.h)
 
508
 
 
509
  @retval
 
510
    1  there was overflow
 
511
  @retval
 
512
    0  no error or some other errors except overflow
 
513
*/
 
514
 
623
515
int Field::warn_if_overflow(int op_result)
624
516
{
625
517
  if (op_result == E_DEC_OVERFLOW)
626
518
  {
627
519
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
628
 
    return E_DEC_OVERFLOW;
 
520
    return 1;
629
521
  }
630
522
  if (op_result == E_DEC_TRUNCATED)
631
523
  {
632
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
633
 
    return E_DEC_TRUNCATED;
 
524
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_NOTE, ER_WARN_DATA_TRUNCATED, 1);
 
525
    /* We return 0 here as this is not a critical issue */
634
526
  }
635
527
  return 0;
636
528
}
637
529
 
638
 
void Field::init(Table *table_arg)
639
 
{
640
 
  orig_table= table= table_arg;
641
 
}
 
530
 
 
531
#ifdef NOT_USED
 
532
static bool test_if_real(const char *str,int length, const CHARSET_INFO * const cs)
 
533
{
 
534
  cs= system_charset_info; // QQ move test_if_real into CHARSET_INFO struct
 
535
 
 
536
  while (length && my_isspace(cs,*str))
 
537
  {                                             // Allow start space
 
538
    length--; str++;
 
539
  }
 
540
  if (!length)
 
541
    return 0;
 
542
  if (*str == '+' || *str == '-')
 
543
  {
 
544
    length--; str++;
 
545
    if (!length || !(my_isdigit(cs,*str) || *str == '.'))
 
546
      return 0;
 
547
  }
 
548
  while (length && my_isdigit(cs,*str))
 
549
  {
 
550
    length--; str++;
 
551
  }
 
552
  if (!length)
 
553
    return 1;
 
554
  if (*str == '.')
 
555
  {
 
556
    length--; str++;
 
557
    while (length && my_isdigit(cs,*str))
 
558
    {
 
559
      length--; str++;
 
560
    }
 
561
  }
 
562
  if (!length)
 
563
    return 1;
 
564
  if (*str == 'E' || *str == 'e')
 
565
  {
 
566
    if (length < 3 || (str[1] != '+' && str[1] != '-') || 
 
567
        !my_isdigit(cs,str[2]))
 
568
      return 0;
 
569
    length-=3;
 
570
    str+=3;
 
571
    while (length && my_isdigit(cs,*str))
 
572
    {
 
573
      length--; str++;
 
574
    }
 
575
  }
 
576
  for (; length ; length--, str++)
 
577
  {                                             // Allow end space
 
578
    if (!my_isspace(cs,*str))
 
579
      return 0;
 
580
  }
 
581
  return 1;
 
582
}
 
583
#endif
 
584
 
 
585
 
 
586
/**
 
587
  Interpret field value as an integer but return the result as a string.
 
588
 
 
589
  This is used for printing bit_fields as numbers while debugging.
 
590
*/
 
591
 
 
592
String *Field::val_int_as_str(String *val_buffer, bool unsigned_val)
 
593
{
 
594
  const CHARSET_INFO * const cs= &my_charset_bin;
 
595
  uint32_t length;
 
596
  int64_t value= val_int();
 
597
 
 
598
  if (val_buffer->alloc(MY_INT64_NUM_DECIMAL_DIGITS))
 
599
    return 0;
 
600
  length= (uint32_t) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
 
601
                                                MY_INT64_NUM_DECIMAL_DIGITS,
 
602
                                                unsigned_val ? 10 : -10,
 
603
                                                value);
 
604
  val_buffer->length(length);
 
605
  return val_buffer;
 
606
}
 
607
 
642
608
 
643
609
/// This is used as a table name when the table structure is not set up
644
 
Field::Field(unsigned char *ptr_arg,
645
 
             uint32_t length_arg,
646
 
             unsigned char *null_ptr_arg,
647
 
             unsigned char null_bit_arg,
648
 
             utype unireg_check_arg, 
649
 
             const char *field_name_arg)
650
 
  :
651
 
    ptr(ptr_arg),
652
 
    null_ptr(null_ptr_arg),
653
 
    table(NULL),
654
 
    orig_table(NULL),
655
 
    field_name(field_name_arg),
656
 
    key_start(0),
657
 
    part_of_key(0),
658
 
    part_of_key_not_clustered(0),
659
 
    part_of_sortkey(0),
660
 
    unireg_check(unireg_check_arg),
661
 
    field_length(length_arg),
662
 
    null_bit(null_bit_arg),
663
 
    is_created_from_null_item(false)
 
610
Field::Field(unsigned char *ptr_arg,uint32_t length_arg,unsigned char *null_ptr_arg,
 
611
             unsigned char null_bit_arg,
 
612
             utype unireg_check_arg, const char *field_name_arg)
 
613
  :ptr(ptr_arg), null_ptr(null_ptr_arg),
 
614
   table(0), orig_table(0), table_name(0),
 
615
   field_name(field_name_arg),
 
616
   key_start(0), part_of_key(0), part_of_key_not_clustered(0),
 
617
   part_of_sortkey(0), unireg_check(unireg_check_arg),
 
618
   field_length(length_arg), null_bit(null_bit_arg), 
 
619
   is_created_from_null_item(false)
664
620
{
665
 
  flags= null_ptr ? 0: NOT_NULL_FLAG;
 
621
  flags=null_ptr ? 0: NOT_NULL_FLAG;
666
622
  comment.str= (char*) "";
667
 
  comment.length= 0;
 
623
  comment.length=0;
668
624
  field_index= 0;
669
625
}
670
626
 
 
627
 
671
628
void Field::hash(uint32_t *nr, uint32_t *nr2)
672
629
{
673
630
  if (is_null())
682
639
  }
683
640
}
684
641
 
 
642
size_t
 
643
Field::do_last_null_byte() const
 
644
{
 
645
  assert(null_ptr == NULL || null_ptr >= table->record[0]);
 
646
  if (null_ptr)
 
647
    return (size_t) (null_ptr - table->record[0]) + 1;
 
648
  return LAST_NULL_BYTE_UNDEF;
 
649
}
 
650
 
 
651
 
685
652
void Field::copy_from_tmp(int row_offset)
686
653
{
687
654
  memcpy(ptr,ptr+row_offset,pack_length());
688
655
  if (null_ptr)
689
656
  {
690
 
    *null_ptr= (unsigned char) ((null_ptr[0] &
691
 
                                 (unsigned char) ~(uint32_t) null_bit) |
692
 
                                (null_ptr[row_offset] &
693
 
                                 (unsigned char) null_bit));
 
657
    *null_ptr= (unsigned char) ((null_ptr[0] & (unsigned char) ~(uint32_t) null_bit) | (null_ptr[row_offset] & (unsigned char) null_bit));
694
658
  }
695
659
}
696
660
 
697
 
int Field::store_and_check(enum_check_fields check_level,
698
 
                           const char *to, 
699
 
                           uint32_t length,
700
 
                           const CHARSET_INFO * const cs)
701
 
 
 
661
 
 
662
bool Field::send_binary(Protocol *protocol)
 
663
{
 
664
  char buff[MAX_FIELD_WIDTH];
 
665
  String tmp(buff,sizeof(buff),charset());
 
666
  val_str(&tmp);
 
667
  return protocol->store(tmp.ptr(), tmp.length(), tmp.charset());
 
668
}
 
669
 
 
670
 
 
671
/**
 
672
   Check to see if field size is compatible with destination.
 
673
 
 
674
   This method is used in row-based replication to verify that the slave's
 
675
   field size is less than or equal to the master's field size. The 
 
676
   encoded field metadata (from the master or source) is decoded and compared
 
677
   to the size of this field (the slave or destination). 
 
678
 
 
679
   @param   field_metadata   Encoded size in field metadata
 
680
 
 
681
   @retval 0 if this field's size is < the source field's size
 
682
   @retval 1 if this field's size is >= the source field's size
 
683
*/
 
684
int Field::compatible_field_size(uint32_t field_metadata)
 
685
{
 
686
  uint32_t const source_size= pack_length_from_metadata(field_metadata);
 
687
  uint32_t const destination_size= row_pack_length();
 
688
  return (source_size <= destination_size);
 
689
}
 
690
 
 
691
 
 
692
int Field::store(const char *to, uint32_t length, const CHARSET_INFO * const cs,
 
693
                 enum_check_fields check_level)
702
694
{
703
695
  int res;
704
696
  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
708
700
  return res;
709
701
}
710
702
 
711
 
unsigned char *Field::pack(unsigned char *to, const unsigned char *from, uint32_t max_length, bool)
 
703
 
 
704
/**
 
705
   Pack the field into a format suitable for storage and transfer.
 
706
 
 
707
   To implement packing functionality, only the virtual function
 
708
   should be overridden. The other functions are just convenience
 
709
   functions and hence should not be overridden.
 
710
 
 
711
   The value of <code>low_byte_first</code> is dependent on how the
 
712
   packed data is going to be used: for local use, e.g., temporary
 
713
   store on disk or in memory, use the native format since that is
 
714
   faster. For data that is going to be transfered to other machines
 
715
   (e.g., when writing data to the binary log), data should always be
 
716
   stored in little-endian format.
 
717
 
 
718
   @note The default method for packing fields just copy the raw bytes
 
719
   of the record into the destination, but never more than
 
720
   <code>max_length</code> characters.
 
721
 
 
722
   @param to
 
723
   Pointer to memory area where representation of field should be put.
 
724
 
 
725
   @param from
 
726
   Pointer to memory area where record representation of field is
 
727
   stored.
 
728
 
 
729
   @param max_length
 
730
   Maximum length of the field, as given in the column definition. For
 
731
   example, for <code>CHAR(1000)</code>, the <code>max_length</code>
 
732
   is 1000. This information is sometimes needed to decide how to pack
 
733
   the data.
 
734
 
 
735
   @param low_byte_first
 
736
   @c true if integers should be stored little-endian, @c false if
 
737
   native format should be used. Note that for little-endian machines,
 
738
   the value of this flag is a moot point since the native format is
 
739
   little-endian.
 
740
*/
 
741
unsigned char *
 
742
Field::pack(unsigned char *to, const unsigned char *from, uint32_t max_length,
 
743
            bool low_byte_first __attribute__((unused)))
712
744
{
713
745
  uint32_t length= pack_length();
714
746
  set_if_smaller(length, max_length);
716
748
  return to+length;
717
749
}
718
750
 
719
 
unsigned char *Field::pack(unsigned char *to, const unsigned char *from)
720
 
{
721
 
  unsigned char *result= this->pack(to, from, UINT32_MAX, table->getShare()->db_low_byte_first);
722
 
  return(result);
723
 
}
724
 
 
725
 
const unsigned char *Field::unpack(unsigned char* to,
726
 
                                   const unsigned char *from, 
727
 
                                   uint32_t param_data,
728
 
                                   bool)
 
751
/**
 
752
   Unpack a field from row data.
 
753
 
 
754
   This method is used to unpack a field from a master whose size of
 
755
   the field is less than that of the slave.
 
756
 
 
757
   The <code>param_data</code> parameter is a two-byte integer (stored
 
758
   in the least significant 16 bits of the unsigned integer) usually
 
759
   consisting of two parts: the real type in the most significant byte
 
760
   and a original pack length in the least significant byte.
 
761
 
 
762
   The exact layout of the <code>param_data</code> field is given by
 
763
   the <code>Table_map_log_event::save_field_metadata()</code>.
 
764
 
 
765
   This is the default method for unpacking a field. It just copies
 
766
   the memory block in byte order (of original pack length bytes or
 
767
   length of field, whichever is smaller).
 
768
 
 
769
   @param   to         Destination of the data
 
770
   @param   from       Source of the data
 
771
   @param   param_data Real type and original pack length of the field
 
772
                       data
 
773
 
 
774
   @param low_byte_first
 
775
   If this flag is @c true, all composite entities (e.g., lengths)
 
776
   should be unpacked in little-endian format; otherwise, the entities
 
777
   are unpacked in native order.
 
778
 
 
779
   @return  New pointer into memory based on from + length of the data
 
780
*/
 
781
const unsigned char *
 
782
Field::unpack(unsigned char* to, const unsigned char *from, uint32_t param_data,
 
783
              bool low_byte_first __attribute__((unused)))
729
784
{
730
785
  uint32_t length=pack_length();
731
786
  int from_type= 0;
751
806
            param_data : length;
752
807
 
753
808
  memcpy(to, from, param_data > length ? length : len);
754
 
  return (from + len);
755
 
}
756
 
 
757
 
const unsigned char *Field::unpack(unsigned char* to, const unsigned char *from)
758
 
{
759
 
  const unsigned char *result= unpack(to, from, 0U, table->getShare()->db_low_byte_first);
760
 
  return(result);
761
 
}
762
 
 
763
 
my_decimal *Field::val_decimal(my_decimal *)
 
809
  return from+len;
 
810
}
 
811
 
 
812
 
 
813
my_decimal *Field::val_decimal(my_decimal *decimal __attribute__((unused)))
764
814
{
765
815
  /* This never have to be called */
766
816
  assert(0);
768
818
}
769
819
 
770
820
 
771
 
void Field::make_field(SendField *field)
 
821
void Field::make_field(Send_field *field)
772
822
{
773
 
  if (orig_table && orig_table->getShare()->getSchemaName() && *orig_table->getShare()->getSchemaName())
 
823
  if (orig_table && orig_table->s->db.str && *orig_table->s->db.str)
774
824
  {
775
 
    field->db_name= orig_table->getShare()->getSchemaName();
776
 
    field->org_table_name= orig_table->getShare()->getTableName();
 
825
    field->db_name= orig_table->s->db.str;
 
826
    field->org_table_name= orig_table->s->table_name.str;
777
827
  }
778
828
  else
779
829
    field->org_table_name= field->db_name= "";
780
830
  if (orig_table)
781
831
  {
782
 
    field->table_name= orig_table->getAlias();
 
832
    field->table_name= orig_table->alias;
783
833
    field->org_col_name= field_name;
784
834
  }
785
835
  else
789
839
  }
790
840
  field->col_name= field_name;
791
841
  field->charsetnr= charset()->number;
792
 
  field->length= field_length;
793
 
  field->type= type();
794
 
  field->flags= table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
 
842
  field->length=field_length;
 
843
  field->type=type();
 
844
  field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
795
845
  field->decimals= 0;
796
846
}
797
847
 
798
 
int64_t Field::convert_decimal2int64_t(const my_decimal *val, bool, int *err)
 
848
 
 
849
/**
 
850
  Conversion from decimal to int64_t with checking overflow and
 
851
  setting correct value (min/max) in case of overflow.
 
852
 
 
853
  @param val             value which have to be converted
 
854
  @param unsigned_flag   type of integer in which we convert val
 
855
  @param err             variable to pass error code
 
856
 
 
857
  @return
 
858
    value converted from val
 
859
*/
 
860
int64_t Field::convert_decimal2int64_t(const my_decimal *val,
 
861
                                         bool unsigned_flag, int *err)
799
862
{
800
863
  int64_t i;
801
 
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
802
 
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
803
 
                                      val, false, &i)))
 
864
  if (unsigned_flag)
 
865
  {
 
866
    if (val->sign())
 
867
    {
 
868
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
869
      i= 0;
 
870
      *err= 1;
 
871
    }
 
872
    else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
 
873
                                           ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
 
874
                                           val, true, &i)))
 
875
    {
 
876
      i= ~(int64_t) 0;
 
877
      *err= 1;
 
878
    }
 
879
  }
 
880
  else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
 
881
                                         ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
 
882
                                         val, false, &i)))
804
883
  {
805
884
    i= (val->sign() ? INT64_MIN : INT64_MAX);
806
885
    *err= 1;
808
887
  return i;
809
888
}
810
889
 
811
 
uint32_t Field::fill_cache_field(CacheField *copy)
 
890
uint32_t Field::fill_cache_field(CACHE_FIELD *copy)
812
891
{
813
892
  uint32_t store_length;
814
893
  copy->str=ptr;
818
897
  {
819
898
    copy->blob_field=(Field_blob*) this;
820
899
    copy->strip=0;
821
 
    copy->length-= table->getShare()->blob_ptr_size;
 
900
    copy->length-= table->s->blob_ptr_size;
822
901
    return copy->length;
823
902
  }
824
903
  else
829
908
  return copy->length+ store_length;
830
909
}
831
910
 
 
911
 
832
912
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
833
913
{
834
914
  char buff[40];
835
915
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
836
 
  if (!(res=val_str_internal(&tmp)) || str_to_datetime_with_warn(res->ptr(), res->length(),
837
 
                                                                 ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
838
 
  {
 
916
  if (!(res=val_str(&tmp)) ||
 
917
      str_to_datetime_with_warn(res->ptr(), res->length(),
 
918
                                ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
839
919
    return 1;
840
 
  }
841
 
 
842
920
  return 0;
843
921
}
844
922
 
846
924
{
847
925
  char buff[40];
848
926
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
849
 
 
850
 
  if (!(res=val_str_internal(&tmp)) || str_to_time_with_warn(res->ptr(), res->length(), ltime))
851
 
  {
 
927
  if (!(res=val_str(&tmp)) ||
 
928
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
852
929
    return 1;
853
 
  }
854
 
 
855
930
  return 0;
856
931
}
857
932
 
858
 
int Field::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
 
933
/**
 
934
  This is called when storing a date in a string.
 
935
 
 
936
  @note
 
937
    Needs to be changed if/when we want to support different time formats.
 
938
*/
 
939
 
 
940
int Field::store_time(DRIZZLE_TIME *ltime,
 
941
                      enum enum_drizzle_timestamp_type type_arg __attribute__((unused)))
859
942
{
860
943
  char buff[MAX_DATE_STRING_REP_LENGTH];
861
944
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
862
945
  return store(buff, length, &my_charset_bin);
863
946
}
864
947
 
865
 
bool Field::optimize_range(uint32_t idx, uint32_t)
 
948
 
 
949
bool Field::optimize_range(uint32_t idx, uint32_t part)
866
950
{
867
 
  return test(table->index_flags(idx) & HA_READ_RANGE);
 
951
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
868
952
}
869
953
 
870
 
Field *Field::new_field(memory::Root *root, Table *new_table, bool)
 
954
 
 
955
Field *Field::new_field(MEM_ROOT *root, Table *new_table,
 
956
                        bool keep_type __attribute__((unused)))
871
957
{
872
958
  Field *tmp;
873
 
  if (!(tmp= (Field*) root->memdup_root((char*) this,size_of())))
 
959
  if (!(tmp= (Field*) memdup_root(root,(char*) this,size_of())))
874
960
    return 0;
875
961
 
876
962
  if (tmp->table->maybe_null)
877
963
    tmp->flags&= ~NOT_NULL_FLAG;
878
964
  tmp->table= new_table;
879
 
  tmp->key_start.reset();
880
 
  tmp->part_of_key.reset();
881
 
  tmp->part_of_sortkey.reset();
 
965
  tmp->key_start.init(0);
 
966
  tmp->part_of_key.init(0);
 
967
  tmp->part_of_sortkey.init(0);
882
968
  tmp->unireg_check= Field::NONE;
883
 
  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | BINARY_FLAG | ENUM_FLAG);
 
969
  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
884
970
  tmp->reset_fields();
885
971
  return tmp;
886
972
}
887
973
 
888
 
Field *Field::new_key_field(memory::Root *root, Table *new_table,
889
 
                            unsigned char *new_ptr,
890
 
                            unsigned char *new_null_ptr,
 
974
 
 
975
Field *Field::new_key_field(MEM_ROOT *root, Table *new_table,
 
976
                            unsigned char *new_ptr, unsigned char *new_null_ptr,
891
977
                            uint32_t new_null_bit)
892
978
{
893
979
  Field *tmp;
894
980
  if ((tmp= new_field(root, new_table, table == new_table)))
895
981
  {
896
 
    tmp->ptr= new_ptr;
 
982
    tmp->ptr=      new_ptr;
897
983
    tmp->null_ptr= new_null_ptr;
898
984
    tmp->null_bit= new_null_bit;
899
985
  }
900
986
  return tmp;
901
987
}
902
988
 
903
 
Field *Field::clone(memory::Root *root, Table *new_table)
 
989
 
 
990
/* This is used to generate a field in Table from TABLE_SHARE */
 
991
 
 
992
Field *Field::clone(MEM_ROOT *root, Table *new_table)
904
993
{
905
994
  Field *tmp;
906
 
  if ((tmp= (Field*) root->memdup_root((char*) this,size_of())))
 
995
  if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
907
996
  {
908
997
    tmp->init(new_table);
909
 
    tmp->move_field_offset((ptrdiff_t) (new_table->getInsertRecord() -
910
 
                                           new_table->getDefaultValues()));
 
998
    tmp->move_field_offset((my_ptrdiff_t) (new_table->record[0] -
 
999
                                           new_table->s->default_values));
911
1000
  }
912
1001
  return tmp;
913
1002
}
914
1003
 
915
1004
 
916
 
uint32_t Field::is_equal(CreateField *new_field_ptr)
917
 
{
918
 
  return (new_field_ptr->sql_type == real_type());
919
 
}
 
1005
/****************************************************************************
 
1006
** tiny int
 
1007
****************************************************************************/
 
1008
 
 
1009
int Field_tiny::store(const char *from,uint32_t len, const CHARSET_INFO * const cs)
 
1010
{
 
1011
  int error;
 
1012
  int64_t rnd;
 
1013
  
 
1014
  error= get_int(cs, from, len, &rnd, 255, -128, 127);
 
1015
  ptr[0]= unsigned_flag ? (char) (uint64_t) rnd : (char) rnd;
 
1016
  return error;
 
1017
}
 
1018
 
 
1019
 
 
1020
int Field_tiny::store(double nr)
 
1021
{
 
1022
  int error= 0;
 
1023
  nr=rint(nr);
 
1024
  if (unsigned_flag)
 
1025
  {
 
1026
    if (nr < 0.0)
 
1027
    {
 
1028
      *ptr=0;
 
1029
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1030
      error= 1;
 
1031
    }
 
1032
    else if (nr > 255.0)
 
1033
    {
 
1034
      *ptr=(char) 255;
 
1035
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1036
      error= 1;
 
1037
    }
 
1038
    else
 
1039
      *ptr=(char) nr;
 
1040
  }
 
1041
  else
 
1042
  {
 
1043
    if (nr < -128.0)
 
1044
    {
 
1045
      *ptr= (char) -128;
 
1046
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1047
      error= 1;
 
1048
    }
 
1049
    else if (nr > 127.0)
 
1050
    {
 
1051
      *ptr=127;
 
1052
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1053
      error= 1;
 
1054
    }
 
1055
    else
 
1056
      *ptr=(char) (int) nr;
 
1057
  }
 
1058
  return error;
 
1059
}
 
1060
 
 
1061
 
 
1062
int Field_tiny::store(int64_t nr, bool unsigned_val)
 
1063
{
 
1064
  int error= 0;
 
1065
 
 
1066
  if (unsigned_flag)
 
1067
  {
 
1068
    if (nr < 0 && !unsigned_val)
 
1069
    {
 
1070
      *ptr= 0;
 
1071
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1072
      error= 1;
 
1073
    }
 
1074
    else if ((uint64_t) nr > (uint64_t) 255)
 
1075
    {
 
1076
      *ptr= (char) 255;
 
1077
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1078
      error= 1;
 
1079
    }
 
1080
    else
 
1081
      *ptr=(char) nr;
 
1082
  }
 
1083
  else
 
1084
  {
 
1085
    if (nr < 0 && unsigned_val)
 
1086
      nr= 256;                                    // Generate overflow
 
1087
    if (nr < -128)
 
1088
    {
 
1089
      *ptr= (char) -128;
 
1090
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1091
      error= 1;
 
1092
    }
 
1093
    else if (nr > 127)
 
1094
    {
 
1095
      *ptr=127;
 
1096
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1097
      error= 1;
 
1098
    }
 
1099
    else
 
1100
      *ptr=(char) nr;
 
1101
  }
 
1102
  return error;
 
1103
}
 
1104
 
 
1105
 
 
1106
double Field_tiny::val_real(void)
 
1107
{
 
1108
  int tmp= unsigned_flag ? (int) ptr[0] :
 
1109
    (int) ((signed char*) ptr)[0];
 
1110
  return (double) tmp;
 
1111
}
 
1112
 
 
1113
 
 
1114
int64_t Field_tiny::val_int(void)
 
1115
{
 
1116
  int tmp= unsigned_flag ? (int) ptr[0] :
 
1117
    (int) ((signed char*) ptr)[0];
 
1118
  return (int64_t) tmp;
 
1119
}
 
1120
 
 
1121
 
 
1122
String *Field_tiny::val_str(String *val_buffer,
 
1123
                            String *val_ptr __attribute__((unused)))
 
1124
{
 
1125
  const CHARSET_INFO * const cs= &my_charset_bin;
 
1126
  uint32_t length;
 
1127
  uint32_t mlength=cmax(field_length+1,5*cs->mbmaxlen);
 
1128
  val_buffer->alloc(mlength);
 
1129
  char *to=(char*) val_buffer->ptr();
 
1130
 
 
1131
  if (unsigned_flag)
 
1132
    length= (uint32_t) cs->cset->long10_to_str(cs,to,mlength, 10,
 
1133
                                           (long) *ptr);
 
1134
  else
 
1135
    length= (uint32_t) cs->cset->long10_to_str(cs,to,mlength,-10,
 
1136
                                           (long) *((signed char*) ptr));
 
1137
  
 
1138
  val_buffer->length(length);
 
1139
 
 
1140
  return val_buffer;
 
1141
}
 
1142
 
 
1143
bool Field_tiny::send_binary(Protocol *protocol)
 
1144
{
 
1145
  return protocol->store_tiny((int64_t) (int8_t) ptr[0]);
 
1146
}
 
1147
 
 
1148
int Field_tiny::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
 
1149
{
 
1150
  signed char a,b;
 
1151
  a=(signed char) a_ptr[0]; b= (signed char) b_ptr[0];
 
1152
  if (unsigned_flag)
 
1153
    return ((unsigned char) a < (unsigned char) b) ? -1 : ((unsigned char) a > (unsigned char) b) ? 1 : 0;
 
1154
  return (a < b) ? -1 : (a > b) ? 1 : 0;
 
1155
}
 
1156
 
 
1157
void Field_tiny::sort_string(unsigned char *to,uint32_t length __attribute__((unused)))
 
1158
{
 
1159
  if (unsigned_flag)
 
1160
    *to= *ptr;
 
1161
  else
 
1162
    to[0] = (char) (ptr[0] ^ (unsigned char) 128);      /* Revers signbit */
 
1163
}
 
1164
 
 
1165
void Field_tiny::sql_type(String &res) const
 
1166
{
 
1167
  const CHARSET_INFO * const cs=res.charset();
 
1168
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
 
1169
                          "tinyint(%d)",(int) field_length));
 
1170
}
 
1171
 
 
1172
/*
 
1173
  Report "not well formed" or "cannot convert" error
 
1174
  after storing a character string info a field.
 
1175
 
 
1176
  SYNOPSIS
 
1177
    check_string_copy_error()
 
1178
    field                    - Field
 
1179
    well_formed_error_pos    - where not well formed data was first met
 
1180
    cannot_convert_error_pos - where a not-convertable character was first met
 
1181
    end                      - end of the string
 
1182
    cs                       - character set of the string
 
1183
 
 
1184
  NOTES
 
1185
    As of version 5.0 both cases return the same error:
 
1186
 
 
1187
      "Invalid string value: 'xxx' for column 't' at row 1"
 
1188
 
 
1189
  Future versions will possibly introduce a new error message:
 
1190
 
 
1191
      "Cannot convert character string: 'xxx' for column 't' at row 1"
 
1192
 
 
1193
  RETURN
 
1194
    false - If errors didn't happen
 
1195
    true  - If an error happened
 
1196
*/
 
1197
 
 
1198
bool
 
1199
check_string_copy_error(Field_str *field,
 
1200
                        const char *well_formed_error_pos,
 
1201
                        const char *cannot_convert_error_pos,
 
1202
                        const char *end,
 
1203
                        const CHARSET_INFO * const cs)
 
1204
{
 
1205
  const char *pos, *end_orig;
 
1206
  char tmp[64], *t;
 
1207
  
 
1208
  if (!(pos= well_formed_error_pos) &&
 
1209
      !(pos= cannot_convert_error_pos))
 
1210
    return false;
 
1211
 
 
1212
  end_orig= end;
 
1213
  set_if_smaller(end, pos + 6);
 
1214
 
 
1215
  for (t= tmp; pos < end; pos++)
 
1216
  {
 
1217
    /*
 
1218
      If the source string is ASCII compatible (mbminlen==1)
 
1219
      and the source character is in ASCII printable range (0x20..0x7F),
 
1220
      then display the character as is.
 
1221
      
 
1222
      Otherwise, if the source string is not ASCII compatible (e.g. UCS2),
 
1223
      or the source character is not in the printable range,
 
1224
      then print the character using HEX notation.
 
1225
    */
 
1226
    if (((unsigned char) *pos) >= 0x20 &&
 
1227
        ((unsigned char) *pos) <= 0x7F &&
 
1228
        cs->mbminlen == 1)
 
1229
    {
 
1230
      *t++= *pos;
 
1231
    }
 
1232
    else
 
1233
    {
 
1234
      *t++= '\\';
 
1235
      *t++= 'x';
 
1236
      *t++= _dig_vec_upper[((unsigned char) *pos) >> 4];
 
1237
      *t++= _dig_vec_upper[((unsigned char) *pos) & 15];
 
1238
    }
 
1239
  }
 
1240
  if (end_orig > end)
 
1241
  {
 
1242
    *t++= '.';
 
1243
    *t++= '.';
 
1244
    *t++= '.';
 
1245
  }
 
1246
  *t= '\0';
 
1247
  push_warning_printf(field->table->in_use, 
 
1248
                      field->table->in_use->abort_on_warning ?
 
1249
                      DRIZZLE_ERROR::WARN_LEVEL_ERROR :
 
1250
                      DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
1251
                      ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, 
 
1252
                      ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
 
1253
                      "string", tmp, field->field_name,
 
1254
                      (uint32_t) field->table->in_use->row_count);
 
1255
  return true;
 
1256
}
 
1257
 
 
1258
uint32_t Field::is_equal(Create_field *new_field)
 
1259
{
 
1260
  return (new_field->sql_type == real_type());
 
1261
}
 
1262
 
 
1263
/**
 
1264
  @retval
 
1265
    1  if the fields are equally defined
 
1266
  @retval
 
1267
    0  if the fields are unequally defined
 
1268
*/
920
1269
 
921
1270
bool Field::eq_def(Field *field)
922
1271
{
926
1275
  return 1;
927
1276
}
928
1277
 
 
1278
/**
 
1279
  @return
 
1280
  returns 1 if the fields are equally defined
 
1281
*/
929
1282
bool Field_enum::eq_def(Field *field)
930
1283
{
931
1284
  if (!Field::eq_def(field))
944
1297
  return 1;
945
1298
}
946
1299
 
 
1300
/*****************************************************************************
 
1301
  Handling of field and Create_field
 
1302
*****************************************************************************/
 
1303
 
 
1304
/**
 
1305
  Convert create_field::length from number of characters to number of bytes.
 
1306
*/
 
1307
 
 
1308
void Create_field::create_length_to_internal_length(void)
 
1309
{
 
1310
  switch (sql_type) {
 
1311
  case DRIZZLE_TYPE_BLOB:
 
1312
  case DRIZZLE_TYPE_VARCHAR:
 
1313
    length*= charset->mbmaxlen;
 
1314
    key_length= length;
 
1315
    pack_length= calc_pack_length(sql_type, length);
 
1316
    break;
 
1317
  case DRIZZLE_TYPE_ENUM:
 
1318
    /* Pack_length already calculated in sql_parse.cc */
 
1319
    length*= charset->mbmaxlen;
 
1320
    key_length= pack_length;
 
1321
    break;
 
1322
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1323
    key_length= pack_length=
 
1324
      my_decimal_get_binary_size(my_decimal_length_to_precision(length,
 
1325
                                                                decimals,
 
1326
                                                                flags &
 
1327
                                                                UNSIGNED_FLAG),
 
1328
                                 decimals);
 
1329
    break;
 
1330
  default:
 
1331
    key_length= pack_length= calc_pack_length(sql_type, length);
 
1332
    break;
 
1333
  }
 
1334
}
 
1335
 
 
1336
 
 
1337
/**
 
1338
  Init for a tmp table field. To be extended if need be.
 
1339
*/
 
1340
void Create_field::init_for_tmp_table(enum_field_types sql_type_arg,
 
1341
                                      uint32_t length_arg, uint32_t decimals_arg,
 
1342
                                      bool maybe_null, bool is_unsigned)
 
1343
{
 
1344
  field_name= "";
 
1345
  sql_type= sql_type_arg;
 
1346
  char_length= length= length_arg;;
 
1347
  unireg_check= Field::NONE;
 
1348
  interval= 0;
 
1349
  charset= &my_charset_bin;
 
1350
  pack_flag= (FIELDFLAG_NUMBER |
 
1351
              ((decimals_arg & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
 
1352
              (maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
 
1353
              (is_unsigned ? 0 : FIELDFLAG_DECIMAL));
 
1354
}
 
1355
 
 
1356
 
 
1357
/**
 
1358
  Initialize field definition for create.
 
1359
 
 
1360
  @param thd                   Thread handle
 
1361
  @param fld_name              Field name
 
1362
  @param fld_type              Field type
 
1363
  @param fld_length            Field length
 
1364
  @param fld_decimals          Decimal (if any)
 
1365
  @param fld_type_modifier     Additional type information
 
1366
  @param fld_default_value     Field default value (if any)
 
1367
  @param fld_on_update_value   The value of ON UPDATE clause
 
1368
  @param fld_comment           Field comment
 
1369
  @param fld_change            Field change
 
1370
  @param fld_interval_list     Interval list (if any)
 
1371
  @param fld_charset           Field charset
 
1372
 
 
1373
  @retval
 
1374
    false on success
 
1375
  @retval
 
1376
    true  on error
 
1377
*/
 
1378
 
 
1379
bool Create_field::init(THD *thd __attribute__((unused)), char *fld_name, enum_field_types fld_type,
 
1380
                        char *fld_length, char *fld_decimals,
 
1381
                        uint32_t fld_type_modifier, Item *fld_default_value,
 
1382
                        Item *fld_on_update_value, LEX_STRING *fld_comment,
 
1383
                        char *fld_change, List<String> *fld_interval_list,
 
1384
                        const CHARSET_INFO * const fld_charset,
 
1385
                        uint32_t fld_geom_type __attribute__((unused)),
 
1386
                        enum column_format_type column_format)
 
1387
{
 
1388
  uint32_t sign_len, allowed_type_modifier= 0;
 
1389
  uint32_t max_field_charlength= MAX_FIELD_CHARLENGTH;
 
1390
 
 
1391
  field= 0;
 
1392
  field_name= fld_name;
 
1393
  def= fld_default_value;
 
1394
  flags= fld_type_modifier;
 
1395
  flags|= (((uint32_t)column_format & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
 
1396
  unireg_check= (fld_type_modifier & AUTO_INCREMENT_FLAG ?
 
1397
                 Field::NEXT_NUMBER : Field::NONE);
 
1398
  decimals= fld_decimals ? (uint32_t)atoi(fld_decimals) : 0;
 
1399
  if (decimals >= NOT_FIXED_DEC)
 
1400
  {
 
1401
    my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
 
1402
             NOT_FIXED_DEC-1);
 
1403
    return(true);
 
1404
  }
 
1405
 
 
1406
  sql_type= fld_type;
 
1407
  length= 0;
 
1408
  change= fld_change;
 
1409
  interval= 0;
 
1410
  pack_length= key_length= 0;
 
1411
  charset= fld_charset;
 
1412
  interval_list.empty();
 
1413
 
 
1414
  comment= *fld_comment;
 
1415
  /*
 
1416
    Set NO_DEFAULT_VALUE_FLAG if this field doesn't have a default value and
 
1417
    it is NOT NULL, not an AUTO_INCREMENT field and not a TIMESTAMP.
 
1418
  */
 
1419
  if (!fld_default_value && !(fld_type_modifier & AUTO_INCREMENT_FLAG) &&
 
1420
      (fld_type_modifier & NOT_NULL_FLAG) && fld_type != DRIZZLE_TYPE_TIMESTAMP)
 
1421
    flags|= NO_DEFAULT_VALUE_FLAG;
 
1422
 
 
1423
  if (fld_length && !(length= (uint32_t) atoi(fld_length)))
 
1424
    fld_length= 0; /* purecov: inspected */
 
1425
  sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1;
 
1426
 
 
1427
  switch (fld_type) {
 
1428
  case DRIZZLE_TYPE_TINY:
 
1429
    if (!fld_length)
 
1430
      length= MAX_TINYINT_WIDTH+sign_len;
 
1431
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
 
1432
    break;
 
1433
  case DRIZZLE_TYPE_LONG:
 
1434
    if (!fld_length)
 
1435
      length= MAX_INT_WIDTH+sign_len;
 
1436
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
 
1437
    break;
 
1438
  case DRIZZLE_TYPE_LONGLONG:
 
1439
    if (!fld_length)
 
1440
      length= MAX_BIGINT_WIDTH;
 
1441
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
 
1442
    break;
 
1443
  case DRIZZLE_TYPE_NULL:
 
1444
    break;
 
1445
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1446
    my_decimal_trim(&length, &decimals);
 
1447
    if (length > DECIMAL_MAX_PRECISION)
 
1448
    {
 
1449
      my_error(ER_TOO_BIG_PRECISION, MYF(0), length, fld_name,
 
1450
               DECIMAL_MAX_PRECISION);
 
1451
      return(true);
 
1452
    }
 
1453
    if (length < decimals)
 
1454
    {
 
1455
      my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
 
1456
      return(true);
 
1457
    }
 
1458
    length=
 
1459
      my_decimal_precision_to_length(length, decimals,
 
1460
                                     fld_type_modifier & UNSIGNED_FLAG);
 
1461
    pack_length=
 
1462
      my_decimal_get_binary_size(length, decimals);
 
1463
    break;
 
1464
  case DRIZZLE_TYPE_VARCHAR:
 
1465
    /*
 
1466
      Long VARCHAR's are automaticly converted to blobs in mysql_prepare_table
 
1467
      if they don't have a default value
 
1468
    */
 
1469
    max_field_charlength= MAX_FIELD_VARCHARLENGTH;
 
1470
    break;
 
1471
  case DRIZZLE_TYPE_BLOB:
 
1472
    if (fld_default_value)
 
1473
    {
 
1474
      /* Allow empty as default value. */
 
1475
      String str,*res;
 
1476
      res= fld_default_value->val_str(&str);
 
1477
    }
 
1478
    flags|= BLOB_FLAG;
 
1479
    break;
 
1480
  case DRIZZLE_TYPE_DOUBLE:
 
1481
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
 
1482
    if (!fld_length && !fld_decimals)
 
1483
    {
 
1484
      length= DBL_DIG+7;
 
1485
      decimals= NOT_FIXED_DEC;
 
1486
    }
 
1487
    if (length < decimals &&
 
1488
        decimals != NOT_FIXED_DEC)
 
1489
    {
 
1490
      my_error(ER_M_BIGGER_THAN_D, MYF(0), fld_name);
 
1491
      return(true);
 
1492
    }
 
1493
    break;
 
1494
  case DRIZZLE_TYPE_TIMESTAMP:
 
1495
    if (!fld_length)
 
1496
    {
 
1497
      /* Compressed date YYYYMMDDHHMMSS */
 
1498
      length= MAX_DATETIME_COMPRESSED_WIDTH;
 
1499
    }
 
1500
    else if (length != MAX_DATETIME_WIDTH)
 
1501
    {
 
1502
      /*
 
1503
        We support only even TIMESTAMP lengths less or equal than 14
 
1504
        and 19 as length of 4.1 compatible representation.
 
1505
      */
 
1506
      length= ((length+1)/2)*2; /* purecov: inspected */
 
1507
      length= cmin(length, (uint32_t)MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
 
1508
    }
 
1509
    flags|= UNSIGNED_FLAG;
 
1510
    if (fld_default_value)
 
1511
    {
 
1512
      /* Grammar allows only NOW() value for ON UPDATE clause */
 
1513
      if (fld_default_value->type() == Item::FUNC_ITEM && 
 
1514
          ((Item_func*)fld_default_value)->functype() == Item_func::NOW_FUNC)
 
1515
      {
 
1516
        unireg_check= (fld_on_update_value ? Field::TIMESTAMP_DNUN_FIELD:
 
1517
                                             Field::TIMESTAMP_DN_FIELD);
 
1518
        /*
 
1519
          We don't need default value any longer moreover it is dangerous.
 
1520
          Everything handled by unireg_check further.
 
1521
        */
 
1522
        def= 0;
 
1523
      }
 
1524
      else
 
1525
        unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD:
 
1526
                                             Field::NONE);
 
1527
    }
 
1528
    else
 
1529
    {
 
1530
      /*
 
1531
        If we have default TIMESTAMP NOT NULL column without explicit DEFAULT
 
1532
        or ON UPDATE values then for the sake of compatiblity we should treat
 
1533
        this column as having DEFAULT NOW() ON UPDATE NOW() (when we don't
 
1534
        have another TIMESTAMP column with auto-set option before this one)
 
1535
        or DEFAULT 0 (in other cases).
 
1536
        So here we are setting TIMESTAMP_OLD_FIELD only temporary, and will
 
1537
        replace this value by TIMESTAMP_DNUN_FIELD or NONE later when
 
1538
        information about all TIMESTAMP fields in table will be availiable.
 
1539
 
 
1540
        If we have TIMESTAMP NULL column without explicit DEFAULT value
 
1541
        we treat it as having DEFAULT NULL attribute.
 
1542
      */
 
1543
      unireg_check= (fld_on_update_value ? Field::TIMESTAMP_UN_FIELD :
 
1544
                     (flags & NOT_NULL_FLAG ? Field::TIMESTAMP_OLD_FIELD :
 
1545
                                              Field::NONE));
 
1546
    }
 
1547
    break;
 
1548
  case DRIZZLE_TYPE_NEWDATE:
 
1549
    length= 10;
 
1550
    break;
 
1551
  case DRIZZLE_TYPE_TIME:
 
1552
    length= 10;
 
1553
    break;
 
1554
  case DRIZZLE_TYPE_DATETIME:
 
1555
    length= MAX_DATETIME_WIDTH;
 
1556
    break;
 
1557
  case DRIZZLE_TYPE_ENUM:
 
1558
    {
 
1559
      /* Should be safe. */
 
1560
      pack_length= get_enum_pack_length(fld_interval_list->elements);
 
1561
 
 
1562
      List_iterator<String> it(*fld_interval_list);
 
1563
      String *tmp;
 
1564
      while ((tmp= it++))
 
1565
        interval_list.push_back(tmp);
 
1566
      length= 1; /* See comment for DRIZZLE_TYPE_SET above. */
 
1567
      break;
 
1568
   }
 
1569
  }
 
1570
  /* Remember the value of length */
 
1571
  char_length= length;
 
1572
 
 
1573
  if (!(flags & BLOB_FLAG) &&
 
1574
      ((length > max_field_charlength &&
 
1575
        fld_type != DRIZZLE_TYPE_ENUM &&
 
1576
        (fld_type != DRIZZLE_TYPE_VARCHAR || fld_default_value)) ||
 
1577
       (!length && fld_type != DRIZZLE_TYPE_VARCHAR)))
 
1578
  {
 
1579
    my_error((fld_type == DRIZZLE_TYPE_VARCHAR) ?  ER_TOO_BIG_FIELDLENGTH : ER_TOO_BIG_DISPLAYWIDTH,
 
1580
              MYF(0),
 
1581
              fld_name, max_field_charlength); /* purecov: inspected */
 
1582
    return(true);
 
1583
  }
 
1584
  fld_type_modifier&= AUTO_INCREMENT_FLAG;
 
1585
  if ((~allowed_type_modifier) & fld_type_modifier)
 
1586
  {
 
1587
    my_error(ER_WRONG_FIELD_SPEC, MYF(0), fld_name);
 
1588
    return(true);
 
1589
  }
 
1590
 
 
1591
  return(false); /* success */
 
1592
}
 
1593
 
 
1594
 
 
1595
enum_field_types get_blob_type_from_length(uint32_t length __attribute__((unused)))
 
1596
{
 
1597
  enum_field_types type;
 
1598
 
 
1599
  type= DRIZZLE_TYPE_BLOB;
 
1600
 
 
1601
  return type;
 
1602
}
 
1603
 
 
1604
 
 
1605
/*
 
1606
  Make a field from the .frm file info
 
1607
*/
 
1608
 
947
1609
uint32_t calc_pack_length(enum_field_types type,uint32_t length)
948
1610
{
949
1611
  switch (type) {
950
 
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
951
 
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
952
 
  case DRIZZLE_TYPE_DATE:
953
 
  case DRIZZLE_TYPE_ENUM:
954
 
  case DRIZZLE_TYPE_LONG: return 4;
 
1612
  case DRIZZLE_TYPE_VARCHAR:     return (length + (length < 256 ? 1: 2));
 
1613
  case DRIZZLE_TYPE_TINY        : return 1;
 
1614
  case DRIZZLE_TYPE_NEWDATE:
 
1615
  case DRIZZLE_TYPE_TIME:   return 3;
 
1616
  case DRIZZLE_TYPE_TIMESTAMP:
 
1617
  case DRIZZLE_TYPE_LONG        : return 4;
955
1618
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
956
1619
  case DRIZZLE_TYPE_DATETIME:
957
 
  case DRIZZLE_TYPE_TIMESTAMP:
958
1620
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
959
 
  case DRIZZLE_TYPE_NULL: return 0;
960
 
  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
961
 
  case DRIZZLE_TYPE_DECIMAL:
962
 
                          assert(0);
963
 
                          abort();
 
1621
  case DRIZZLE_TYPE_NULL        : return 0;
 
1622
  case DRIZZLE_TYPE_BLOB:               return 4+portable_sizeof_char_ptr;
 
1623
  case DRIZZLE_TYPE_ENUM:
 
1624
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1625
    abort(); return 0;                          // This shouldn't happen
 
1626
  default:
 
1627
    return 0;
964
1628
  }
965
 
 
966
 
  assert(0);
967
 
  abort();
968
1629
}
969
1630
 
 
1631
 
970
1632
uint32_t pack_length_to_packflag(uint32_t type)
971
1633
{
972
1634
  switch (type) {
973
 
    case 1: return 1 << FIELDFLAG_PACK_SHIFT;
 
1635
    case 1: return f_settype((uint32_t) DRIZZLE_TYPE_TINY);
974
1636
    case 2: assert(1);
975
1637
    case 3: assert(1);
976
 
    case 4: return f_settype(DRIZZLE_TYPE_LONG);
977
 
    case 8: return f_settype(DRIZZLE_TYPE_LONGLONG);
 
1638
    case 4: return f_settype((uint32_t) DRIZZLE_TYPE_LONG);
 
1639
    case 8: return f_settype((uint32_t) DRIZZLE_TYPE_LONGLONG);
978
1640
  }
979
1641
  return 0;                                     // This shouldn't happen
980
1642
}
981
1643
 
 
1644
 
 
1645
Field *make_field(TABLE_SHARE *share, unsigned char *ptr, uint32_t field_length,
 
1646
                  unsigned char *null_pos, unsigned char null_bit,
 
1647
                  uint32_t pack_flag,
 
1648
                  enum_field_types field_type,
 
1649
                  const CHARSET_INFO * field_charset,
 
1650
                  Field::utype unireg_check,
 
1651
                  TYPELIB *interval,
 
1652
                  const char *field_name)
 
1653
{
 
1654
  if (!f_maybe_null(pack_flag))
 
1655
  {
 
1656
    null_pos=0;
 
1657
    null_bit=0;
 
1658
  }
 
1659
  else
 
1660
  {
 
1661
    null_bit= ((unsigned char) 1) << null_bit;
 
1662
  }
 
1663
 
 
1664
  switch (field_type) {
 
1665
  case DRIZZLE_TYPE_NEWDATE:
 
1666
  case DRIZZLE_TYPE_TIME:
 
1667
  case DRIZZLE_TYPE_DATETIME:
 
1668
  case DRIZZLE_TYPE_TIMESTAMP:
 
1669
    field_charset= &my_charset_bin;
 
1670
  default: break;
 
1671
  }
 
1672
 
 
1673
  if (f_is_alpha(pack_flag))
 
1674
  {
 
1675
    if (!f_is_packed(pack_flag))
 
1676
    {
 
1677
      if (field_type == DRIZZLE_TYPE_VARCHAR)
 
1678
        return new Field_varstring(ptr,field_length,
 
1679
                                   HA_VARCHAR_PACKLENGTH(field_length),
 
1680
                                   null_pos,null_bit,
 
1681
                                   unireg_check, field_name,
 
1682
                                   share,
 
1683
                                   field_charset);
 
1684
      return 0;                                 // Error
 
1685
    }
 
1686
 
 
1687
    uint32_t pack_length=calc_pack_length((enum_field_types)
 
1688
                                      f_packtype(pack_flag),
 
1689
                                      field_length);
 
1690
 
 
1691
    if (f_is_blob(pack_flag))
 
1692
      return new Field_blob(ptr,null_pos,null_bit,
 
1693
                            unireg_check, field_name, share,
 
1694
                            pack_length, field_charset);
 
1695
    if (interval)
 
1696
    {
 
1697
      if (f_is_enum(pack_flag))
 
1698
        return new Field_enum(ptr,field_length,null_pos,null_bit,
 
1699
                                  unireg_check, field_name,
 
1700
                                  pack_length, interval, field_charset);
 
1701
    }
 
1702
  }
 
1703
 
 
1704
  switch (field_type) {
 
1705
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1706
    return new Field_new_decimal(ptr,field_length,null_pos,null_bit,
 
1707
                                 unireg_check, field_name,
 
1708
                                 f_decimals(pack_flag),
 
1709
                                 f_is_decimal_precision(pack_flag) != 0,
 
1710
                                 f_is_dec(pack_flag) == 0);
 
1711
  case DRIZZLE_TYPE_DOUBLE:
 
1712
    return new Field_double(ptr,field_length,null_pos,null_bit,
 
1713
                            unireg_check, field_name,
 
1714
                            f_decimals(pack_flag),
 
1715
                            false,
 
1716
                            f_is_dec(pack_flag)== 0);
 
1717
  case DRIZZLE_TYPE_TINY:
 
1718
    return new Field_tiny(ptr,field_length,null_pos,null_bit,
 
1719
                          unireg_check, field_name,
 
1720
                          false,
 
1721
                          f_is_dec(pack_flag) == 0);
 
1722
  case DRIZZLE_TYPE_LONG:
 
1723
    return new Field_long(ptr,field_length,null_pos,null_bit,
 
1724
                           unireg_check, field_name,
 
1725
                           false,
 
1726
                           f_is_dec(pack_flag) == 0);
 
1727
  case DRIZZLE_TYPE_LONGLONG:
 
1728
    return new Field_int64_t(ptr,field_length,null_pos,null_bit,
 
1729
                              unireg_check, field_name,
 
1730
                              false,
 
1731
                              f_is_dec(pack_flag) == 0);
 
1732
  case DRIZZLE_TYPE_TIMESTAMP:
 
1733
    return new Field_timestamp(ptr,field_length, null_pos, null_bit,
 
1734
                               unireg_check, field_name, share,
 
1735
                               field_charset);
 
1736
  case DRIZZLE_TYPE_NEWDATE:
 
1737
    return new Field_newdate(ptr,null_pos,null_bit,
 
1738
                             unireg_check, field_name, field_charset);
 
1739
  case DRIZZLE_TYPE_TIME:
 
1740
    return new Field_time(ptr,null_pos,null_bit,
 
1741
                          unireg_check, field_name, field_charset);
 
1742
  case DRIZZLE_TYPE_DATETIME:
 
1743
    return new Field_datetime(ptr,null_pos,null_bit,
 
1744
                              unireg_check, field_name, field_charset);
 
1745
  case DRIZZLE_TYPE_NULL:
 
1746
    return new Field_null(ptr, field_length, unireg_check, field_name,
 
1747
                          field_charset);
 
1748
  default:                                      // Impossible (Wrong version)
 
1749
    break;
 
1750
  }
 
1751
  return 0;
 
1752
}
 
1753
 
 
1754
 
 
1755
/** Create a field suitable for create of table. */
 
1756
 
 
1757
Create_field::Create_field(Field *old_field,Field *orig_field)
 
1758
{
 
1759
  field=      old_field;
 
1760
  field_name=change=old_field->field_name;
 
1761
  length=     old_field->field_length;
 
1762
  flags=      old_field->flags;
 
1763
  unireg_check=old_field->unireg_check;
 
1764
  pack_length=old_field->pack_length();
 
1765
  key_length= old_field->key_length();
 
1766
  sql_type=   old_field->real_type();
 
1767
  charset=    old_field->charset();             // May be NULL ptr
 
1768
  comment=    old_field->comment;
 
1769
  decimals=   old_field->decimals();
 
1770
 
 
1771
  /* Fix if the original table had 4 byte pointer blobs */
 
1772
  if (flags & BLOB_FLAG)
 
1773
    pack_length= (pack_length- old_field->table->s->blob_ptr_size +
 
1774
                  portable_sizeof_char_ptr);
 
1775
 
 
1776
  switch (sql_type) {
 
1777
  case DRIZZLE_TYPE_BLOB:
 
1778
    sql_type= DRIZZLE_TYPE_BLOB;
 
1779
    length/= charset->mbmaxlen;
 
1780
    key_length/= charset->mbmaxlen;
 
1781
    break;
 
1782
    /* Change CHAR -> VARCHAR if dynamic record length */
 
1783
  case DRIZZLE_TYPE_ENUM:
 
1784
  case DRIZZLE_TYPE_VARCHAR:
 
1785
    /* This is corrected in create_length_to_internal_length */
 
1786
    length= (length+charset->mbmaxlen-1) / charset->mbmaxlen;
 
1787
    break;
 
1788
  default:
 
1789
    break;
 
1790
  }
 
1791
 
 
1792
  if (flags & (ENUM_FLAG | SET_FLAG))
 
1793
    interval= ((Field_enum*) old_field)->typelib;
 
1794
  else
 
1795
    interval=0;
 
1796
  def=0;
 
1797
  char_length= length;
 
1798
 
 
1799
  if (!(flags & (NO_DEFAULT_VALUE_FLAG | BLOB_FLAG)) &&
 
1800
      old_field->ptr && orig_field &&
 
1801
      (sql_type != DRIZZLE_TYPE_TIMESTAMP ||                /* set def only if */
 
1802
       old_field->table->timestamp_field != old_field ||  /* timestamp field */ 
 
1803
       unireg_check == Field::TIMESTAMP_UN_FIELD))        /* has default val */
 
1804
  {
 
1805
    char buff[MAX_FIELD_WIDTH];
 
1806
    String tmp(buff,sizeof(buff), charset);
 
1807
    my_ptrdiff_t diff;
 
1808
 
 
1809
    /* Get the value from default_values */
 
1810
    diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
 
1811
                          orig_field->table->record[0]);
 
1812
    orig_field->move_field_offset(diff);        // Points now at default_values
 
1813
    if (!orig_field->is_real_null())
 
1814
    {
 
1815
      char buff[MAX_FIELD_WIDTH], *pos;
 
1816
      String tmp(buff, sizeof(buff), charset), *res;
 
1817
      res= orig_field->val_str(&tmp);
 
1818
      pos= (char*) sql_strmake(res->ptr(), res->length());
 
1819
      def= new Item_string(pos, res->length(), charset);
 
1820
    }
 
1821
    orig_field->move_field_offset(-diff);       // Back to record[0]
 
1822
  }
 
1823
}
 
1824
 
 
1825
 
982
1826
/*****************************************************************************
983
1827
 Warning handling
984
1828
*****************************************************************************/
985
1829
 
986
 
bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
987
 
                        uint32_t code,
988
 
                        int cuted_increment)
 
1830
/**
 
1831
  Produce warning or note about data saved into field.
 
1832
 
 
1833
  @param level            - level of message (Note/Warning/Error)
 
1834
  @param code             - error code of message to be produced
 
1835
  @param cuted_increment  - whenever we should increase cut fields count or not
 
1836
 
 
1837
  @note
 
1838
    This function won't produce warning and increase cut fields counter
 
1839
    if count_cuted_fields == CHECK_FIELD_IGNORE for current thread.
 
1840
 
 
1841
    if count_cuted_fields == CHECK_FIELD_IGNORE then we ignore notes.
 
1842
    This allows us to avoid notes in optimisation, like convert_constant_item().
 
1843
 
 
1844
  @retval
 
1845
    1 if count_cuted_fields == CHECK_FIELD_IGNORE and error level is not NOTE
 
1846
  @retval
 
1847
    0 otherwise
 
1848
*/
 
1849
 
 
1850
bool 
 
1851
Field::set_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code,
 
1852
                   int cuted_increment)
989
1853
{
990
1854
  /*
991
1855
    If this field was created only for type conversion purposes it
992
1856
    will have table == NULL.
993
1857
  */
994
 
  Session *session= table ? table->in_use : current_session;
995
 
  if (session->count_cuted_fields)
 
1858
  THD *thd= table ? table->in_use : current_thd;
 
1859
  if (thd->count_cuted_fields)
996
1860
  {
997
 
    session->cuted_fields+= cuted_increment;
998
 
    push_warning_printf(session, level, code, ER(code), field_name,
999
 
                        session->row_count);
 
1861
    thd->cuted_fields+= cuted_increment;
 
1862
    push_warning_printf(thd, level, code, ER(code), field_name,
 
1863
                        thd->row_count);
1000
1864
    return 0;
1001
1865
  }
1002
1866
  return level >= DRIZZLE_ERROR::WARN_LEVEL_WARN;
1003
1867
}
1004
1868
 
1005
1869
 
1006
 
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1007
 
                                 unsigned int code,
1008
 
                                 const char *str, 
1009
 
                                 uint32_t str_length,
1010
 
                                 enum enum_drizzle_timestamp_type ts_type, 
1011
 
                                 int cuted_increment)
 
1870
/**
 
1871
  Produce warning or note about datetime string data saved into field.
 
1872
 
 
1873
  @param level            level of message (Note/Warning/Error)
 
1874
  @param code             error code of message to be produced
 
1875
  @param str              string value which we tried to save
 
1876
  @param str_length       length of string which we tried to save
 
1877
  @param ts_type          type of datetime value (datetime/date/time)
 
1878
  @param cuted_increment  whenever we should increase cut fields count or not
 
1879
 
 
1880
  @note
 
1881
    This function will always produce some warning but won't increase cut
 
1882
    fields counter if count_cuted_fields ==FIELD_CHECK_IGNORE for current
 
1883
    thread.
 
1884
*/
 
1885
 
 
1886
void 
 
1887
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
 
1888
                            unsigned int code, 
 
1889
                            const char *str, uint32_t str_length, 
 
1890
                            enum enum_drizzle_timestamp_type ts_type, int cuted_increment)
1012
1891
{
1013
 
  Session *session= table ? table->in_use : current_session;
1014
 
  if ((session->really_abort_on_warning() &&
 
1892
  THD *thd= table ? table->in_use : current_thd;
 
1893
  if ((thd->really_abort_on_warning() &&
1015
1894
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
1016
1895
      set_warning(level, code, cuted_increment))
1017
 
    make_truncated_value_warning(session, level, str, str_length, ts_type,
 
1896
    make_truncated_value_warning(thd, level, str, str_length, ts_type,
1018
1897
                                 field_name);
1019
1898
}
1020
1899
 
1021
 
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
1022
 
                                 uint32_t code,
1023
 
                                 int64_t nr, 
1024
 
                                 enum enum_drizzle_timestamp_type ts_type,
1025
 
                                 int cuted_increment)
 
1900
 
 
1901
/**
 
1902
  Produce warning or note about integer datetime value saved into field.
 
1903
 
 
1904
  @param level            level of message (Note/Warning/Error)
 
1905
  @param code             error code of message to be produced
 
1906
  @param nr               numeric value which we tried to save
 
1907
  @param ts_type          type of datetime value (datetime/date/time)
 
1908
  @param cuted_increment  whenever we should increase cut fields count or not
 
1909
 
 
1910
  @note
 
1911
    This function will always produce some warning but won't increase cut
 
1912
    fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current
 
1913
    thread.
 
1914
*/
 
1915
 
 
1916
void 
 
1917
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code, 
 
1918
                            int64_t nr, enum enum_drizzle_timestamp_type ts_type,
 
1919
                            int cuted_increment)
1026
1920
{
1027
 
  Session *session= table ? table->in_use : current_session;
1028
 
  if (session->really_abort_on_warning() ||
 
1921
  THD *thd= table ? table->in_use : current_thd;
 
1922
  if (thd->really_abort_on_warning() ||
1029
1923
      set_warning(level, code, cuted_increment))
1030
1924
  {
1031
1925
    char str_nr[22];
1032
 
    char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
1033
 
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
 
1926
    char *str_end= int64_t10_to_str(nr, str_nr, -10);
 
1927
    make_truncated_value_warning(thd, level, str_nr, (uint32_t) (str_end - str_nr), 
1034
1928
                                 ts_type, field_name);
1035
1929
  }
1036
1930
}
1037
1931
 
1038
 
void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1039
 
                                 const uint32_t code,
1040
 
                                 double nr, 
1041
 
                                 enum enum_drizzle_timestamp_type ts_type)
 
1932
 
 
1933
/**
 
1934
  Produce warning or note about double datetime data saved into field.
 
1935
 
 
1936
  @param level            level of message (Note/Warning/Error)
 
1937
  @param code             error code of message to be produced
 
1938
  @param nr               double value which we tried to save
 
1939
  @param ts_type          type of datetime value (datetime/date/time)
 
1940
 
 
1941
  @note
 
1942
    This function will always produce some warning but won't increase cut
 
1943
    fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current
 
1944
    thread.
 
1945
*/
 
1946
 
 
1947
void 
 
1948
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code, 
 
1949
                            double nr, enum enum_drizzle_timestamp_type ts_type)
1042
1950
{
1043
 
  Session *session= table ? table->in_use : current_session;
1044
 
  if (session->really_abort_on_warning() ||
 
1951
  THD *thd= table ? table->in_use : current_thd;
 
1952
  if (thd->really_abort_on_warning() ||
1045
1953
      set_warning(level, code, 1))
1046
1954
  {
1047
1955
    /* DBL_DIG is enough to print '-[digits].E+###' */
1048
1956
    char str_nr[DBL_DIG + 8];
1049
 
    uint32_t str_len= snprintf(str_nr, sizeof(str_nr), "%g", nr);
1050
 
    make_truncated_value_warning(session, level, str_nr, str_len, ts_type,
 
1957
    uint32_t str_len= sprintf(str_nr, "%g", nr);
 
1958
    make_truncated_value_warning(thd, level, str_nr, str_len, ts_type,
1051
1959
                                 field_name);
1052
1960
  }
1053
1961
}
1054
 
 
1055
 
bool Field::isReadSet() 
1056
 
{ 
1057
 
  return table->isReadSet(field_index); 
1058
 
}
1059
 
 
1060
 
bool Field::isWriteSet()
1061
 
{ 
1062
 
  return table->isWriteSet(field_index); 
1063
 
}
1064
 
 
1065
 
void Field::setReadSet(bool arg)
1066
 
{
1067
 
  if (arg)
1068
 
    table->setReadSet(field_index);
1069
 
  else
1070
 
    table->clearReadSet(field_index);
1071
 
}
1072
 
 
1073
 
void Field::setWriteSet(bool arg)
1074
 
{
1075
 
  if (arg)
1076
 
    table->setWriteSet(field_index);
1077
 
  else
1078
 
    table->clearWriteSet(field_index);
1079
 
}
1080
 
 
1081
 
std::ostream& operator<<(std::ostream& output, const Field &field)
1082
 
{
1083
 
  output << "Field:(";
1084
 
  output <<  field.field_name;
1085
 
  output << ", ";
1086
 
  output << drizzled::display::type(field.real_type());
1087
 
  output << ")";
1088
 
 
1089
 
  return output;  // for multiple << operators.
1090
 
}
1091
 
 
1092
 
} /* namespace drizzled */