← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/field.cc

Merge/fix in FAQ.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/field.cc
20
20
  @brief
21
21
  This file implements classes defined in field.h
22
22
*/
23
 
#include <drizzled/server_includes.h>
 
23
 
 
24
#ifdef USE_PRAGMA_IMPLEMENTATION
 
25
#pragma implementation                          // gcc: Class implementation
 
26
#endif
 
27
 
 
28
#include "mysql_priv.h"
24
29
#include "sql_select.h"
 
30
#include <m_ctype.h>
25
31
#include <errno.h>
26
 
#include <drizzled/drizzled_error_messages.h>
27
32
 
28
33
// Maximum allowed exponent value for converting string to decimal
29
34
#define MAX_EXPONENT 1024
45
50
  following #defines describe that gap and how to canculate number of fields
46
51
  and index of field in thia array.
47
52
*/
48
 
#define FIELDTYPE_TEAR_FROM (DRIZZLE_TYPE_VARCHAR + 1)
49
 
#define FIELDTYPE_TEAR_TO   (DRIZZLE_TYPE_NEWDECIMAL - 1)
 
53
#define FIELDTYPE_TEAR_FROM (MYSQL_TYPE_VARCHAR + 1)
 
54
#define FIELDTYPE_TEAR_TO   (MYSQL_TYPE_NEWDECIMAL - 1)
50
55
#define FIELDTYPE_NUM (FIELDTYPE_TEAR_FROM + (255 - FIELDTYPE_TEAR_TO))
51
56
inline int field_type2index (enum_field_types field_type)
52
57
{
58
63
 
59
64
static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
60
65
{
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
 
  },
107
 
  /* DRIZZLE_TYPE_LONG -> */
108
 
  {
109
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
110
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_LONG,
111
 
  //DRIZZLE_TYPE_LONG
112
 
    DRIZZLE_TYPE_LONG,
113
 
  //DRIZZLE_TYPE_DOUBLE
114
 
    DRIZZLE_TYPE_DOUBLE,
115
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
116
 
    DRIZZLE_TYPE_LONG,         DRIZZLE_TYPE_VARCHAR,
117
 
  //DRIZZLE_TYPE_LONGLONG
118
 
    DRIZZLE_TYPE_LONGLONG,
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
128
 
    DRIZZLE_TYPE_BLOB,
129
 
  },
130
 
  /* DRIZZLE_TYPE_DOUBLE -> */
131
 
  {
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
151
 
    DRIZZLE_TYPE_BLOB,
152
 
  },
153
 
  /* DRIZZLE_TYPE_NULL -> */
154
 
  {
155
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
156
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_TINY,
157
 
  //DRIZZLE_TYPE_LONG
158
 
    DRIZZLE_TYPE_LONG,
159
 
  //DRIZZLE_TYPE_DOUBLE
160
 
    DRIZZLE_TYPE_DOUBLE,
161
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
162
 
    DRIZZLE_TYPE_NULL,        DRIZZLE_TYPE_TIMESTAMP,
163
 
  //DRIZZLE_TYPE_LONGLONG
164
 
    DRIZZLE_TYPE_LONGLONG,
165
 
  //DRIZZLE_TYPE_TIME
166
 
    DRIZZLE_TYPE_TIME,
167
 
  //DRIZZLE_TYPE_DATETIME
168
 
    DRIZZLE_TYPE_DATETIME,
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
174
 
    DRIZZLE_TYPE_BLOB,
175
 
  },
176
 
  /* DRIZZLE_TYPE_TIMESTAMP -> */
177
 
  {
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
197
 
    DRIZZLE_TYPE_BLOB,
198
 
  },
199
 
  /* DRIZZLE_TYPE_LONGLONG -> */
200
 
  {
201
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
202
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_LONGLONG,
203
 
  //DRIZZLE_TYPE_LONG
204
 
    DRIZZLE_TYPE_LONGLONG,
205
 
  //DRIZZLE_TYPE_DOUBLE
206
 
    DRIZZLE_TYPE_DOUBLE,
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,
244
 
  },
245
 
  /* DRIZZLE_TYPE_DATETIME -> */
246
 
  {
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
266
 
    DRIZZLE_TYPE_BLOB,
267
 
  },
268
 
  /* DRIZZLE_TYPE_NEWDATE -> */
269
 
  {
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
289
 
    DRIZZLE_TYPE_BLOB,
290
 
  },
291
 
  /* DRIZZLE_TYPE_VARCHAR -> */
292
 
  {
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
312
 
    DRIZZLE_TYPE_BLOB,
313
 
  },
314
 
  /* DRIZZLE_TYPE_NEWDECIMAL -> */
315
 
  {
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
321
 
    DRIZZLE_TYPE_DOUBLE,
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
335
 
    DRIZZLE_TYPE_BLOB,
336
 
  },
337
 
  /* DRIZZLE_TYPE_ENUM -> */
338
 
  {
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
358
 
    DRIZZLE_TYPE_BLOB,
359
 
  },
360
 
  /* DRIZZLE_TYPE_BLOB -> */
361
 
  {
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,
382
 
  },
 
66
  /* MYSQL_TYPE_DECIMAL -> */
 
67
  {
 
68
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
69
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_NEWDECIMAL,
 
70
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
71
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_NEWDECIMAL,
 
72
  //MYSQL_TYPE_DOUBLE
 
73
    MYSQL_TYPE_DOUBLE,
 
74
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
75
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
 
76
  //MYSQL_TYPE_LONGLONG
 
77
    MYSQL_TYPE_NEWDECIMAL,
 
78
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
79
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
80
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
81
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
82
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
83
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
84
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
85
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
 
86
  //MYSQL_TYPE_SET
 
87
    MYSQL_TYPE_VARCHAR,
 
88
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
89
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
90
  //MYSQL_TYPE_STRING       
 
91
    MYSQL_TYPE_STRING
 
92
  },
 
93
  /* MYSQL_TYPE_TINY -> */
 
94
  {
 
95
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
96
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_TINY,
 
97
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
98
    MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
 
99
  //MYSQL_TYPE_DOUBLE
 
100
    MYSQL_TYPE_DOUBLE,
 
101
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
102
    MYSQL_TYPE_TINY,        MYSQL_TYPE_VARCHAR,
 
103
  //MYSQL_TYPE_LONGLONG
 
104
    MYSQL_TYPE_LONGLONG,
 
105
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
106
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
107
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
108
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_TINY,
 
109
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
110
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
111
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
112
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
 
113
  //MYSQL_TYPE_SET
 
114
    MYSQL_TYPE_VARCHAR,
 
115
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
116
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
117
  //MYSQL_TYPE_STRING       
 
118
    MYSQL_TYPE_STRING     
 
119
  },
 
120
  /* MYSQL_TYPE_SHORT -> */
 
121
  {
 
122
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
123
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_SHORT,
 
124
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
125
    MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
 
126
  //MYSQL_TYPE_DOUBLE
 
127
    MYSQL_TYPE_DOUBLE,
 
128
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
129
    MYSQL_TYPE_SHORT,       MYSQL_TYPE_VARCHAR,
 
130
  //MYSQL_TYPE_LONGLONG
 
131
    MYSQL_TYPE_LONGLONG,
 
132
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
133
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
134
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
135
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_SHORT,
 
136
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
137
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
138
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
139
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
 
140
  //MYSQL_TYPE_SET
 
141
    MYSQL_TYPE_VARCHAR,
 
142
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
143
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
144
  //MYSQL_TYPE_STRING
 
145
    MYSQL_TYPE_STRING
 
146
  },
 
147
  /* MYSQL_TYPE_LONG -> */
 
148
  {
 
149
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
150
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_LONG,
 
151
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
152
    MYSQL_TYPE_LONG,        MYSQL_TYPE_LONG,
 
153
  //MYSQL_TYPE_DOUBLE
 
154
    MYSQL_TYPE_DOUBLE,
 
155
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
156
    MYSQL_TYPE_LONG,         MYSQL_TYPE_VARCHAR,
 
157
  //MYSQL_TYPE_LONGLONG
 
158
    MYSQL_TYPE_LONGLONG,
 
159
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
160
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
161
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
162
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_LONG,
 
163
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
164
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
165
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
166
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
 
167
  //MYSQL_TYPE_SET
 
168
    MYSQL_TYPE_VARCHAR,
 
169
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
170
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
171
  //MYSQL_TYPE_STRING
 
172
    MYSQL_TYPE_STRING
 
173
  },
 
174
  /* MYSQL_TYPE_DOUBLE -> */
 
175
  {
 
176
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
177
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
 
178
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
179
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_DOUBLE,
 
180
  //MYSQL_TYPE_DOUBLE
 
181
    MYSQL_TYPE_DOUBLE,
 
182
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
183
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_VARCHAR,
 
184
  //MYSQL_TYPE_LONGLONG
 
185
    MYSQL_TYPE_DOUBLE,
 
186
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
187
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
188
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
189
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_DOUBLE,
 
190
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
191
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
192
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
193
    MYSQL_TYPE_DOUBLE,      MYSQL_TYPE_VARCHAR,
 
194
  //MYSQL_TYPE_SET
 
195
    MYSQL_TYPE_VARCHAR,
 
196
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
197
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
198
  //MYSQL_TYPE_STRING
 
199
    MYSQL_TYPE_STRING
 
200
  },
 
201
  /* MYSQL_TYPE_NULL -> */
 
202
  {
 
203
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
204
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_TINY,
 
205
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
206
    MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
 
207
  //MYSQL_TYPE_DOUBLE
 
208
    MYSQL_TYPE_DOUBLE,
 
209
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
210
    MYSQL_TYPE_NULL,        MYSQL_TYPE_TIMESTAMP,
 
211
  //MYSQL_TYPE_LONGLONG
 
212
    MYSQL_TYPE_LONGLONG,
 
213
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
214
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_TIME,
 
215
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
216
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_YEAR,
 
217
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
218
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
 
219
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
220
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_ENUM,
 
221
  //MYSQL_TYPE_SET
 
222
    MYSQL_TYPE_SET,
 
223
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
224
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
225
  //MYSQL_TYPE_STRING
 
226
    MYSQL_TYPE_STRING
 
227
  },
 
228
  /* MYSQL_TYPE_TIMESTAMP -> */
 
229
  {
 
230
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
231
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
232
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
233
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
234
  //MYSQL_TYPE_DOUBLE
 
235
    MYSQL_TYPE_VARCHAR,
 
236
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
237
    MYSQL_TYPE_TIMESTAMP,   MYSQL_TYPE_TIMESTAMP,
 
238
  //MYSQL_TYPE_LONGLONG
 
239
    MYSQL_TYPE_VARCHAR,
 
240
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
241
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_DATETIME,
 
242
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
243
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VARCHAR,
 
244
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
245
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
 
246
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
247
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
248
  //MYSQL_TYPE_SET
 
249
    MYSQL_TYPE_VARCHAR,
 
250
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
251
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
252
  //MYSQL_TYPE_STRING
 
253
    MYSQL_TYPE_STRING
 
254
  },
 
255
  /* MYSQL_TYPE_LONGLONG -> */
 
256
  {
 
257
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
258
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_LONGLONG,
 
259
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
260
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_LONGLONG,
 
261
  //MYSQL_TYPE_DOUBLE
 
262
    MYSQL_TYPE_DOUBLE,
 
263
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
264
    MYSQL_TYPE_LONGLONG,    MYSQL_TYPE_VARCHAR,
 
265
  //MYSQL_TYPE_LONGLONG
 
266
    MYSQL_TYPE_LONGLONG,
 
267
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
268
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
269
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
270
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_LONGLONG,
 
271
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
272
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
 
273
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
274
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
 
275
  //MYSQL_TYPE_SET
 
276
    MYSQL_TYPE_VARCHAR,
 
277
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
278
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
279
  //MYSQL_TYPE_STRING
 
280
    MYSQL_TYPE_STRING
 
281
  },
 
282
  /* MYSQL_TYPE_DATE -> */
 
283
  {
 
284
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
285
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
286
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
287
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
288
  //MYSQL_TYPE_DOUBLE
 
289
    MYSQL_TYPE_VARCHAR,
 
290
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
291
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
 
292
  //MYSQL_TYPE_LONGLONG
 
293
    MYSQL_TYPE_VARCHAR,
 
294
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
295
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
 
296
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
297
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VARCHAR,
 
298
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
299
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
 
300
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
301
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
302
  //MYSQL_TYPE_SET
 
303
    MYSQL_TYPE_VARCHAR,
 
304
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
305
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
306
  //MYSQL_TYPE_STRING
 
307
    MYSQL_TYPE_STRING
 
308
  },
 
309
  /* MYSQL_TYPE_TIME -> */
 
310
  {
 
311
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
312
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
313
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
314
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
315
  //MYSQL_TYPE_DOUBLE
 
316
    MYSQL_TYPE_VARCHAR,
 
317
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
318
    MYSQL_TYPE_TIME,        MYSQL_TYPE_DATETIME,
 
319
  //MYSQL_TYPE_LONGLONG
 
320
    MYSQL_TYPE_VARCHAR,
 
321
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
322
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_TIME,
 
323
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
324
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VARCHAR,
 
325
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
326
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
 
327
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
328
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
329
  //MYSQL_TYPE_SET
 
330
    MYSQL_TYPE_VARCHAR,
 
331
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
332
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
333
  //MYSQL_TYPE_STRING
 
334
    MYSQL_TYPE_STRING
 
335
  },
 
336
  /* MYSQL_TYPE_DATETIME -> */
 
337
  {
 
338
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
339
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
340
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
341
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
342
  //MYSQL_TYPE_DOUBLE
 
343
    MYSQL_TYPE_VARCHAR,
 
344
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
345
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_DATETIME,
 
346
  //MYSQL_TYPE_LONGLONG
 
347
    MYSQL_TYPE_VARCHAR,
 
348
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
349
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_DATETIME,
 
350
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
351
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VARCHAR,
 
352
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
353
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
 
354
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
355
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
356
  //MYSQL_TYPE_SET
 
357
    MYSQL_TYPE_VARCHAR,
 
358
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
359
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
360
  //MYSQL_TYPE_STRING
 
361
    MYSQL_TYPE_STRING
 
362
  },
 
363
  /* MYSQL_TYPE_YEAR -> */
 
364
  {
 
365
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
366
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_TINY,
 
367
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
368
    MYSQL_TYPE_SHORT,       MYSQL_TYPE_LONG,
 
369
  //MYSQL_TYPE_DOUBLE
 
370
    MYSQL_TYPE_DOUBLE,
 
371
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
372
    MYSQL_TYPE_YEAR,        MYSQL_TYPE_VARCHAR,
 
373
  //MYSQL_TYPE_LONGLONG
 
374
    MYSQL_TYPE_LONGLONG,
 
375
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
376
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
377
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
378
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_YEAR,
 
379
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
380
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
381
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
382
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
 
383
  //MYSQL_TYPE_SET
 
384
    MYSQL_TYPE_VARCHAR,
 
385
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
386
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
387
  //MYSQL_TYPE_STRING
 
388
    MYSQL_TYPE_STRING
 
389
  },
 
390
  /* MYSQL_TYPE_NEWDATE -> */
 
391
  {
 
392
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
393
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
394
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
395
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
396
  //MYSQL_TYPE_DOUBLE
 
397
    MYSQL_TYPE_VARCHAR,
 
398
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
399
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
 
400
  //MYSQL_TYPE_LONGLONG
 
401
    MYSQL_TYPE_VARCHAR,
 
402
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
403
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_DATETIME,
 
404
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
405
    MYSQL_TYPE_DATETIME,    MYSQL_TYPE_VARCHAR,
 
406
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
407
    MYSQL_TYPE_NEWDATE,     MYSQL_TYPE_VARCHAR,
 
408
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
409
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
410
  //MYSQL_TYPE_SET
 
411
    MYSQL_TYPE_VARCHAR,
 
412
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
413
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
414
  //MYSQL_TYPE_STRING
 
415
    MYSQL_TYPE_STRING
 
416
  },
 
417
  /* MYSQL_TYPE_VARCHAR -> */
 
418
  {
 
419
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
420
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
421
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
422
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
423
  //MYSQL_TYPE_DOUBLE
 
424
    MYSQL_TYPE_VARCHAR,
 
425
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
426
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
427
  //MYSQL_TYPE_LONGLONG
 
428
    MYSQL_TYPE_VARCHAR,
 
429
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
430
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
431
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
432
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
433
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
434
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
435
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
436
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
437
  //MYSQL_TYPE_SET
 
438
    MYSQL_TYPE_VARCHAR,
 
439
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
440
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
441
  //MYSQL_TYPE_STRING
 
442
    MYSQL_TYPE_VARCHAR
 
443
  },
 
444
  /* MYSQL_TYPE_NEWDECIMAL -> */
 
445
  {
 
446
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
447
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_NEWDECIMAL,
 
448
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
449
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_NEWDECIMAL,
 
450
  //MYSQL_TYPE_DOUBLE
 
451
    MYSQL_TYPE_DOUBLE,
 
452
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
453
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
 
454
  //MYSQL_TYPE_LONGLONG
 
455
    MYSQL_TYPE_NEWDECIMAL,
 
456
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
457
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
458
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
459
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_NEWDECIMAL,
 
460
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
461
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
462
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
463
    MYSQL_TYPE_NEWDECIMAL,  MYSQL_TYPE_VARCHAR,
 
464
  //MYSQL_TYPE_SET
 
465
    MYSQL_TYPE_VARCHAR,
 
466
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
467
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
468
  //MYSQL_TYPE_STRING
 
469
    MYSQL_TYPE_STRING
 
470
  },
 
471
  /* MYSQL_TYPE_ENUM -> */
 
472
  {
 
473
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
474
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
475
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
476
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
477
  //MYSQL_TYPE_DOUBLE
 
478
    MYSQL_TYPE_VARCHAR,
 
479
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
480
    MYSQL_TYPE_ENUM,        MYSQL_TYPE_VARCHAR,
 
481
  //MYSQL_TYPE_LONGLONG
 
482
    MYSQL_TYPE_VARCHAR,
 
483
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
484
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
485
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
486
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
487
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
488
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
489
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
490
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
491
  //MYSQL_TYPE_SET
 
492
    MYSQL_TYPE_VARCHAR,
 
493
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
494
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
495
  //MYSQL_TYPE_STRING
 
496
    MYSQL_TYPE_STRING
 
497
  },
 
498
  /* MYSQL_TYPE_SET -> */
 
499
  {
 
500
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
501
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
502
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
503
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
504
  //MYSQL_TYPE_DOUBLE
 
505
    MYSQL_TYPE_VARCHAR,
 
506
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
507
    MYSQL_TYPE_SET,         MYSQL_TYPE_VARCHAR,
 
508
  //MYSQL_TYPE_LONGLONG
 
509
    MYSQL_TYPE_VARCHAR,
 
510
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
511
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
512
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
513
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
514
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
515
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
516
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
517
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
518
  //MYSQL_TYPE_SET
 
519
    MYSQL_TYPE_VARCHAR,
 
520
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
521
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
522
  //MYSQL_TYPE_STRING
 
523
    MYSQL_TYPE_STRING
 
524
  },
 
525
  /* MYSQL_TYPE_BLOB -> */
 
526
  {
 
527
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
528
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
 
529
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
530
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
 
531
  //MYSQL_TYPE_DOUBLE
 
532
    MYSQL_TYPE_BLOB,
 
533
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
534
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
 
535
  //MYSQL_TYPE_LONGLONG
 
536
    MYSQL_TYPE_BLOB,
 
537
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
538
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
 
539
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
540
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
 
541
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
542
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
 
543
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
544
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
 
545
  //MYSQL_TYPE_SET
 
546
    MYSQL_TYPE_BLOB,
 
547
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
548
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_BLOB,
 
549
  //MYSQL_TYPE_STRING
 
550
    MYSQL_TYPE_BLOB
 
551
  },
 
552
  /* MYSQL_TYPE_VAR_STRING -> */
 
553
  {
 
554
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
555
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
556
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
557
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
558
  //MYSQL_TYPE_DOUBLE
 
559
    MYSQL_TYPE_VARCHAR,
 
560
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
561
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
562
  //MYSQL_TYPE_LONGLONG
 
563
    MYSQL_TYPE_VARCHAR,
 
564
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
565
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
566
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
567
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
568
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
569
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
570
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
571
    MYSQL_TYPE_VARCHAR,     MYSQL_TYPE_VARCHAR,
 
572
  //MYSQL_TYPE_SET
 
573
    MYSQL_TYPE_VARCHAR,
 
574
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
575
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
576
  //MYSQL_TYPE_STRING
 
577
    MYSQL_TYPE_VARCHAR
 
578
  },
 
579
  /* MYSQL_TYPE_STRING -> */
 
580
  {
 
581
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
 
582
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
 
583
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
584
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
 
585
  //MYSQL_TYPE_DOUBLE
 
586
    MYSQL_TYPE_STRING,
 
587
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
 
588
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
 
589
  //MYSQL_TYPE_LONGLONG
 
590
    MYSQL_TYPE_STRING,
 
591
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
592
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
 
593
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
594
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
 
595
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
596
    MYSQL_TYPE_STRING,      MYSQL_TYPE_VARCHAR,
 
597
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
 
598
    MYSQL_TYPE_STRING,      MYSQL_TYPE_STRING,
 
599
  //MYSQL_TYPE_SET
 
600
    MYSQL_TYPE_STRING,
 
601
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
602
    MYSQL_TYPE_BLOB,        MYSQL_TYPE_VARCHAR,
 
603
  //MYSQL_TYPE_STRING
 
604
    MYSQL_TYPE_STRING
 
605
  }
383
606
};
384
607
 
385
608
/**
404
627
 
405
628
static Item_result field_types_result_type [FIELDTYPE_NUM]=
406
629
{
407
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
630
  //MYSQL_TYPE_DECIMAL      MYSQL_TYPE_TINY
408
631
  DECIMAL_RESULT,           INT_RESULT,
409
 
  //DRIZZLE_TYPE_LONG
410
 
  INT_RESULT,
411
 
  //DRIZZLE_TYPE_DOUBLE
 
632
  //MYSQL_TYPE_SHORT        MYSQL_TYPE_LONG
 
633
  INT_RESULT,               INT_RESULT,
 
634
  //MYSQL_TYPE_DOUBLE
412
635
  REAL_RESULT,
413
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
636
  //MYSQL_TYPE_NULL         MYSQL_TYPE_TIMESTAMP
414
637
  STRING_RESULT,            STRING_RESULT,
415
 
  //DRIZZLE_TYPE_LONGLONG
 
638
  //MYSQL_TYPE_LONGLONG
416
639
  INT_RESULT,
417
 
  //DRIZZLE_TYPE_TIME
418
 
  STRING_RESULT,
419
 
  //DRIZZLE_TYPE_DATETIME
420
 
  STRING_RESULT,
421
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
422
 
  STRING_RESULT,            STRING_RESULT,
423
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
640
  //MYSQL_TYPE_DATE         MYSQL_TYPE_TIME
 
641
  STRING_RESULT,            STRING_RESULT,
 
642
  //MYSQL_TYPE_DATETIME     MYSQL_TYPE_YEAR
 
643
  STRING_RESULT,            INT_RESULT,
 
644
  //MYSQL_TYPE_NEWDATE      MYSQL_TYPE_VARCHAR
 
645
  STRING_RESULT,            STRING_RESULT,
 
646
  //MYSQL_TYPE_NEWDECIMAL   MYSQL_TYPE_ENUM
424
647
  DECIMAL_RESULT,           STRING_RESULT,
425
 
  //DRIZZLE_TYPE_BLOB
 
648
  //MYSQL_TYPE_SET
426
649
  STRING_RESULT,
 
650
  //MYSQL_TYPE_BLOB         MYSQL_TYPE_VAR_STRING
 
651
  STRING_RESULT,            STRING_RESULT,
 
652
  //MYSQL_TYPE_STRING
 
653
  STRING_RESULT
427
654
};
428
655
 
429
656
 
444
671
*/
445
672
 
446
673
static bool
447
 
test_if_important_data(const CHARSET_INFO * const cs, const char *str,
448
 
                       const char *strend)
 
674
test_if_important_data(CHARSET_INFO *cs, const char *str, const char *strend)
449
675
{
450
676
  if (cs != &my_charset_bin)
451
677
    str+= cs->cset->scan(cs, str, strend, MY_SEQ_SPACES);
491
717
bool Field::type_can_have_key_part(enum enum_field_types type)
492
718
{
493
719
  switch (type) {
494
 
  case DRIZZLE_TYPE_VARCHAR:
495
 
  case DRIZZLE_TYPE_BLOB:
 
720
  case MYSQL_TYPE_VARCHAR:
 
721
  case MYSQL_TYPE_BLOB:
 
722
  case MYSQL_TYPE_VAR_STRING:
 
723
  case MYSQL_TYPE_STRING:
496
724
    return true;
497
725
  default:
498
726
    return false;
503
731
/**
504
732
  Numeric fields base class constructor.
505
733
*/
506
 
Field_num::Field_num(unsigned char *ptr_arg,uint32_t len_arg, unsigned char *null_ptr_arg,
507
 
                     unsigned char null_bit_arg, utype unireg_check_arg,
 
734
Field_num::Field_num(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
 
735
                     uchar null_bit_arg, utype unireg_check_arg,
508
736
                     const char *field_name_arg,
509
 
                     uint8_t dec_arg, bool zero_arg, bool unsigned_arg)
 
737
                     uint8 dec_arg, bool zero_arg, bool unsigned_arg)
510
738
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
511
739
         unireg_check_arg, field_name_arg),
512
 
  dec(dec_arg),decimal_precision(zero_arg),unsigned_flag(unsigned_arg)
 
740
  dec(dec_arg),zerofill(zero_arg),unsigned_flag(unsigned_arg)
513
741
{
 
742
  if (zerofill)
 
743
    flags|=ZEROFILL_FLAG;
514
744
  if (unsigned_flag)
515
745
    flags|=UNSIGNED_FLAG;
516
746
}
517
747
 
518
748
 
 
749
void Field_num::prepend_zeros(String *value)
 
750
{
 
751
  int diff;
 
752
  if ((diff= (int) (field_length - value->length())) > 0)
 
753
  {
 
754
    bmove_upp((uchar*) value->ptr()+field_length,
 
755
              (uchar*) value->ptr()+value->length(),
 
756
              value->length());
 
757
    bfill((uchar*) value->ptr(),diff,'0');
 
758
    value->length(field_length);
 
759
    (void) value->c_ptr_quick();                // Avoid warnings in purify
 
760
  }
 
761
}
 
762
 
519
763
/**
520
764
  Test if given number is a int.
521
765
 
538
782
    2   error: garbage at the end of string.
539
783
*/
540
784
 
541
 
int Field_num::check_int(const CHARSET_INFO * const cs, const char *str, int length, 
 
785
int Field_num::check_int(CHARSET_INFO *cs, const char *str, int length, 
542
786
                         const char *int_end, int error)
543
787
{
544
788
  /* Test if we get an empty string or wrong integer */
545
789
  if (str == int_end || error == MY_ERRNO_EDOM)
546
790
  {
547
791
    char buff[128];
548
 
    String tmp(buff, (uint32_t) sizeof(buff), system_charset_info);
 
792
    String tmp(buff, (uint32) sizeof(buff), system_charset_info);
549
793
    tmp.copy(str, length, system_charset_info);
550
 
    push_warning_printf(table->in_use, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
794
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
551
795
                        ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, 
552
796
                        ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
553
797
                        "integer", tmp.c_ptr(), field_name,
554
 
                        (uint32_t) table->in_use->row_count);
 
798
                        (ulong) table->in_use->row_count);
555
799
    return 1;
556
800
  }
557
801
  /* Test if we have garbage at the end of the given string. */
558
802
  if (test_if_important_data(cs, int_end, str + length))
559
803
  {
560
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
 
804
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
561
805
    return 2;
562
806
  }
563
807
  return 0;
587
831
    1   error
588
832
*/
589
833
 
590
 
bool Field_num::get_int(const CHARSET_INFO * const cs, const char *from, uint32_t len,
 
834
bool Field_num::get_int(CHARSET_INFO *cs, const char *from, uint len,
591
835
                        int64_t *rnd, uint64_t unsigned_max, 
592
836
                        int64_t signed_min, int64_t signed_max)
593
837
{
625
869
  return 0;
626
870
 
627
871
out_of_range:
628
 
  set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
872
  set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
629
873
  return 1;
630
874
}
631
875
 
645
889
{
646
890
  if (op_result == E_DEC_OVERFLOW)
647
891
  {
648
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
892
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
649
893
    return 1;
650
894
  }
651
895
  if (op_result == E_DEC_TRUNCATED)
652
896
  {
653
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_NOTE, ER_WARN_DATA_TRUNCATED, 1);
 
897
    set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
654
898
    /* We return 0 here as this is not a critical issue */
655
899
  }
656
900
  return 0;
658
902
 
659
903
 
660
904
#ifdef NOT_USED
661
 
static bool test_if_real(const char *str,int length, const CHARSET_INFO * const cs)
 
905
static bool test_if_real(const char *str,int length, CHARSET_INFO *cs)
662
906
{
663
907
  cs= system_charset_info; // QQ move test_if_real into CHARSET_INFO struct
664
908
 
718
962
  This is used for printing bit_fields as numbers while debugging.
719
963
*/
720
964
 
721
 
String *Field::val_int_as_str(String *val_buffer, bool unsigned_val)
 
965
String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_val)
722
966
{
723
 
  const CHARSET_INFO * const cs= &my_charset_bin;
724
 
  uint32_t length;
 
967
  CHARSET_INFO *cs= &my_charset_bin;
 
968
  uint length;
725
969
  int64_t value= val_int();
726
970
 
727
971
  if (val_buffer->alloc(MY_INT64_NUM_DECIMAL_DIGITS))
728
972
    return 0;
729
 
  length= (uint32_t) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
 
973
  length= (uint) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
730
974
                                                MY_INT64_NUM_DECIMAL_DIGITS,
731
975
                                                unsigned_val ? 10 : -10,
732
976
                                                value);
736
980
 
737
981
 
738
982
/// This is used as a table name when the table structure is not set up
739
 
Field::Field(unsigned char *ptr_arg,uint32_t length_arg,unsigned char *null_ptr_arg,
740
 
             unsigned char null_bit_arg,
 
983
Field::Field(uchar *ptr_arg,uint32 length_arg,uchar *null_ptr_arg,
 
984
             uchar null_bit_arg,
741
985
             utype unireg_check_arg, const char *field_name_arg)
742
986
  :ptr(ptr_arg), null_ptr(null_ptr_arg),
743
987
   table(0), orig_table(0), table_name(0),
754
998
}
755
999
 
756
1000
 
757
 
void Field::hash(uint32_t *nr, uint32_t *nr2)
 
1001
void Field::hash(ulong *nr, ulong *nr2)
758
1002
{
759
1003
  if (is_null())
760
1004
  {
762
1006
  }
763
1007
  else
764
1008
  {
765
 
    uint32_t len= pack_length();
766
 
    const CHARSET_INFO * const cs= charset();
 
1009
    uint len= pack_length();
 
1010
    CHARSET_INFO *cs= charset();
767
1011
    cs->coll->hash_sort(cs, ptr, len, nr, nr2);
768
1012
  }
769
1013
}
783
1027
  memcpy(ptr,ptr+row_offset,pack_length());
784
1028
  if (null_ptr)
785
1029
  {
786
 
    *null_ptr= (unsigned char) ((null_ptr[0] & (unsigned char) ~(uint32_t) null_bit) | (null_ptr[row_offset] & (unsigned char) null_bit));
 
1030
    *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) | (null_ptr[row_offset] & (uchar) null_bit));
787
1031
  }
788
1032
}
789
1033
 
810
1054
   @retval 0 if this field's size is < the source field's size
811
1055
   @retval 1 if this field's size is >= the source field's size
812
1056
*/
813
 
int Field::compatible_field_size(uint32_t field_metadata)
 
1057
int Field::compatible_field_size(uint field_metadata)
814
1058
{
815
 
  uint32_t const source_size= pack_length_from_metadata(field_metadata);
816
 
  uint32_t const destination_size= row_pack_length();
 
1059
  uint const source_size= pack_length_from_metadata(field_metadata);
 
1060
  uint const destination_size= row_pack_length();
817
1061
  return (source_size <= destination_size);
818
1062
}
819
1063
 
820
1064
 
821
 
int Field::store(const char *to, uint32_t length, const CHARSET_INFO * const cs,
 
1065
int Field::store(const char *to, uint length, CHARSET_INFO *cs,
822
1066
                 enum_check_fields check_level)
823
1067
{
824
1068
  int res;
867
1111
   the value of this flag is a moot point since the native format is
868
1112
   little-endian.
869
1113
*/
870
 
unsigned char *
871
 
Field::pack(unsigned char *to, const unsigned char *from, uint32_t max_length,
 
1114
uchar *
 
1115
Field::pack(uchar *to, const uchar *from, uint max_length,
872
1116
            bool low_byte_first __attribute__((unused)))
873
1117
{
874
 
  uint32_t length= pack_length();
 
1118
  uint32 length= pack_length();
875
1119
  set_if_smaller(length, max_length);
876
1120
  memcpy(to, from, length);
877
1121
  return to+length;
907
1151
 
908
1152
   @return  New pointer into memory based on from + length of the data
909
1153
*/
910
 
const unsigned char *
911
 
Field::unpack(unsigned char* to, const unsigned char *from, uint32_t param_data,
 
1154
const uchar *
 
1155
Field::unpack(uchar* to, const uchar *from, uint param_data,
912
1156
              bool low_byte_first __attribute__((unused)))
913
1157
{
914
 
  uint32_t length=pack_length();
 
1158
  uint length=pack_length();
915
1159
  int from_type= 0;
916
1160
  /*
917
1161
    If from length is > 255, it has encoded data in the upper bits. Need
931
1175
    return from+length;
932
1176
  }
933
1177
 
934
 
  uint32_t len= (param_data && (param_data < length)) ?
 
1178
  uint len= (param_data && (param_data < length)) ?
935
1179
            param_data : length;
936
1180
 
937
1181
  memcpy(to, from, param_data > length ? length : len);
939
1183
}
940
1184
 
941
1185
 
942
 
my_decimal *Field::val_decimal(my_decimal *decimal __attribute__((unused)))
 
1186
my_decimal *Field::val_decimal(my_decimal *decimal __attribute__((__unused__)))
943
1187
{
944
1188
  /* This never have to be called */
945
1189
  assert(0);
947
1191
}
948
1192
 
949
1193
 
950
 
void Field_num::add_unsigned(String &res) const
 
1194
void Field_num::add_zerofill_and_unsigned(String &res) const
951
1195
{
952
1196
  if (unsigned_flag)
953
1197
    res.append(STRING_WITH_LEN(" unsigned"));
 
1198
  if (zerofill)
 
1199
    res.append(STRING_WITH_LEN(" zerofill"));
954
1200
}
955
1201
 
956
1202
 
1001
1247
  {
1002
1248
    if (val->sign())
1003
1249
    {
1004
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1250
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1005
1251
      i= 0;
1006
1252
      *err= 1;
1007
1253
    }
1069
1315
}
1070
1316
 
1071
1317
 
1072
 
Field_str::Field_str(unsigned char *ptr_arg,uint32_t len_arg, unsigned char *null_ptr_arg,
1073
 
                     unsigned char null_bit_arg, utype unireg_check_arg,
1074
 
                     const char *field_name_arg, const CHARSET_INFO * const charset_arg)
 
1318
Field_str::Field_str(uchar *ptr_arg,uint32 len_arg, uchar *null_ptr_arg,
 
1319
                     uchar null_bit_arg, utype unireg_check_arg,
 
1320
                     const char *field_name_arg, CHARSET_INFO *charset_arg)
1075
1321
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1076
1322
         unireg_check_arg, field_name_arg)
1077
1323
{
1126
1372
}
1127
1373
 
1128
1374
 
1129
 
uint32_t Field::fill_cache_field(CACHE_FIELD *copy)
 
1375
uint Field::fill_cache_field(CACHE_FIELD *copy)
1130
1376
{
1131
 
  uint32_t store_length;
 
1377
  uint store_length;
1132
1378
  copy->str=ptr;
1133
1379
  copy->length=pack_length();
1134
1380
  copy->blob_field=0;
1139
1385
    copy->length-= table->s->blob_ptr_size;
1140
1386
    return copy->length;
1141
1387
  }
 
1388
  else if (!zero_pack() &&
 
1389
           (type() == MYSQL_TYPE_STRING && copy->length >= 4 &&
 
1390
            copy->length < 256))
 
1391
  {
 
1392
    copy->strip=1;                              /* Remove end space */
 
1393
    store_length= 2;
 
1394
  }
1142
1395
  else
1143
1396
  {
1144
1397
    copy->strip=0;
1148
1401
}
1149
1402
 
1150
1403
 
1151
 
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
 
1404
bool Field::get_date(MYSQL_TIME *ltime,uint fuzzydate)
1152
1405
{
1153
1406
  char buff[40];
1154
1407
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1155
1408
  if (!(res=val_str(&tmp)) ||
1156
1409
      str_to_datetime_with_warn(res->ptr(), res->length(),
1157
 
                                ltime, fuzzydate) <= DRIZZLE_TIMESTAMP_ERROR)
 
1410
                                ltime, fuzzydate) <= MYSQL_TIMESTAMP_ERROR)
1158
1411
    return 1;
1159
1412
  return 0;
1160
1413
}
1161
1414
 
1162
 
bool Field::get_time(DRIZZLE_TIME *ltime)
 
1415
bool Field::get_time(MYSQL_TIME *ltime)
1163
1416
{
1164
1417
  char buff[40];
1165
1418
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1176
1429
    Needs to be changed if/when we want to support different time formats.
1177
1430
*/
1178
1431
 
1179
 
int Field::store_time(DRIZZLE_TIME *ltime,
1180
 
                      enum enum_drizzle_timestamp_type type_arg __attribute__((unused)))
 
1432
int Field::store_time(MYSQL_TIME *ltime,
 
1433
                      timestamp_type type_arg __attribute__((__unused__)))
1181
1434
{
1182
1435
  char buff[MAX_DATE_STRING_REP_LENGTH];
1183
 
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
 
1436
  uint length= (uint) my_TIME_to_str(ltime, buff);
1184
1437
  return store(buff, length, &my_charset_bin);
1185
1438
}
1186
1439
 
1187
1440
 
1188
 
bool Field::optimize_range(uint32_t idx, uint32_t part)
 
1441
bool Field::optimize_range(uint idx, uint part)
1189
1442
{
1190
1443
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
1191
1444
}
1192
1445
 
1193
1446
 
1194
 
Field *Field::new_field(MEM_ROOT *root, Table *new_table,
 
1447
Field *Field::new_field(MEM_ROOT *root, struct st_table *new_table,
1195
1448
                        bool keep_type __attribute__((unused)))
1196
1449
{
1197
1450
  Field *tmp;
1205
1458
  tmp->part_of_key.init(0);
1206
1459
  tmp->part_of_sortkey.init(0);
1207
1460
  tmp->unireg_check= Field::NONE;
1208
 
  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
 
1461
  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG |
 
1462
                ZEROFILL_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
1209
1463
  tmp->reset_fields();
1210
1464
  return tmp;
1211
1465
}
1212
1466
 
1213
1467
 
1214
 
Field *Field::new_key_field(MEM_ROOT *root, Table *new_table,
1215
 
                            unsigned char *new_ptr, unsigned char *new_null_ptr,
1216
 
                            uint32_t new_null_bit)
 
1468
Field *Field::new_key_field(MEM_ROOT *root, struct st_table *new_table,
 
1469
                            uchar *new_ptr, uchar *new_null_ptr,
 
1470
                            uint new_null_bit)
1217
1471
{
1218
1472
  Field *tmp;
1219
1473
  if ((tmp= new_field(root, new_table, table == new_table)))
1226
1480
}
1227
1481
 
1228
1482
 
1229
 
/* This is used to generate a field in Table from TABLE_SHARE */
 
1483
/* This is used to generate a field in TABLE from TABLE_SHARE */
1230
1484
 
1231
 
Field *Field::clone(MEM_ROOT *root, Table *new_table)
 
1485
Field *Field::clone(MEM_ROOT *root, struct st_table *new_table)
1232
1486
{
1233
1487
  Field *tmp;
1234
1488
  if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
1245
1499
** tiny int
1246
1500
****************************************************************************/
1247
1501
 
1248
 
int Field_tiny::store(const char *from,uint32_t len, const CHARSET_INFO * const cs)
 
1502
int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs)
1249
1503
{
1250
1504
  int error;
1251
1505
  int64_t rnd;
1265
1519
    if (nr < 0.0)
1266
1520
    {
1267
1521
      *ptr=0;
1268
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1522
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1269
1523
      error= 1;
1270
1524
    }
1271
1525
    else if (nr > 255.0)
1272
1526
    {
1273
1527
      *ptr=(char) 255;
1274
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1528
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1275
1529
      error= 1;
1276
1530
    }
1277
1531
    else
1282
1536
    if (nr < -128.0)
1283
1537
    {
1284
1538
      *ptr= (char) -128;
1285
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1539
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1286
1540
      error= 1;
1287
1541
    }
1288
1542
    else if (nr > 127.0)
1289
1543
    {
1290
1544
      *ptr=127;
1291
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1545
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1292
1546
      error= 1;
1293
1547
    }
1294
1548
    else
1307
1561
    if (nr < 0 && !unsigned_val)
1308
1562
    {
1309
1563
      *ptr= 0;
1310
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1564
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1311
1565
      error= 1;
1312
1566
    }
1313
1567
    else if ((uint64_t) nr > (uint64_t) 255)
1314
1568
    {
1315
1569
      *ptr= (char) 255;
1316
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1570
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1317
1571
      error= 1;
1318
1572
    }
1319
1573
    else
1326
1580
    if (nr < -128)
1327
1581
    {
1328
1582
      *ptr= (char) -128;
1329
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1583
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1330
1584
      error= 1;
1331
1585
    }
1332
1586
    else if (nr > 127)
1333
1587
    {
1334
1588
      *ptr=127;
1335
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
1589
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1336
1590
      error= 1;
1337
1591
    }
1338
1592
    else
1361
1615
String *Field_tiny::val_str(String *val_buffer,
1362
1616
                            String *val_ptr __attribute__((unused)))
1363
1617
{
1364
 
  const CHARSET_INFO * const cs= &my_charset_bin;
1365
 
  uint32_t length;
1366
 
  uint32_t mlength=cmax(field_length+1,5*cs->mbmaxlen);
 
1618
  CHARSET_INFO *cs= &my_charset_bin;
 
1619
  uint length;
 
1620
  uint mlength=max(field_length+1,5*cs->mbmaxlen);
1367
1621
  val_buffer->alloc(mlength);
1368
1622
  char *to=(char*) val_buffer->ptr();
1369
1623
 
1370
1624
  if (unsigned_flag)
1371
 
    length= (uint32_t) cs->cset->long10_to_str(cs,to,mlength, 10,
 
1625
    length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
1372
1626
                                           (long) *ptr);
1373
1627
  else
1374
 
    length= (uint32_t) cs->cset->long10_to_str(cs,to,mlength,-10,
 
1628
    length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
1375
1629
                                           (long) *((signed char*) ptr));
1376
1630
  
1377
1631
  val_buffer->length(length);
1378
 
 
 
1632
  if (zerofill)
 
1633
    prepend_zeros(val_buffer);
1379
1634
  return val_buffer;
1380
1635
}
1381
1636
 
1382
1637
bool Field_tiny::send_binary(Protocol *protocol)
1383
1638
{
1384
 
  return protocol->store_tiny((int64_t) (int8_t) ptr[0]);
 
1639
  return protocol->store_tiny((int64_t) (int8) ptr[0]);
1385
1640
}
1386
1641
 
1387
 
int Field_tiny::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
 
1642
int Field_tiny::cmp(const uchar *a_ptr, const uchar *b_ptr)
1388
1643
{
1389
1644
  signed char a,b;
1390
1645
  a=(signed char) a_ptr[0]; b= (signed char) b_ptr[0];
1391
1646
  if (unsigned_flag)
1392
 
    return ((unsigned char) a < (unsigned char) b) ? -1 : ((unsigned char) a > (unsigned char) b) ? 1 : 0;
 
1647
    return ((uchar) a < (uchar) b) ? -1 : ((uchar) a > (uchar) b) ? 1 : 0;
1393
1648
  return (a < b) ? -1 : (a > b) ? 1 : 0;
1394
1649
}
1395
1650
 
1396
 
void Field_tiny::sort_string(unsigned char *to,uint32_t length __attribute__((unused)))
 
1651
void Field_tiny::sort_string(uchar *to,uint length __attribute__((unused)))
1397
1652
{
1398
1653
  if (unsigned_flag)
1399
1654
    *to= *ptr;
1400
1655
  else
1401
 
    to[0] = (char) (ptr[0] ^ (unsigned char) 128);      /* Revers signbit */
 
1656
    to[0] = (char) (ptr[0] ^ (uchar) 128);      /* Revers signbit */
1402
1657
}
1403
1658
 
1404
1659
void Field_tiny::sql_type(String &res) const
1405
1660
{
1406
 
  const CHARSET_INFO * const cs=res.charset();
 
1661
  CHARSET_INFO *cs=res.charset();
1407
1662
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
1408
1663
                          "tinyint(%d)",(int) field_length));
1409
 
  add_unsigned(res);
 
1664
  add_zerofill_and_unsigned(res);
1410
1665
}
1411
1666
 
1412
1667
 
1441
1696
                        const char *well_formed_error_pos,
1442
1697
                        const char *cannot_convert_error_pos,
1443
1698
                        const char *end,
1444
 
                        const CHARSET_INFO * const cs)
 
1699
                        CHARSET_INFO *cs)
1445
1700
{
1446
1701
  const char *pos, *end_orig;
1447
1702
  char tmp[64], *t;
1487
1742
  *t= '\0';
1488
1743
  push_warning_printf(field->table->in_use, 
1489
1744
                      field->table->in_use->abort_on_warning ?
1490
 
                      DRIZZLE_ERROR::WARN_LEVEL_ERROR :
1491
 
                      DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
1745
                      MYSQL_ERROR::WARN_LEVEL_ERROR :
 
1746
                      MYSQL_ERROR::WARN_LEVEL_WARN,
1492
1747
                      ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, 
1493
1748
                      ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
1494
1749
                      "string", tmp, field->field_name,
1495
 
                      (uint32_t) field->table->in_use->row_count);
 
1750
                      (ulong) field->table->in_use->row_count);
1496
1751
  return true;
1497
1752
}
1498
1753
 
1523
1778
    if (test_if_important_data(field_charset, ptr, end))
1524
1779
    {
1525
1780
      if (table->in_use->abort_on_warning)
1526
 
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
 
1781
        set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
1527
1782
      else
1528
 
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
 
1783
        set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
1529
1784
    }
1530
1785
    else /* If we lost only spaces then produce a NOTE, not a WARNING */
1531
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_NOTE, ER_WARN_DATA_TRUNCATED, 1);
 
1786
      set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
1532
1787
    return 2;
1533
1788
  }
1534
1789
  return 0;
1536
1791
 
1537
1792
 
1538
1793
/**
1539
 
  Store double value in Field_varstring.
 
1794
  Store double value in Field_string or Field_varstring.
1540
1795
 
1541
1796
  Pretty prints double number into field_length characters buffer.
1542
1797
 
1546
1801
int Field_str::store(double nr)
1547
1802
{
1548
1803
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
1549
 
  uint32_t local_char_length= field_length / charset()->mbmaxlen;
 
1804
  uint local_char_length= field_length / charset()->mbmaxlen;
1550
1805
  size_t length;
1551
 
  bool error;
 
1806
  my_bool error;
1552
1807
 
1553
1808
  length= my_gcvt(nr, MY_GCVT_ARG_DOUBLE, local_char_length, buff, &error);
1554
1809
  if (error)
1555
1810
  {
1556
1811
    if (table->in_use->abort_on_warning)
1557
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
 
1812
      set_warning(MYSQL_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
1558
1813
    else
1559
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
 
1814
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
1560
1815
  }
1561
1816
  return store(buff, length, charset());
1562
1817
}
1563
1818
 
1564
1819
 
1565
 
uint32_t Field::is_equal(Create_field *new_field)
 
1820
uint Field::is_equal(Create_field *new_field)
1566
1821
{
1567
1822
  return (new_field->sql_type == real_type());
1568
1823
}
1570
1825
 
1571
1826
/* If one of the fields is binary and the other one isn't return 1 else 0 */
1572
1827
 
1573
 
bool Field_str::compare_str_field_flags(Create_field *new_field, uint32_t flag_arg)
 
1828
bool Field_str::compare_str_field_flags(Create_field *new_field, uint32 flag_arg)
1574
1829
{
1575
1830
  return (((new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
1576
1831
          !(flag_arg & (BINCMP_FLAG | BINARY_FLAG))) ||
1579
1834
}
1580
1835
 
1581
1836
 
1582
 
uint32_t Field_str::is_equal(Create_field *new_field)
 
1837
uint Field_str::is_equal(Create_field *new_field)
1583
1838
{
1584
1839
  if (compare_str_field_flags(new_field, flags))
1585
1840
    return 0;
1598
1853
  return store(str.ptr(), str.length(), str.charset());
1599
1854
}
1600
1855
 
1601
 
uint32_t Field_longstr::max_data_length() const
 
1856
uint32 Field_longstr::max_data_length() const
1602
1857
{
1603
1858
  return field_length + (field_length > 255 ? 2 : 1);
1604
1859
}
1605
1860
 
1606
1861
 
 
1862
/****************************************************************************
 
1863
** enum type.
 
1864
** This is a string which only can have a selection of different values.
 
1865
** If one uses this string in a number context one gets the type number.
 
1866
****************************************************************************/
 
1867
 
 
1868
enum ha_base_keytype Field_enum::key_type() const
 
1869
{
 
1870
  switch (packlength) {
 
1871
  default: return HA_KEYTYPE_BINARY;
 
1872
  case 2: return HA_KEYTYPE_USHORT_INT;
 
1873
  case 3: return HA_KEYTYPE_UINT24;
 
1874
  case 4: return HA_KEYTYPE_ULONG_INT;
 
1875
  case 8: return HA_KEYTYPE_ULONGLONG;
 
1876
  }
 
1877
}
 
1878
 
 
1879
void Field_enum::store_type(uint64_t value)
 
1880
{
 
1881
  switch (packlength) {
 
1882
  case 1: ptr[0]= (uchar) value;  break;
 
1883
  case 2:
 
1884
#ifdef WORDS_BIGENDIAN
 
1885
  if (table->s->db_low_byte_first)
 
1886
  {
 
1887
    int2store(ptr,(unsigned short) value);
 
1888
  }
 
1889
  else
 
1890
#endif
 
1891
    shortstore(ptr,(unsigned short) value);
 
1892
  break;
 
1893
  case 3: int3store(ptr,(long) value); break;
 
1894
  case 4:
 
1895
#ifdef WORDS_BIGENDIAN
 
1896
  if (table->s->db_low_byte_first)
 
1897
  {
 
1898
    int4store(ptr,value);
 
1899
  }
 
1900
  else
 
1901
#endif
 
1902
    longstore(ptr,(long) value);
 
1903
  break;
 
1904
  case 8:
 
1905
#ifdef WORDS_BIGENDIAN
 
1906
  if (table->s->db_low_byte_first)
 
1907
  {
 
1908
    int8store(ptr,value);
 
1909
  }
 
1910
  else
 
1911
#endif
 
1912
    int64_tstore(ptr,value); break;
 
1913
  }
 
1914
}
 
1915
 
 
1916
 
 
1917
/**
 
1918
  @note
 
1919
    Storing a empty string in a enum field gives a warning
 
1920
    (if there isn't a empty value in the enum)
 
1921
*/
 
1922
 
 
1923
int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
 
1924
{
 
1925
  int err= 0;
 
1926
  uint32 not_used;
 
1927
  char buff[STRING_BUFFER_USUAL_SIZE];
 
1928
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
 
1929
 
 
1930
  /* Convert character set if necessary */
 
1931
  if (String::needs_conversion(length, cs, field_charset, &not_used))
 
1932
  { 
 
1933
    uint dummy_errors;
 
1934
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
 
1935
    from= tmpstr.ptr();
 
1936
    length=  tmpstr.length();
 
1937
  }
 
1938
 
 
1939
  /* Remove end space */
 
1940
  length= field_charset->cset->lengthsp(field_charset, from, length);
 
1941
  uint tmp=find_type2(typelib, from, length, field_charset);
 
1942
  if (!tmp)
 
1943
  {
 
1944
    if (length < 6) // Can't be more than 99999 enums
 
1945
    {
 
1946
      /* This is for reading numbers with LOAD DATA INFILE */
 
1947
      char *end;
 
1948
      tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
 
1949
      if (err || end != from+length || tmp > typelib->count)
 
1950
      {
 
1951
        tmp=0;
 
1952
        set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
 
1953
      }
 
1954
      if (!table->in_use->count_cuted_fields)
 
1955
        err= 0;
 
1956
    }
 
1957
    else
 
1958
      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
 
1959
  }
 
1960
  store_type((uint64_t) tmp);
 
1961
  return err;
 
1962
}
 
1963
 
 
1964
 
 
1965
int Field_enum::store(double nr)
 
1966
{
 
1967
  return Field_enum::store((int64_t) nr, false);
 
1968
}
 
1969
 
 
1970
 
 
1971
int Field_enum::store(int64_t nr,
 
1972
                      bool unsigned_val __attribute__((__unused__)))
 
1973
{
 
1974
  int error= 0;
 
1975
  if ((uint64_t) nr > typelib->count || nr == 0)
 
1976
  {
 
1977
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
 
1978
    if (nr != 0 || table->in_use->count_cuted_fields)
 
1979
    {
 
1980
      nr= 0;
 
1981
      error= 1;
 
1982
    }
 
1983
  }
 
1984
  store_type((uint64_t) (uint) nr);
 
1985
  return error;
 
1986
}
 
1987
 
 
1988
 
 
1989
double Field_enum::val_real(void)
 
1990
{
 
1991
  return (double) Field_enum::val_int();
 
1992
}
 
1993
 
 
1994
 
 
1995
int64_t Field_enum::val_int(void)
 
1996
{
 
1997
  switch (packlength) {
 
1998
  case 1:
 
1999
    return (int64_t) ptr[0];
 
2000
  case 2:
 
2001
  {
 
2002
    uint16 tmp;
 
2003
#ifdef WORDS_BIGENDIAN
 
2004
    if (table->s->db_low_byte_first)
 
2005
      tmp=sint2korr(ptr);
 
2006
    else
 
2007
#endif
 
2008
      shortget(tmp,ptr);
 
2009
    return (int64_t) tmp;
 
2010
  }
 
2011
  case 3:
 
2012
    return (int64_t) uint3korr(ptr);
 
2013
  case 4:
 
2014
  {
 
2015
    uint32 tmp;
 
2016
#ifdef WORDS_BIGENDIAN
 
2017
    if (table->s->db_low_byte_first)
 
2018
      tmp=uint4korr(ptr);
 
2019
    else
 
2020
#endif
 
2021
      longget(tmp,ptr);
 
2022
    return (int64_t) tmp;
 
2023
  }
 
2024
  case 8:
 
2025
  {
 
2026
    int64_t tmp;
 
2027
#ifdef WORDS_BIGENDIAN
 
2028
    if (table->s->db_low_byte_first)
 
2029
      tmp=sint8korr(ptr);
 
2030
    else
 
2031
#endif
 
2032
      int64_tget(tmp,ptr);
 
2033
    return tmp;
 
2034
  }
 
2035
  }
 
2036
  return 0;                                     // impossible
 
2037
}
 
2038
 
 
2039
 
 
2040
/**
 
2041
   Save the field metadata for enum fields.
 
2042
 
 
2043
   Saves the real type in the first byte and the pack length in the 
 
2044
   second byte of the field metadata array at index of *metadata_ptr and
 
2045
   *(metadata_ptr + 1).
 
2046
 
 
2047
   @param   metadata_ptr   First byte of field metadata
 
2048
 
 
2049
   @returns number of bytes written to metadata_ptr
 
2050
*/
 
2051
int Field_enum::do_save_field_metadata(uchar *metadata_ptr)
 
2052
{
 
2053
  *metadata_ptr= real_type();
 
2054
  *(metadata_ptr + 1)= pack_length();
 
2055
  return 2;
 
2056
}
 
2057
 
 
2058
 
 
2059
String *Field_enum::val_str(String *val_buffer __attribute__((unused)),
 
2060
                            String *val_ptr)
 
2061
{
 
2062
  uint tmp=(uint) Field_enum::val_int();
 
2063
  if (!tmp || tmp > typelib->count)
 
2064
    val_ptr->set("", 0, field_charset);
 
2065
  else
 
2066
    val_ptr->set((const char*) typelib->type_names[tmp-1],
 
2067
                 typelib->type_lengths[tmp-1],
 
2068
                 field_charset);
 
2069
  return val_ptr;
 
2070
}
 
2071
 
 
2072
int Field_enum::cmp(const uchar *a_ptr, const uchar *b_ptr)
 
2073
{
 
2074
  uchar *old= ptr;
 
2075
  ptr= (uchar*) a_ptr;
 
2076
  uint64_t a=Field_enum::val_int();
 
2077
  ptr= (uchar*) b_ptr;
 
2078
  uint64_t b=Field_enum::val_int();
 
2079
  ptr= old;
 
2080
  return (a < b) ? -1 : (a > b) ? 1 : 0;
 
2081
}
 
2082
 
 
2083
void Field_enum::sort_string(uchar *to,uint length __attribute__((unused)))
 
2084
{
 
2085
  uint64_t value=Field_enum::val_int();
 
2086
  to+=packlength-1;
 
2087
  for (uint i=0 ; i < packlength ; i++)
 
2088
  {
 
2089
    *to-- = (uchar) (value & 255);
 
2090
    value>>=8;
 
2091
  }
 
2092
}
 
2093
 
 
2094
 
 
2095
void Field_enum::sql_type(String &res) const
 
2096
{
 
2097
  char buffer[255];
 
2098
  String enum_item(buffer, sizeof(buffer), res.charset());
 
2099
 
 
2100
  res.length(0);
 
2101
  res.append(STRING_WITH_LEN("enum("));
 
2102
 
 
2103
  bool flag=0;
 
2104
  uint *len= typelib->type_lengths;
 
2105
  for (const char **pos= typelib->type_names; *pos; pos++, len++)
 
2106
  {
 
2107
    uint dummy_errors;
 
2108
    if (flag)
 
2109
      res.append(',');
 
2110
    /* convert to res.charset() == utf8, then quote */
 
2111
    enum_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
 
2112
    append_unescaped(&res, enum_item.ptr(), enum_item.length());
 
2113
    flag= 1;
 
2114
  }
 
2115
  res.append(')');
 
2116
}
 
2117
 
 
2118
 
 
2119
Field *Field_enum::new_field(MEM_ROOT *root, struct st_table *new_table,
 
2120
                             bool keep_type)
 
2121
{
 
2122
  Field_enum *res= (Field_enum*) Field::new_field(root, new_table, keep_type);
 
2123
  if (res)
 
2124
    res->typelib= copy_typelib(root, typelib);
 
2125
  return res;
 
2126
}
 
2127
 
 
2128
 
1607
2129
/**
1608
2130
  @retval
1609
2131
    1  if the fields are equally defined
1631
2153
 
1632
2154
  if (typelib->count < from_lib->count)
1633
2155
    return 0;
1634
 
  for (uint32_t i=0 ; i < from_lib->count ; i++)
 
2156
  for (uint i=0 ; i < from_lib->count ; i++)
1635
2157
    if (my_strnncoll(field_charset,
1636
 
                     (const unsigned char*)typelib->type_names[i],
 
2158
                     (const uchar*)typelib->type_names[i],
1637
2159
                     strlen(typelib->type_names[i]),
1638
 
                     (const unsigned char*)from_lib->type_names[i],
 
2160
                     (const uchar*)from_lib->type_names[i],
1639
2161
                     strlen(from_lib->type_names[i])))
1640
2162
      return 0;
1641
2163
  return 1;
1652
2174
  Field_num *from_num= (Field_num*) field;
1653
2175
 
1654
2176
  if (unsigned_flag != from_num->unsigned_flag ||
 
2177
      (zerofill && !from_num->zerofill && !zero_pack()) ||
1655
2178
      dec != from_num->dec)
1656
2179
    return 0;
1657
2180
  return 1;
1658
2181
}
1659
2182
 
1660
2183
 
1661
 
uint32_t Field_num::is_equal(Create_field *new_field)
 
2184
uint Field_num::is_equal(Create_field *new_field)
1662
2185
{
1663
2186
  return ((new_field->sql_type == real_type()) &&
1664
 
          ((new_field->flags & UNSIGNED_FLAG) == (uint32_t) (flags &
 
2187
          ((new_field->flags & UNSIGNED_FLAG) == (uint) (flags &
1665
2188
                                                         UNSIGNED_FLAG)) &&
1666
2189
          ((new_field->flags & AUTO_INCREMENT_FLAG) ==
1667
 
           (uint32_t) (flags & AUTO_INCREMENT_FLAG)) &&
 
2190
           (uint) (flags & AUTO_INCREMENT_FLAG)) &&
1668
2191
          (new_field->length <= max_display_length()));
1669
2192
}
1670
2193
 
1680
2203
void Create_field::create_length_to_internal_length(void)
1681
2204
{
1682
2205
  switch (sql_type) {
1683
 
  case DRIZZLE_TYPE_BLOB:
1684
 
  case DRIZZLE_TYPE_VARCHAR:
 
2206
  case MYSQL_TYPE_BLOB:
 
2207
  case MYSQL_TYPE_VAR_STRING:
 
2208
  case MYSQL_TYPE_STRING:
 
2209
  case MYSQL_TYPE_VARCHAR:
1685
2210
    length*= charset->mbmaxlen;
1686
2211
    key_length= length;
1687
2212
    pack_length= calc_pack_length(sql_type, length);
1688
2213
    break;
1689
 
  case DRIZZLE_TYPE_ENUM:
 
2214
  case MYSQL_TYPE_ENUM:
 
2215
  case MYSQL_TYPE_SET:
1690
2216
    /* Pack_length already calculated in sql_parse.cc */
1691
2217
    length*= charset->mbmaxlen;
1692
2218
    key_length= pack_length;
1693
2219
    break;
1694
 
  case DRIZZLE_TYPE_NEWDECIMAL:
 
2220
  case MYSQL_TYPE_NEWDECIMAL:
1695
2221
    key_length= pack_length=
1696
2222
      my_decimal_get_binary_size(my_decimal_length_to_precision(length,
1697
2223
                                                                decimals,
1710
2236
  Init for a tmp table field. To be extended if need be.
1711
2237
*/
1712
2238
void Create_field::init_for_tmp_table(enum_field_types sql_type_arg,
1713
 
                                      uint32_t length_arg, uint32_t decimals_arg,
 
2239
                                      uint32 length_arg, uint32 decimals_arg,
1714
2240
                                      bool maybe_null, bool is_unsigned)
1715
2241
{
1716
2242
  field_name= "";
1748
2274
    true  on error
1749
2275
*/
1750
2276
 
1751
 
bool Create_field::init(THD *thd __attribute__((unused)), char *fld_name, enum_field_types fld_type,
 
2277
bool Create_field::init(THD *thd, char *fld_name, enum_field_types fld_type,
1752
2278
                        char *fld_length, char *fld_decimals,
1753
 
                        uint32_t fld_type_modifier, Item *fld_default_value,
 
2279
                        uint fld_type_modifier, Item *fld_default_value,
1754
2280
                        Item *fld_on_update_value, LEX_STRING *fld_comment,
1755
2281
                        char *fld_change, List<String> *fld_interval_list,
1756
 
                        const CHARSET_INFO * const fld_charset,
1757
 
                        uint32_t fld_geom_type __attribute__((unused)),
 
2282
                        CHARSET_INFO *fld_charset,
 
2283
                        uint fld_geom_type __attribute__((__unused__)),
1758
2284
                        enum column_format_type column_format)
1759
2285
{
1760
 
  uint32_t sign_len, allowed_type_modifier= 0;
1761
 
  uint32_t max_field_charlength= MAX_FIELD_CHARLENGTH;
 
2286
  uint sign_len, allowed_type_modifier= 0;
 
2287
  ulong max_field_charlength= MAX_FIELD_CHARLENGTH;
1762
2288
 
1763
2289
  field= 0;
1764
2290
  field_name= fld_name;
1765
2291
  def= fld_default_value;
1766
2292
  flags= fld_type_modifier;
1767
 
  flags|= (((uint32_t)column_format & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
 
2293
  flags|= (((uint)column_format & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
1768
2294
  unireg_check= (fld_type_modifier & AUTO_INCREMENT_FLAG ?
1769
2295
                 Field::NEXT_NUMBER : Field::NONE);
1770
 
  decimals= fld_decimals ? (uint32_t)atoi(fld_decimals) : 0;
 
2296
  decimals= fld_decimals ? (uint)atoi(fld_decimals) : 0;
1771
2297
  if (decimals >= NOT_FIXED_DEC)
1772
2298
  {
1773
2299
    my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
1789
2315
    it is NOT NULL, not an AUTO_INCREMENT field and not a TIMESTAMP.
1790
2316
  */
1791
2317
  if (!fld_default_value && !(fld_type_modifier & AUTO_INCREMENT_FLAG) &&
1792
 
      (fld_type_modifier & NOT_NULL_FLAG) && fld_type != DRIZZLE_TYPE_TIMESTAMP)
 
2318
      (fld_type_modifier & NOT_NULL_FLAG) && fld_type != MYSQL_TYPE_TIMESTAMP)
1793
2319
    flags|= NO_DEFAULT_VALUE_FLAG;
1794
2320
 
1795
 
  if (fld_length && !(length= (uint32_t) atoi(fld_length)))
 
2321
  if (fld_length && !(length= (uint) atoi(fld_length)))
1796
2322
    fld_length= 0; /* purecov: inspected */
1797
2323
  sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1;
1798
2324
 
1799
2325
  switch (fld_type) {
1800
 
  case DRIZZLE_TYPE_TINY:
 
2326
  case MYSQL_TYPE_TINY:
1801
2327
    if (!fld_length)
1802
2328
      length= MAX_TINYINT_WIDTH+sign_len;
1803
2329
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
1804
2330
    break;
1805
 
  case DRIZZLE_TYPE_LONG:
 
2331
  case MYSQL_TYPE_SHORT:
 
2332
    if (!fld_length)
 
2333
      length= MAX_SMALLINT_WIDTH+sign_len;
 
2334
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
 
2335
    break;
 
2336
  case MYSQL_TYPE_LONG:
1806
2337
    if (!fld_length)
1807
2338
      length= MAX_INT_WIDTH+sign_len;
1808
2339
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
1809
2340
    break;
1810
 
  case DRIZZLE_TYPE_LONGLONG:
 
2341
  case MYSQL_TYPE_LONGLONG:
1811
2342
    if (!fld_length)
1812
2343
      length= MAX_BIGINT_WIDTH;
1813
2344
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
1814
2345
    break;
1815
 
  case DRIZZLE_TYPE_NULL:
 
2346
  case MYSQL_TYPE_NULL:
1816
2347
    break;
1817
 
  case DRIZZLE_TYPE_NEWDECIMAL:
 
2348
  case MYSQL_TYPE_NEWDECIMAL:
1818
2349
    my_decimal_trim(&length, &decimals);
1819
2350
    if (length > DECIMAL_MAX_PRECISION)
1820
2351
    {
1833
2364
    pack_length=
1834
2365
      my_decimal_get_binary_size(length, decimals);
1835
2366
    break;
1836
 
  case DRIZZLE_TYPE_VARCHAR:
 
2367
  case MYSQL_TYPE_VARCHAR:
1837
2368
    /*
1838
2369
      Long VARCHAR's are automaticly converted to blobs in mysql_prepare_table
1839
2370
      if they don't have a default value
1840
2371
    */
1841
2372
    max_field_charlength= MAX_FIELD_VARCHARLENGTH;
1842
2373
    break;
1843
 
  case DRIZZLE_TYPE_BLOB:
 
2374
  case MYSQL_TYPE_STRING:
 
2375
    break;
 
2376
  case MYSQL_TYPE_BLOB:
1844
2377
    if (fld_default_value)
1845
2378
    {
1846
2379
      /* Allow empty as default value. */
1847
2380
      String str,*res;
1848
2381
      res= fld_default_value->val_str(&str);
 
2382
      /*
 
2383
        A default other than '' is always an error, and any non-NULL
 
2384
        specified default is an error in strict mode.
 
2385
      */
 
2386
      if (res->length() || (thd->variables.sql_mode &
 
2387
                            (MODE_STRICT_TRANS_TABLES |
 
2388
                             MODE_STRICT_ALL_TABLES)))
 
2389
      {
 
2390
        my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
 
2391
                 fld_name); /* purecov: inspected */
 
2392
        return(true);
 
2393
      }
 
2394
      else
 
2395
      {
 
2396
        /*
 
2397
          Otherwise a default of '' is just a warning.
 
2398
        */
 
2399
        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
 
2400
                            ER_BLOB_CANT_HAVE_DEFAULT,
 
2401
                            ER(ER_BLOB_CANT_HAVE_DEFAULT),
 
2402
                            fld_name);
 
2403
      }
 
2404
      def= 0;
1849
2405
    }
1850
2406
    flags|= BLOB_FLAG;
1851
2407
    break;
1852
 
  case DRIZZLE_TYPE_DOUBLE:
 
2408
  case MYSQL_TYPE_YEAR:
 
2409
    if (!fld_length || length != 2)
 
2410
      length= 4; /* Default length */
 
2411
    flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
 
2412
    break;
 
2413
  case MYSQL_TYPE_DOUBLE:
1853
2414
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
1854
2415
    if (!fld_length && !fld_decimals)
1855
2416
    {
1863
2424
      return(true);
1864
2425
    }
1865
2426
    break;
1866
 
  case DRIZZLE_TYPE_TIMESTAMP:
 
2427
  case MYSQL_TYPE_TIMESTAMP:
1867
2428
    if (!fld_length)
1868
2429
    {
1869
2430
      /* Compressed date YYYYMMDDHHMMSS */
1876
2437
        and 19 as length of 4.1 compatible representation.
1877
2438
      */
1878
2439
      length= ((length+1)/2)*2; /* purecov: inspected */
1879
 
      length= cmin(length, (uint32_t)MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
 
2440
      length= min(length, MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
1880
2441
    }
1881
 
    flags|= UNSIGNED_FLAG;
 
2442
    flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
1882
2443
    if (fld_default_value)
1883
2444
    {
1884
2445
      /* Grammar allows only NOW() value for ON UPDATE clause */
1917
2478
                                              Field::NONE));
1918
2479
    }
1919
2480
    break;
1920
 
  case DRIZZLE_TYPE_NEWDATE:
1921
 
    length= 10;
1922
 
    break;
1923
 
  case DRIZZLE_TYPE_TIME:
1924
 
    length= 10;
1925
 
    break;
1926
 
  case DRIZZLE_TYPE_DATETIME:
 
2481
  case MYSQL_TYPE_DATE:
 
2482
    /* Old date type. */
 
2483
    sql_type= MYSQL_TYPE_NEWDATE;
 
2484
    /* fall trough */
 
2485
  case MYSQL_TYPE_NEWDATE:
 
2486
    length= 10;
 
2487
    break;
 
2488
  case MYSQL_TYPE_TIME:
 
2489
    length= 10;
 
2490
    break;
 
2491
  case MYSQL_TYPE_DATETIME:
1927
2492
    length= MAX_DATETIME_WIDTH;
1928
2493
    break;
1929
 
  case DRIZZLE_TYPE_ENUM:
 
2494
  case MYSQL_TYPE_SET:
 
2495
    {
 
2496
      pack_length= get_set_pack_length(fld_interval_list->elements);
 
2497
 
 
2498
      List_iterator<String> it(*fld_interval_list);
 
2499
      String *tmp;
 
2500
      while ((tmp= it++))
 
2501
        interval_list.push_back(tmp);
 
2502
      /*
 
2503
        Set fake length to 1 to pass the below conditions.
 
2504
        Real length will be set in mysql_prepare_table()
 
2505
        when we know the character set of the column
 
2506
      */
 
2507
      length= 1;
 
2508
      break;
 
2509
    }
 
2510
  case MYSQL_TYPE_ENUM:
1930
2511
    {
1931
2512
      /* Should be safe. */
1932
2513
      pack_length= get_enum_pack_length(fld_interval_list->elements);
1935
2516
      String *tmp;
1936
2517
      while ((tmp= it++))
1937
2518
        interval_list.push_back(tmp);
1938
 
      length= 1; /* See comment for DRIZZLE_TYPE_SET above. */
 
2519
      length= 1; /* See comment for MYSQL_TYPE_SET above. */
1939
2520
      break;
1940
2521
   }
 
2522
  case MYSQL_TYPE_VAR_STRING:
 
2523
    assert(0);  /* Impossible, we killed it */
 
2524
    break;
1941
2525
  }
1942
2526
  /* Remember the value of length */
1943
2527
  char_length= length;
1944
2528
 
1945
2529
  if (!(flags & BLOB_FLAG) &&
1946
 
      ((length > max_field_charlength &&
1947
 
        fld_type != DRIZZLE_TYPE_ENUM &&
1948
 
        (fld_type != DRIZZLE_TYPE_VARCHAR || fld_default_value)) ||
1949
 
       (!length && fld_type != DRIZZLE_TYPE_VARCHAR)))
 
2530
      ((length > max_field_charlength && fld_type != MYSQL_TYPE_SET &&
 
2531
        fld_type != MYSQL_TYPE_ENUM &&
 
2532
        (fld_type != MYSQL_TYPE_VARCHAR || fld_default_value)) ||
 
2533
       (!length &&
 
2534
        fld_type != MYSQL_TYPE_STRING &&
 
2535
        fld_type != MYSQL_TYPE_VARCHAR)))
1950
2536
  {
1951
 
    my_error((fld_type == DRIZZLE_TYPE_VARCHAR) ?  ER_TOO_BIG_FIELDLENGTH : ER_TOO_BIG_DISPLAYWIDTH,
 
2537
    my_error((fld_type == MYSQL_TYPE_VAR_STRING ||
 
2538
              fld_type == MYSQL_TYPE_VARCHAR ||
 
2539
              fld_type == MYSQL_TYPE_STRING) ?  ER_TOO_BIG_FIELDLENGTH :
 
2540
                                                ER_TOO_BIG_DISPLAYWIDTH,
1952
2541
              MYF(0),
1953
2542
              fld_name, max_field_charlength); /* purecov: inspected */
1954
2543
    return(true);
1964
2553
}
1965
2554
 
1966
2555
 
1967
 
enum_field_types get_blob_type_from_length(uint32_t length __attribute__((unused)))
 
2556
enum_field_types get_blob_type_from_length(ulong length __attribute__((__unused__)))
1968
2557
{
1969
2558
  enum_field_types type;
1970
2559
 
1971
 
  type= DRIZZLE_TYPE_BLOB;
 
2560
  type= MYSQL_TYPE_BLOB;
1972
2561
 
1973
2562
  return type;
1974
2563
}
1978
2567
  Make a field from the .frm file info
1979
2568
*/
1980
2569
 
1981
 
uint32_t calc_pack_length(enum_field_types type,uint32_t length)
 
2570
uint32 calc_pack_length(enum_field_types type,uint32 length)
1982
2571
{
1983
2572
  switch (type) {
1984
 
  case DRIZZLE_TYPE_VARCHAR:     return (length + (length < 256 ? 1: 2));
1985
 
  case DRIZZLE_TYPE_TINY        : return 1;
1986
 
  case DRIZZLE_TYPE_NEWDATE:
1987
 
  case DRIZZLE_TYPE_TIME:   return 3;
1988
 
  case DRIZZLE_TYPE_TIMESTAMP:
1989
 
  case DRIZZLE_TYPE_LONG        : return 4;
1990
 
  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
1991
 
  case DRIZZLE_TYPE_DATETIME:
1992
 
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
1993
 
  case DRIZZLE_TYPE_NULL        : return 0;
1994
 
  case DRIZZLE_TYPE_BLOB:               return 4+portable_sizeof_char_ptr;
1995
 
  case DRIZZLE_TYPE_ENUM:
1996
 
  case DRIZZLE_TYPE_NEWDECIMAL:
 
2573
  case MYSQL_TYPE_VAR_STRING:
 
2574
  case MYSQL_TYPE_STRING:
 
2575
  case MYSQL_TYPE_VARCHAR:     return (length + (length < 256 ? 1: 2));
 
2576
  case MYSQL_TYPE_YEAR:
 
2577
  case MYSQL_TYPE_TINY  : return 1;
 
2578
  case MYSQL_TYPE_SHORT : return 2;
 
2579
  case MYSQL_TYPE_DATE:
 
2580
  case MYSQL_TYPE_NEWDATE:
 
2581
  case MYSQL_TYPE_TIME:   return 3;
 
2582
  case MYSQL_TYPE_TIMESTAMP:
 
2583
  case MYSQL_TYPE_LONG  : return 4;
 
2584
  case MYSQL_TYPE_DOUBLE: return sizeof(double);
 
2585
  case MYSQL_TYPE_DATETIME:
 
2586
  case MYSQL_TYPE_LONGLONG: return 8;   /* Don't crash if no int64_t */
 
2587
  case MYSQL_TYPE_NULL  : return 0;
 
2588
  case MYSQL_TYPE_BLOB:         return 4+portable_sizeof_char_ptr;
 
2589
  case MYSQL_TYPE_SET:
 
2590
  case MYSQL_TYPE_ENUM:
 
2591
  case MYSQL_TYPE_NEWDECIMAL:
1997
2592
    abort(); return 0;                          // This shouldn't happen
1998
2593
  default:
1999
2594
    return 0;
2001
2596
}
2002
2597
 
2003
2598
 
2004
 
uint32_t pack_length_to_packflag(uint32_t type)
 
2599
uint pack_length_to_packflag(uint type)
2005
2600
{
2006
2601
  switch (type) {
2007
 
    case 1: return f_settype((uint32_t) DRIZZLE_TYPE_TINY);
2008
 
    case 2: assert(1);
 
2602
    case 1: return f_settype((uint) MYSQL_TYPE_TINY);
 
2603
    case 2: return f_settype((uint) MYSQL_TYPE_SHORT);
2009
2604
    case 3: assert(1);
2010
 
    case 4: return f_settype((uint32_t) DRIZZLE_TYPE_LONG);
2011
 
    case 8: return f_settype((uint32_t) DRIZZLE_TYPE_LONGLONG);
 
2605
    case 4: return f_settype((uint) MYSQL_TYPE_LONG);
 
2606
    case 8: return f_settype((uint) MYSQL_TYPE_LONGLONG);
2012
2607
  }
2013
2608
  return 0;                                     // This shouldn't happen
2014
2609
}
2015
2610
 
2016
2611
 
2017
 
Field *make_field(TABLE_SHARE *share, unsigned char *ptr, uint32_t field_length,
2018
 
                  unsigned char *null_pos, unsigned char null_bit,
2019
 
                  uint32_t pack_flag,
 
2612
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32 field_length,
 
2613
                  uchar *null_pos, uchar null_bit,
 
2614
                  uint pack_flag,
2020
2615
                  enum_field_types field_type,
2021
 
                  const CHARSET_INFO * field_charset,
 
2616
                  CHARSET_INFO *field_charset,
2022
2617
                  Field::utype unireg_check,
2023
2618
                  TYPELIB *interval,
2024
2619
                  const char *field_name)
2030
2625
  }
2031
2626
  else
2032
2627
  {
2033
 
    null_bit= ((unsigned char) 1) << null_bit;
 
2628
    null_bit= ((uchar) 1) << null_bit;
2034
2629
  }
2035
2630
 
2036
2631
  switch (field_type) {
2037
 
  case DRIZZLE_TYPE_NEWDATE:
2038
 
  case DRIZZLE_TYPE_TIME:
2039
 
  case DRIZZLE_TYPE_DATETIME:
2040
 
  case DRIZZLE_TYPE_TIMESTAMP:
 
2632
  case MYSQL_TYPE_DATE:
 
2633
  case MYSQL_TYPE_NEWDATE:
 
2634
  case MYSQL_TYPE_TIME:
 
2635
  case MYSQL_TYPE_DATETIME:
 
2636
  case MYSQL_TYPE_TIMESTAMP:
2041
2637
    field_charset= &my_charset_bin;
2042
2638
  default: break;
2043
2639
  }
2046
2642
  {
2047
2643
    if (!f_is_packed(pack_flag))
2048
2644
    {
2049
 
      if (field_type == DRIZZLE_TYPE_VARCHAR)
 
2645
      if (field_type == MYSQL_TYPE_STRING ||
 
2646
          field_type == MYSQL_TYPE_VAR_STRING)
 
2647
        return new Field_string(ptr,field_length,null_pos,null_bit,
 
2648
                                unireg_check, field_name,
 
2649
                                field_charset);
 
2650
      if (field_type == MYSQL_TYPE_VARCHAR)
2050
2651
        return new Field_varstring(ptr,field_length,
2051
2652
                                   HA_VARCHAR_PACKLENGTH(field_length),
2052
2653
                                   null_pos,null_bit,
2056
2657
      return 0;                                 // Error
2057
2658
    }
2058
2659
 
2059
 
    uint32_t pack_length=calc_pack_length((enum_field_types)
 
2660
    uint pack_length=calc_pack_length((enum_field_types)
2060
2661
                                      f_packtype(pack_flag),
2061
2662
                                      field_length);
2062
2663
 
2070
2671
        return new Field_enum(ptr,field_length,null_pos,null_bit,
2071
2672
                                  unireg_check, field_name,
2072
2673
                                  pack_length, interval, field_charset);
 
2674
      else
 
2675
        return new Field_set(ptr,field_length,null_pos,null_bit,
 
2676
                             unireg_check, field_name,
 
2677
                             pack_length, interval, field_charset);
2073
2678
    }
2074
2679
  }
2075
2680
 
2076
2681
  switch (field_type) {
2077
 
  case DRIZZLE_TYPE_NEWDECIMAL:
 
2682
  case MYSQL_TYPE_NEWDECIMAL:
2078
2683
    return new Field_new_decimal(ptr,field_length,null_pos,null_bit,
2079
2684
                                 unireg_check, field_name,
2080
2685
                                 f_decimals(pack_flag),
2081
 
                                 f_is_decimal_precision(pack_flag) != 0,
 
2686
                                 f_is_zerofill(pack_flag) != 0,
2082
2687
                                 f_is_dec(pack_flag) == 0);
2083
 
  case DRIZZLE_TYPE_DOUBLE:
 
2688
  case MYSQL_TYPE_DOUBLE:
2084
2689
    return new Field_double(ptr,field_length,null_pos,null_bit,
2085
2690
                            unireg_check, field_name,
2086
2691
                            f_decimals(pack_flag),
2087
 
                            false,
 
2692
                            f_is_zerofill(pack_flag) != 0,
2088
2693
                            f_is_dec(pack_flag)== 0);
2089
 
  case DRIZZLE_TYPE_TINY:
 
2694
  case MYSQL_TYPE_TINY:
2090
2695
    return new Field_tiny(ptr,field_length,null_pos,null_bit,
2091
2696
                          unireg_check, field_name,
2092
 
                          false,
 
2697
                          f_is_zerofill(pack_flag) != 0,
2093
2698
                          f_is_dec(pack_flag) == 0);
2094
 
  case DRIZZLE_TYPE_LONG:
 
2699
  case MYSQL_TYPE_SHORT:
 
2700
    return new Field_short(ptr,field_length,null_pos,null_bit,
 
2701
                           unireg_check, field_name,
 
2702
                           f_is_zerofill(pack_flag) != 0,
 
2703
                           f_is_dec(pack_flag) == 0);
 
2704
  case MYSQL_TYPE_LONG:
2095
2705
    return new Field_long(ptr,field_length,null_pos,null_bit,
2096
2706
                           unireg_check, field_name,
2097
 
                           false,
 
2707
                           f_is_zerofill(pack_flag) != 0,
2098
2708
                           f_is_dec(pack_flag) == 0);
2099
 
  case DRIZZLE_TYPE_LONGLONG:
 
2709
  case MYSQL_TYPE_LONGLONG:
2100
2710
    return new Field_int64_t(ptr,field_length,null_pos,null_bit,
2101
2711
                              unireg_check, field_name,
2102
 
                              false,
 
2712
                              f_is_zerofill(pack_flag) != 0,
2103
2713
                              f_is_dec(pack_flag) == 0);
2104
 
  case DRIZZLE_TYPE_TIMESTAMP:
 
2714
  case MYSQL_TYPE_TIMESTAMP:
2105
2715
    return new Field_timestamp(ptr,field_length, null_pos, null_bit,
2106
2716
                               unireg_check, field_name, share,
2107
2717
                               field_charset);
2108
 
  case DRIZZLE_TYPE_NEWDATE:
 
2718
  case MYSQL_TYPE_YEAR:
 
2719
    return new Field_year(ptr,field_length,null_pos,null_bit,
 
2720
                          unireg_check, field_name);
 
2721
  case MYSQL_TYPE_DATE:
 
2722
  case MYSQL_TYPE_NEWDATE:
2109
2723
    return new Field_newdate(ptr,null_pos,null_bit,
2110
2724
                             unireg_check, field_name, field_charset);
2111
 
  case DRIZZLE_TYPE_TIME:
 
2725
  case MYSQL_TYPE_TIME:
2112
2726
    return new Field_time(ptr,null_pos,null_bit,
2113
2727
                          unireg_check, field_name, field_charset);
2114
 
  case DRIZZLE_TYPE_DATETIME:
 
2728
  case MYSQL_TYPE_DATETIME:
2115
2729
    return new Field_datetime(ptr,null_pos,null_bit,
2116
2730
                              unireg_check, field_name, field_charset);
2117
 
  case DRIZZLE_TYPE_NULL:
 
2731
  case MYSQL_TYPE_NULL:
2118
2732
    return new Field_null(ptr, field_length, unireg_check, field_name,
2119
2733
                          field_charset);
2120
2734
  default:                                      // Impossible (Wrong version)
2146
2760
                  portable_sizeof_char_ptr);
2147
2761
 
2148
2762
  switch (sql_type) {
2149
 
  case DRIZZLE_TYPE_BLOB:
2150
 
    sql_type= DRIZZLE_TYPE_BLOB;
 
2763
  case MYSQL_TYPE_BLOB:
 
2764
    sql_type= MYSQL_TYPE_BLOB;
2151
2765
    length/= charset->mbmaxlen;
2152
2766
    key_length/= charset->mbmaxlen;
2153
2767
    break;
 
2768
  case MYSQL_TYPE_STRING:
2154
2769
    /* Change CHAR -> VARCHAR if dynamic record length */
2155
 
  case DRIZZLE_TYPE_ENUM:
2156
 
  case DRIZZLE_TYPE_VARCHAR:
 
2770
    if (old_field->type() == MYSQL_TYPE_VAR_STRING)
 
2771
      sql_type= MYSQL_TYPE_VARCHAR;
 
2772
    /* fall through */
 
2773
 
 
2774
  case MYSQL_TYPE_ENUM:
 
2775
  case MYSQL_TYPE_SET:
 
2776
  case MYSQL_TYPE_VARCHAR:
 
2777
  case MYSQL_TYPE_VAR_STRING:
2157
2778
    /* This is corrected in create_length_to_internal_length */
2158
2779
    length= (length+charset->mbmaxlen-1) / charset->mbmaxlen;
2159
2780
    break;
2170
2791
 
2171
2792
  if (!(flags & (NO_DEFAULT_VALUE_FLAG | BLOB_FLAG)) &&
2172
2793
      old_field->ptr && orig_field &&
2173
 
      (sql_type != DRIZZLE_TYPE_TIMESTAMP ||                /* set def only if */
 
2794
      (sql_type != MYSQL_TYPE_TIMESTAMP ||                /* set def only if */
2174
2795
       old_field->table->timestamp_field != old_field ||  /* timestamp field */ 
2175
2796
       unireg_check == Field::TIMESTAMP_UN_FIELD))        /* has default val */
2176
2797
  {
2220
2841
*/
2221
2842
 
2222
2843
bool 
2223
 
Field::set_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code,
 
2844
Field::set_warning(MYSQL_ERROR::enum_warning_level level, uint code,
2224
2845
                   int cuted_increment)
2225
2846
{
2226
2847
  /*
2235
2856
                        thd->row_count);
2236
2857
    return 0;
2237
2858
  }
2238
 
  return level >= DRIZZLE_ERROR::WARN_LEVEL_WARN;
 
2859
  return level >= MYSQL_ERROR::WARN_LEVEL_WARN;
2239
2860
}
2240
2861
 
2241
2862
 
2256
2877
*/
2257
2878
 
2258
2879
void 
2259
 
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
2260
 
                            unsigned int code, 
2261
 
                            const char *str, uint32_t str_length, 
2262
 
                            enum enum_drizzle_timestamp_type ts_type, int cuted_increment)
 
2880
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
 
2881
                            const char *str, uint str_length, 
 
2882
                            timestamp_type ts_type, int cuted_increment)
2263
2883
{
2264
2884
  THD *thd= table ? table->in_use : current_thd;
2265
2885
  if ((thd->really_abort_on_warning() &&
2266
 
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
 
2886
       level >= MYSQL_ERROR::WARN_LEVEL_WARN) ||
2267
2887
      set_warning(level, code, cuted_increment))
2268
2888
    make_truncated_value_warning(thd, level, str, str_length, ts_type,
2269
2889
                                 field_name);
2286
2906
*/
2287
2907
 
2288
2908
void 
2289
 
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code, 
2290
 
                            int64_t nr, enum enum_drizzle_timestamp_type ts_type,
 
2909
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
 
2910
                            int64_t nr, timestamp_type ts_type,
2291
2911
                            int cuted_increment)
2292
2912
{
2293
2913
  THD *thd= table ? table->in_use : current_thd;
2296
2916
  {
2297
2917
    char str_nr[22];
2298
2918
    char *str_end= int64_t10_to_str(nr, str_nr, -10);
2299
 
    make_truncated_value_warning(thd, level, str_nr, (uint32_t) (str_end - str_nr), 
 
2919
    make_truncated_value_warning(thd, level, str_nr, (uint) (str_end - str_nr), 
2300
2920
                                 ts_type, field_name);
2301
2921
  }
2302
2922
}
2317
2937
*/
2318
2938
 
2319
2939
void 
2320
 
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code, 
2321
 
                            double nr, enum enum_drizzle_timestamp_type ts_type)
 
2940
Field::set_datetime_warning(MYSQL_ERROR::enum_warning_level level, uint code, 
 
2941
                            double nr, timestamp_type ts_type)
2322
2942
{
2323
2943
  THD *thd= table ? table->in_use : current_thd;
2324
2944
  if (thd->really_abort_on_warning() ||
2326
2946
  {
2327
2947
    /* DBL_DIG is enough to print '-[digits].E+###' */
2328
2948
    char str_nr[DBL_DIG + 8];
2329
 
    uint32_t str_len= sprintf(str_nr, "%g", nr);
 
2949
    uint str_len= sprintf(str_nr, "%g", nr);
2330
2950
    make_truncated_value_warning(thd, level, str_nr, str_len, ts_type,
2331
2951
                                 field_name);
2332
2952
  }