← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Brian Aker
  • Date: 2008-08-12 03:12:57 UTC
  • Revision ID: brian@tangent.org-20080812031257-ln3uk87y1r22byeg
First pass of new sql_db.cc work

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.cc
62
62
  {
63
63
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
64
64
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
65
 
  //DRIZZLE_TYPE_LONG
66
 
    DRIZZLE_TYPE_NEWDECIMAL,
 
65
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
66
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
67
67
  //DRIZZLE_TYPE_DOUBLE
68
68
    DRIZZLE_TYPE_DOUBLE,
69
69
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
70
70
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
71
71
  //DRIZZLE_TYPE_LONGLONG
72
72
    DRIZZLE_TYPE_NEWDECIMAL,
73
 
  //DRIZZLE_TYPE_TIME
74
 
    DRIZZLE_TYPE_VARCHAR,
 
73
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
74
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
75
75
  //DRIZZLE_TYPE_DATETIME
76
76
    DRIZZLE_TYPE_VARCHAR,
77
77
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
78
78
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
79
79
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
80
80
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
81
  //DRIZZLE_TYPE_SET
 
82
    DRIZZLE_TYPE_VARCHAR,
81
83
  //DRIZZLE_TYPE_BLOB
82
84
    DRIZZLE_TYPE_BLOB,
83
85
  },
85
87
  {
86
88
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
87
89
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_TINY,
88
 
  //DRIZZLE_TYPE_LONG
89
 
    DRIZZLE_TYPE_LONG,
 
90
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
91
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_LONG,
90
92
  //DRIZZLE_TYPE_DOUBLE
91
93
    DRIZZLE_TYPE_DOUBLE,
92
94
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
93
95
    DRIZZLE_TYPE_TINY,        DRIZZLE_TYPE_VARCHAR,
94
96
  //DRIZZLE_TYPE_LONGLONG
95
97
    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,
 
98
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
99
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
100
  //DRIZZLE_TYPE_DATETIME
 
101
    DRIZZLE_TYPE_VARCHAR,
 
102
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
103
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
104
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
105
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
106
  //DRIZZLE_TYPE_SET
 
107
    DRIZZLE_TYPE_VARCHAR,
 
108
  //DRIZZLE_TYPE_BLOB
 
109
    DRIZZLE_TYPE_BLOB,
 
110
  },
 
111
  /* DRIZZLE_TYPE_SHORT -> */
 
112
  {
 
113
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
114
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_SHORT,
 
115
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
116
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_LONG,
 
117
  //DRIZZLE_TYPE_DOUBLE
 
118
    DRIZZLE_TYPE_DOUBLE,
 
119
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
120
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_VARCHAR,
 
121
  //DRIZZLE_TYPE_LONGLONG
 
122
    DRIZZLE_TYPE_LONGLONG,
 
123
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
124
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
125
  //DRIZZLE_TYPE_DATETIME
 
126
    DRIZZLE_TYPE_VARCHAR,
 
127
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
128
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
129
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
130
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
131
  //DRIZZLE_TYPE_SET
 
132
    DRIZZLE_TYPE_VARCHAR,
104
133
  //DRIZZLE_TYPE_BLOB
105
134
    DRIZZLE_TYPE_BLOB,
106
135
  },
108
137
  {
109
138
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
110
139
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_LONG,
111
 
  //DRIZZLE_TYPE_LONG
112
 
    DRIZZLE_TYPE_LONG,
 
140
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
141
    DRIZZLE_TYPE_LONG,        DRIZZLE_TYPE_LONG,
113
142
  //DRIZZLE_TYPE_DOUBLE
114
143
    DRIZZLE_TYPE_DOUBLE,
115
144
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
116
145
    DRIZZLE_TYPE_LONG,         DRIZZLE_TYPE_VARCHAR,
117
146
  //DRIZZLE_TYPE_LONGLONG
118
147
    DRIZZLE_TYPE_LONGLONG,
119
 
  //DRIZZLE_TYPE_TIME
120
 
    DRIZZLE_TYPE_VARCHAR,
 
148
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
149
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
121
150
  //DRIZZLE_TYPE_DATETIME
122
151
    DRIZZLE_TYPE_VARCHAR,
123
152
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
124
153
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
125
154
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
126
155
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
156
  //DRIZZLE_TYPE_SET
 
157
    DRIZZLE_TYPE_VARCHAR,
127
158
  //DRIZZLE_TYPE_BLOB
128
159
    DRIZZLE_TYPE_BLOB,
129
160
  },
131
162
  {
132
163
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
133
164
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_DOUBLE,
134
 
  //DRIZZLE_TYPE_LONG
135
 
    DRIZZLE_TYPE_DOUBLE,
 
165
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
166
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_DOUBLE,
136
167
  //DRIZZLE_TYPE_DOUBLE
137
168
    DRIZZLE_TYPE_DOUBLE,
138
169
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
139
170
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_VARCHAR,
140
171
  //DRIZZLE_TYPE_LONGLONG
141
172
    DRIZZLE_TYPE_DOUBLE,
142
 
  //DRIZZLE_TYPE_TIME
143
 
    DRIZZLE_TYPE_VARCHAR,
 
173
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
174
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
144
175
  //DRIZZLE_TYPE_DATETIME
145
176
    DRIZZLE_TYPE_VARCHAR,
146
177
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
147
178
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
148
179
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
149
180
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_VARCHAR,
 
181
  //DRIZZLE_TYPE_SET
 
182
    DRIZZLE_TYPE_VARCHAR,
150
183
  //DRIZZLE_TYPE_BLOB
151
184
    DRIZZLE_TYPE_BLOB,
152
185
  },
154
187
  {
155
188
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
156
189
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_TINY,
157
 
  //DRIZZLE_TYPE_LONG
158
 
    DRIZZLE_TYPE_LONG,
 
190
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
191
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_LONG,
159
192
  //DRIZZLE_TYPE_DOUBLE
160
193
    DRIZZLE_TYPE_DOUBLE,
161
194
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
162
195
    DRIZZLE_TYPE_NULL,        DRIZZLE_TYPE_TIMESTAMP,
163
196
  //DRIZZLE_TYPE_LONGLONG
164
197
    DRIZZLE_TYPE_LONGLONG,
165
 
  //DRIZZLE_TYPE_TIME
166
 
    DRIZZLE_TYPE_TIME,
 
198
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
199
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_TIME,
167
200
  //DRIZZLE_TYPE_DATETIME
168
201
    DRIZZLE_TYPE_DATETIME,
169
202
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
170
203
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
171
204
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
172
205
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_ENUM,
 
206
  //DRIZZLE_TYPE_SET
 
207
    DRIZZLE_TYPE_SET,
173
208
  //DRIZZLE_TYPE_BLOB
174
209
    DRIZZLE_TYPE_BLOB,
175
210
  },
177
212
  {
178
213
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
179
214
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
180
 
  //DRIZZLE_TYPE_LONG
181
 
    DRIZZLE_TYPE_VARCHAR,
 
215
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
216
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
182
217
  //DRIZZLE_TYPE_DOUBLE
183
218
    DRIZZLE_TYPE_VARCHAR,
184
219
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
185
220
    DRIZZLE_TYPE_TIMESTAMP,   DRIZZLE_TYPE_TIMESTAMP,
186
221
  //DRIZZLE_TYPE_LONGLONG
187
222
    DRIZZLE_TYPE_VARCHAR,
188
 
  //DRIZZLE_TYPE_TIME
189
 
    DRIZZLE_TYPE_DATETIME,
 
223
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
224
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_DATETIME,
190
225
  //DRIZZLE_TYPE_DATETIME
191
226
    DRIZZLE_TYPE_DATETIME,
192
227
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
193
228
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
194
229
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
195
230
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
231
  //DRIZZLE_TYPE_SET
 
232
    DRIZZLE_TYPE_VARCHAR,
196
233
  //DRIZZLE_TYPE_BLOB
197
234
    DRIZZLE_TYPE_BLOB,
198
235
  },
200
237
  {
201
238
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
202
239
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_LONGLONG,
203
 
  //DRIZZLE_TYPE_LONG
204
 
    DRIZZLE_TYPE_LONGLONG,
 
240
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
241
    DRIZZLE_TYPE_LONGLONG,    DRIZZLE_TYPE_LONGLONG,
205
242
  //DRIZZLE_TYPE_DOUBLE
206
243
    DRIZZLE_TYPE_DOUBLE,
207
244
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
208
245
    DRIZZLE_TYPE_LONGLONG,    DRIZZLE_TYPE_VARCHAR,
209
246
  //DRIZZLE_TYPE_LONGLONG
210
247
    DRIZZLE_TYPE_LONGLONG,
211
 
  //DRIZZLE_TYPE_TIME
212
 
    DRIZZLE_TYPE_VARCHAR,
 
248
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
249
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
213
250
  //DRIZZLE_TYPE_DATETIME
214
251
    DRIZZLE_TYPE_VARCHAR,
215
252
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
216
253
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
217
254
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
218
255
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
256
  //DRIZZLE_TYPE_SET
 
257
    DRIZZLE_TYPE_VARCHAR,
 
258
  //DRIZZLE_TYPE_BLOB
 
259
    DRIZZLE_TYPE_BLOB,
 
260
  },
 
261
  /* DRIZZLE_TYPE_DATE -> */
 
262
  {
 
263
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
264
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
265
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
266
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
267
  //DRIZZLE_TYPE_DOUBLE
 
268
    DRIZZLE_TYPE_VARCHAR,
 
269
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
270
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
 
271
  //DRIZZLE_TYPE_LONGLONG
 
272
    DRIZZLE_TYPE_VARCHAR,
 
273
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
274
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
 
275
  //DRIZZLE_TYPE_DATETIME
 
276
    DRIZZLE_TYPE_DATETIME,
 
277
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
278
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
 
279
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
280
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
281
  //DRIZZLE_TYPE_SET
 
282
    DRIZZLE_TYPE_VARCHAR,
219
283
  //DRIZZLE_TYPE_BLOB
220
284
    DRIZZLE_TYPE_BLOB,
221
285
  },
223
287
  {
224
288
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
225
289
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
226
 
  //DRIZZLE_TYPE_LONG
227
 
    DRIZZLE_TYPE_VARCHAR,
 
290
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
291
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
228
292
  //DRIZZLE_TYPE_DOUBLE
229
293
    DRIZZLE_TYPE_VARCHAR,
230
294
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
231
295
    DRIZZLE_TYPE_TIME,        DRIZZLE_TYPE_DATETIME,
232
296
  //DRIZZLE_TYPE_LONGLONG
233
297
    DRIZZLE_TYPE_VARCHAR,
234
 
  //DRIZZLE_TYPE_TIME
235
 
    DRIZZLE_TYPE_TIME,
 
298
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
299
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_TIME,
236
300
  //DRIZZLE_TYPE_DATETIME
237
301
    DRIZZLE_TYPE_DATETIME,
238
302
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
239
303
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
240
304
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
241
305
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
306
  //DRIZZLE_TYPE_SET
 
307
    DRIZZLE_TYPE_VARCHAR,
242
308
  //DRIZZLE_TYPE_BLOB
243
309
    DRIZZLE_TYPE_BLOB,
244
310
  },
246
312
  {
247
313
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
248
314
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
249
 
  //DRIZZLE_TYPE_LONG
250
 
    DRIZZLE_TYPE_VARCHAR,
 
315
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
316
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
251
317
  //DRIZZLE_TYPE_DOUBLE
252
318
    DRIZZLE_TYPE_VARCHAR,
253
319
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
254
320
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_DATETIME,
255
321
  //DRIZZLE_TYPE_LONGLONG
256
322
    DRIZZLE_TYPE_VARCHAR,
257
 
  //DRIZZLE_TYPE_TIME
258
 
    DRIZZLE_TYPE_DATETIME,
 
323
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
324
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_DATETIME,
259
325
  //DRIZZLE_TYPE_DATETIME
260
326
    DRIZZLE_TYPE_DATETIME,
261
327
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
262
328
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
263
329
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
264
330
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
331
  //DRIZZLE_TYPE_SET
 
332
    DRIZZLE_TYPE_VARCHAR,
265
333
  //DRIZZLE_TYPE_BLOB
266
334
    DRIZZLE_TYPE_BLOB,
267
335
  },
269
337
  {
270
338
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
271
339
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
272
 
  //DRIZZLE_TYPE_LONG
273
 
    DRIZZLE_TYPE_VARCHAR,
 
340
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
341
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
274
342
  //DRIZZLE_TYPE_DOUBLE
275
343
    DRIZZLE_TYPE_VARCHAR,
276
344
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
277
345
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
278
346
  //DRIZZLE_TYPE_LONGLONG
279
347
    DRIZZLE_TYPE_VARCHAR,
280
 
  //DRIZZLE_TYPE_TIME
281
 
    DRIZZLE_TYPE_DATETIME,
 
348
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
349
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
282
350
  //DRIZZLE_TYPE_DATETIME
283
351
    DRIZZLE_TYPE_DATETIME,
284
352
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
285
353
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
286
354
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
287
355
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
356
  //DRIZZLE_TYPE_SET
 
357
    DRIZZLE_TYPE_VARCHAR,
288
358
  //DRIZZLE_TYPE_BLOB
289
359
    DRIZZLE_TYPE_BLOB,
290
360
  },
292
362
  {
293
363
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
294
364
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
295
 
  //DRIZZLE_TYPE_LONG
296
 
    DRIZZLE_TYPE_VARCHAR,
 
365
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
366
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
297
367
  //DRIZZLE_TYPE_DOUBLE
298
368
    DRIZZLE_TYPE_VARCHAR,
299
369
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
300
370
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
301
371
  //DRIZZLE_TYPE_LONGLONG
302
372
    DRIZZLE_TYPE_VARCHAR,
303
 
  //DRIZZLE_TYPE_TIME
304
 
    DRIZZLE_TYPE_VARCHAR,
 
373
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
374
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
305
375
  //DRIZZLE_TYPE_DATETIME
306
376
    DRIZZLE_TYPE_VARCHAR,
307
377
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
308
378
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
309
379
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
310
380
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
381
  //DRIZZLE_TYPE_SET
 
382
    DRIZZLE_TYPE_VARCHAR,
311
383
  //DRIZZLE_TYPE_BLOB
312
384
    DRIZZLE_TYPE_BLOB,
313
385
  },
315
387
  {
316
388
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
317
389
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
318
 
  //DRIZZLE_TYPE_LONG
319
 
    DRIZZLE_TYPE_NEWDECIMAL,
 
390
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
391
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
320
392
  //DRIZZLE_TYPE_DOUBLE
321
393
    DRIZZLE_TYPE_DOUBLE,
322
394
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
323
395
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
324
396
  //DRIZZLE_TYPE_LONGLONG
325
397
    DRIZZLE_TYPE_NEWDECIMAL,
326
 
  //DRIZZLE_TYPE_TIME
327
 
    DRIZZLE_TYPE_VARCHAR,
 
398
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
399
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
328
400
  //DRIZZLE_TYPE_DATETIME
329
401
    DRIZZLE_TYPE_VARCHAR,
330
402
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
331
403
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
332
404
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
333
405
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
 
406
  //DRIZZLE_TYPE_SET
 
407
    DRIZZLE_TYPE_VARCHAR,
334
408
  //DRIZZLE_TYPE_BLOB
335
409
    DRIZZLE_TYPE_BLOB,
336
410
  },
338
412
  {
339
413
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
340
414
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
341
 
  //DRIZZLE_TYPE_LONG
342
 
    DRIZZLE_TYPE_VARCHAR,
 
415
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
416
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
343
417
  //DRIZZLE_TYPE_DOUBLE
344
418
    DRIZZLE_TYPE_VARCHAR,
345
419
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
346
420
    DRIZZLE_TYPE_ENUM,        DRIZZLE_TYPE_VARCHAR,
347
421
  //DRIZZLE_TYPE_LONGLONG
348
422
    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,
 
423
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
424
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
425
  //DRIZZLE_TYPE_DATETIME
 
426
    DRIZZLE_TYPE_VARCHAR,
 
427
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
428
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
429
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
430
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
431
  //DRIZZLE_TYPE_SET
 
432
    DRIZZLE_TYPE_VARCHAR,
 
433
  //DRIZZLE_TYPE_BLOB
 
434
    DRIZZLE_TYPE_BLOB,
 
435
  },
 
436
  /* DRIZZLE_TYPE_SET -> */
 
437
  {
 
438
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
 
439
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
440
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
441
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
442
  //DRIZZLE_TYPE_DOUBLE
 
443
    DRIZZLE_TYPE_VARCHAR,
 
444
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
 
445
    DRIZZLE_TYPE_SET,         DRIZZLE_TYPE_VARCHAR,
 
446
  //DRIZZLE_TYPE_LONGLONG
 
447
    DRIZZLE_TYPE_VARCHAR,
 
448
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
449
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
450
  //DRIZZLE_TYPE_DATETIME
 
451
    DRIZZLE_TYPE_VARCHAR,
 
452
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
 
453
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
454
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
 
455
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
 
456
  //DRIZZLE_TYPE_SET
 
457
    DRIZZLE_TYPE_VARCHAR,
357
458
  //DRIZZLE_TYPE_BLOB
358
459
    DRIZZLE_TYPE_BLOB,
359
460
  },
361
462
  {
362
463
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
363
464
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
364
 
  //DRIZZLE_TYPE_LONG
365
 
    DRIZZLE_TYPE_BLOB,
 
465
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
466
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
366
467
  //DRIZZLE_TYPE_DOUBLE
367
468
    DRIZZLE_TYPE_BLOB,
368
469
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
369
470
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
370
471
  //DRIZZLE_TYPE_LONGLONG
371
472
    DRIZZLE_TYPE_BLOB,
372
 
  //DRIZZLE_TYPE_TIME
373
 
    DRIZZLE_TYPE_BLOB,
 
473
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
474
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
374
475
  //DRIZZLE_TYPE_DATETIME
375
476
    DRIZZLE_TYPE_BLOB,
376
477
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
377
478
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
378
479
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
379
480
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
 
481
  //DRIZZLE_TYPE_SET
 
482
    DRIZZLE_TYPE_BLOB,
380
483
  //DRIZZLE_TYPE_BLOB
381
484
    DRIZZLE_TYPE_BLOB,
382
485
  },
406
509
{
407
510
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
408
511
  DECIMAL_RESULT,           INT_RESULT,
409
 
  //DRIZZLE_TYPE_LONG
410
 
  INT_RESULT,
 
512
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
 
513
  INT_RESULT,               INT_RESULT,
411
514
  //DRIZZLE_TYPE_DOUBLE
412
515
  REAL_RESULT,
413
516
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
414
517
  STRING_RESULT,            STRING_RESULT,
415
518
  //DRIZZLE_TYPE_LONGLONG
416
519
  INT_RESULT,
417
 
  //DRIZZLE_TYPE_TIME
418
 
  STRING_RESULT,
 
520
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
 
521
  STRING_RESULT,            STRING_RESULT,
419
522
  //DRIZZLE_TYPE_DATETIME
420
523
  STRING_RESULT,
421
524
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
422
525
  STRING_RESULT,            STRING_RESULT,
423
526
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
424
527
  DECIMAL_RESULT,           STRING_RESULT,
 
528
  //DRIZZLE_TYPE_SET
 
529
  STRING_RESULT,
425
530
  //DRIZZLE_TYPE_BLOB
426
531
  STRING_RESULT,
427
532
};
503
608
/**
504
609
  Numeric fields base class constructor.
505
610
*/
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,
 
611
Field_num::Field_num(uchar *ptr_arg,uint32_t len_arg, uchar *null_ptr_arg,
 
612
                     uchar null_bit_arg, utype unireg_check_arg,
508
613
                     const char *field_name_arg,
509
614
                     uint8_t dec_arg, bool zero_arg, bool unsigned_arg)
510
615
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
587
692
    1   error
588
693
*/
589
694
 
590
 
bool Field_num::get_int(const CHARSET_INFO * const cs, const char *from, uint32_t len,
 
695
bool Field_num::get_int(const CHARSET_INFO * const cs, const char *from, uint len,
591
696
                        int64_t *rnd, uint64_t unsigned_max, 
592
697
                        int64_t signed_min, int64_t signed_max)
593
698
{
721
826
String *Field::val_int_as_str(String *val_buffer, bool unsigned_val)
722
827
{
723
828
  const CHARSET_INFO * const cs= &my_charset_bin;
724
 
  uint32_t length;
 
829
  uint length;
725
830
  int64_t value= val_int();
726
831
 
727
832
  if (val_buffer->alloc(MY_INT64_NUM_DECIMAL_DIGITS))
728
833
    return 0;
729
 
  length= (uint32_t) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
 
834
  length= (uint) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
730
835
                                                MY_INT64_NUM_DECIMAL_DIGITS,
731
836
                                                unsigned_val ? 10 : -10,
732
837
                                                value);
736
841
 
737
842
 
738
843
/// 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,
 
844
Field::Field(uchar *ptr_arg,uint32_t length_arg,uchar *null_ptr_arg,
 
845
             uchar null_bit_arg,
741
846
             utype unireg_check_arg, const char *field_name_arg)
742
847
  :ptr(ptr_arg), null_ptr(null_ptr_arg),
743
848
   table(0), orig_table(0), table_name(0),
762
867
  }
763
868
  else
764
869
  {
765
 
    uint32_t len= pack_length();
 
870
    uint len= pack_length();
766
871
    const CHARSET_INFO * const cs= charset();
767
872
    cs->coll->hash_sort(cs, ptr, len, nr, nr2);
768
873
  }
783
888
  memcpy(ptr,ptr+row_offset,pack_length());
784
889
  if (null_ptr)
785
890
  {
786
 
    *null_ptr= (unsigned char) ((null_ptr[0] & (unsigned char) ~(uint32_t) null_bit) | (null_ptr[row_offset] & (unsigned char) null_bit));
 
891
    *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) | (null_ptr[row_offset] & (uchar) null_bit));
787
892
  }
788
893
}
789
894
 
810
915
   @retval 0 if this field's size is < the source field's size
811
916
   @retval 1 if this field's size is >= the source field's size
812
917
*/
813
 
int Field::compatible_field_size(uint32_t field_metadata)
 
918
int Field::compatible_field_size(uint field_metadata)
814
919
{
815
 
  uint32_t const source_size= pack_length_from_metadata(field_metadata);
816
 
  uint32_t const destination_size= row_pack_length();
 
920
  uint const source_size= pack_length_from_metadata(field_metadata);
 
921
  uint const destination_size= row_pack_length();
817
922
  return (source_size <= destination_size);
818
923
}
819
924
 
820
925
 
821
 
int Field::store(const char *to, uint32_t length, const CHARSET_INFO * const cs,
 
926
int Field::store(const char *to, uint length, const CHARSET_INFO * const cs,
822
927
                 enum_check_fields check_level)
823
928
{
824
929
  int res;
867
972
   the value of this flag is a moot point since the native format is
868
973
   little-endian.
869
974
*/
870
 
unsigned char *
871
 
Field::pack(unsigned char *to, const unsigned char *from, uint32_t max_length,
 
975
uchar *
 
976
Field::pack(uchar *to, const uchar *from, uint max_length,
872
977
            bool low_byte_first __attribute__((unused)))
873
978
{
874
979
  uint32_t length= pack_length();
907
1012
 
908
1013
   @return  New pointer into memory based on from + length of the data
909
1014
*/
910
 
const unsigned char *
911
 
Field::unpack(unsigned char* to, const unsigned char *from, uint32_t param_data,
 
1015
const uchar *
 
1016
Field::unpack(uchar* to, const uchar *from, uint param_data,
912
1017
              bool low_byte_first __attribute__((unused)))
913
1018
{
914
 
  uint32_t length=pack_length();
 
1019
  uint length=pack_length();
915
1020
  int from_type= 0;
916
1021
  /*
917
1022
    If from length is > 255, it has encoded data in the upper bits. Need
931
1036
    return from+length;
932
1037
  }
933
1038
 
934
 
  uint32_t len= (param_data && (param_data < length)) ?
 
1039
  uint len= (param_data && (param_data < length)) ?
935
1040
            param_data : length;
936
1041
 
937
1042
  memcpy(to, from, param_data > length ? length : len);
1069
1174
}
1070
1175
 
1071
1176
 
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,
 
1177
Field_str::Field_str(uchar *ptr_arg,uint32_t len_arg, uchar *null_ptr_arg,
 
1178
                     uchar null_bit_arg, utype unireg_check_arg,
1074
1179
                     const char *field_name_arg, const CHARSET_INFO * const charset_arg)
1075
1180
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1076
1181
         unireg_check_arg, field_name_arg)
1126
1231
}
1127
1232
 
1128
1233
 
1129
 
uint32_t Field::fill_cache_field(CACHE_FIELD *copy)
 
1234
uint Field::fill_cache_field(CACHE_FIELD *copy)
1130
1235
{
1131
 
  uint32_t store_length;
 
1236
  uint store_length;
1132
1237
  copy->str=ptr;
1133
1238
  copy->length=pack_length();
1134
1239
  copy->blob_field=0;
1148
1253
}
1149
1254
 
1150
1255
 
1151
 
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
 
1256
bool Field::get_date(DRIZZLE_TIME *ltime,uint fuzzydate)
1152
1257
{
1153
1258
  char buff[40];
1154
1259
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1177
1282
*/
1178
1283
 
1179
1284
int Field::store_time(DRIZZLE_TIME *ltime,
1180
 
                      enum enum_drizzle_timestamp_type type_arg __attribute__((unused)))
 
1285
                      timestamp_type type_arg __attribute__((unused)))
1181
1286
{
1182
1287
  char buff[MAX_DATE_STRING_REP_LENGTH];
1183
 
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
 
1288
  uint length= (uint) my_TIME_to_str(ltime, buff);
1184
1289
  return store(buff, length, &my_charset_bin);
1185
1290
}
1186
1291
 
1187
1292
 
1188
 
bool Field::optimize_range(uint32_t idx, uint32_t part)
 
1293
bool Field::optimize_range(uint idx, uint part)
1189
1294
{
1190
1295
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
1191
1296
}
1192
1297
 
1193
1298
 
1194
 
Field *Field::new_field(MEM_ROOT *root, Table *new_table,
 
1299
Field *Field::new_field(MEM_ROOT *root, struct st_table *new_table,
1195
1300
                        bool keep_type __attribute__((unused)))
1196
1301
{
1197
1302
  Field *tmp;
1211
1316
}
1212
1317
 
1213
1318
 
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)
 
1319
Field *Field::new_key_field(MEM_ROOT *root, struct st_table *new_table,
 
1320
                            uchar *new_ptr, uchar *new_null_ptr,
 
1321
                            uint new_null_bit)
1217
1322
{
1218
1323
  Field *tmp;
1219
1324
  if ((tmp= new_field(root, new_table, table == new_table)))
1226
1331
}
1227
1332
 
1228
1333
 
1229
 
/* This is used to generate a field in Table from TABLE_SHARE */
 
1334
/* This is used to generate a field in TABLE from TABLE_SHARE */
1230
1335
 
1231
 
Field *Field::clone(MEM_ROOT *root, Table *new_table)
 
1336
Field *Field::clone(MEM_ROOT *root, struct st_table *new_table)
1232
1337
{
1233
1338
  Field *tmp;
1234
1339
  if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
1245
1350
** tiny int
1246
1351
****************************************************************************/
1247
1352
 
1248
 
int Field_tiny::store(const char *from,uint32_t len, const CHARSET_INFO * const cs)
 
1353
int Field_tiny::store(const char *from,uint len, const CHARSET_INFO * const cs)
1249
1354
{
1250
1355
  int error;
1251
1356
  int64_t rnd;
1362
1467
                            String *val_ptr __attribute__((unused)))
1363
1468
{
1364
1469
  const CHARSET_INFO * const cs= &my_charset_bin;
1365
 
  uint32_t length;
1366
 
  uint32_t mlength=cmax(field_length+1,5*cs->mbmaxlen);
 
1470
  uint length;
 
1471
  uint mlength=max(field_length+1,5*cs->mbmaxlen);
1367
1472
  val_buffer->alloc(mlength);
1368
1473
  char *to=(char*) val_buffer->ptr();
1369
1474
 
1370
1475
  if (unsigned_flag)
1371
 
    length= (uint32_t) cs->cset->long10_to_str(cs,to,mlength, 10,
 
1476
    length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
1372
1477
                                           (long) *ptr);
1373
1478
  else
1374
 
    length= (uint32_t) cs->cset->long10_to_str(cs,to,mlength,-10,
 
1479
    length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
1375
1480
                                           (long) *((signed char*) ptr));
1376
1481
  
1377
1482
  val_buffer->length(length);
1384
1489
  return protocol->store_tiny((int64_t) (int8_t) ptr[0]);
1385
1490
}
1386
1491
 
1387
 
int Field_tiny::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
 
1492
int Field_tiny::cmp(const uchar *a_ptr, const uchar *b_ptr)
1388
1493
{
1389
1494
  signed char a,b;
1390
1495
  a=(signed char) a_ptr[0]; b= (signed char) b_ptr[0];
1391
1496
  if (unsigned_flag)
1392
 
    return ((unsigned char) a < (unsigned char) b) ? -1 : ((unsigned char) a > (unsigned char) b) ? 1 : 0;
 
1497
    return ((uchar) a < (uchar) b) ? -1 : ((uchar) a > (uchar) b) ? 1 : 0;
1393
1498
  return (a < b) ? -1 : (a > b) ? 1 : 0;
1394
1499
}
1395
1500
 
1396
 
void Field_tiny::sort_string(unsigned char *to,uint32_t length __attribute__((unused)))
 
1501
void Field_tiny::sort_string(uchar *to,uint length __attribute__((unused)))
1397
1502
{
1398
1503
  if (unsigned_flag)
1399
1504
    *to= *ptr;
1400
1505
  else
1401
 
    to[0] = (char) (ptr[0] ^ (unsigned char) 128);      /* Revers signbit */
 
1506
    to[0] = (char) (ptr[0] ^ (uchar) 128);      /* Revers signbit */
1402
1507
}
1403
1508
 
1404
1509
void Field_tiny::sql_type(String &res) const
1546
1651
int Field_str::store(double nr)
1547
1652
{
1548
1653
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
1549
 
  uint32_t local_char_length= field_length / charset()->mbmaxlen;
 
1654
  uint local_char_length= field_length / charset()->mbmaxlen;
1550
1655
  size_t length;
1551
1656
  bool error;
1552
1657
 
1562
1667
}
1563
1668
 
1564
1669
 
1565
 
uint32_t Field::is_equal(Create_field *new_field)
 
1670
uint Field::is_equal(Create_field *new_field)
1566
1671
{
1567
1672
  return (new_field->sql_type == real_type());
1568
1673
}
1579
1684
}
1580
1685
 
1581
1686
 
1582
 
uint32_t Field_str::is_equal(Create_field *new_field)
 
1687
uint Field_str::is_equal(Create_field *new_field)
1583
1688
{
1584
1689
  if (compare_str_field_flags(new_field, flags))
1585
1690
    return 0;
1604
1709
}
1605
1710
 
1606
1711
 
 
1712
/****************************************************************************
 
1713
** enum type.
 
1714
** This is a string which only can have a selection of different values.
 
1715
** If one uses this string in a number context one gets the type number.
 
1716
****************************************************************************/
 
1717
 
 
1718
enum ha_base_keytype Field_enum::key_type() const
 
1719
{
 
1720
  switch (packlength) {
 
1721
  default: return HA_KEYTYPE_BINARY;
 
1722
  case 2: return HA_KEYTYPE_USHORT_INT;
 
1723
  case 3: return HA_KEYTYPE_UINT24;
 
1724
  case 4: return HA_KEYTYPE_ULONG_INT;
 
1725
  case 8: return HA_KEYTYPE_ULONGLONG;
 
1726
  }
 
1727
}
 
1728
 
 
1729
void Field_enum::store_type(uint64_t value)
 
1730
{
 
1731
  switch (packlength) {
 
1732
  case 1: ptr[0]= (uchar) value;  break;
 
1733
  case 2:
 
1734
#ifdef WORDS_BIGENDIAN
 
1735
  if (table->s->db_low_byte_first)
 
1736
  {
 
1737
    int2store(ptr,(unsigned short) value);
 
1738
  }
 
1739
  else
 
1740
#endif
 
1741
    shortstore(ptr,(unsigned short) value);
 
1742
  break;
 
1743
  case 3: int3store(ptr,(long) value); break;
 
1744
  case 4:
 
1745
#ifdef WORDS_BIGENDIAN
 
1746
  if (table->s->db_low_byte_first)
 
1747
  {
 
1748
    int4store(ptr,value);
 
1749
  }
 
1750
  else
 
1751
#endif
 
1752
    longstore(ptr,(long) value);
 
1753
  break;
 
1754
  case 8:
 
1755
#ifdef WORDS_BIGENDIAN
 
1756
  if (table->s->db_low_byte_first)
 
1757
  {
 
1758
    int8store(ptr,value);
 
1759
  }
 
1760
  else
 
1761
#endif
 
1762
    int64_tstore(ptr,value); break;
 
1763
  }
 
1764
}
 
1765
 
 
1766
 
 
1767
/**
 
1768
  @note
 
1769
    Storing a empty string in a enum field gives a warning
 
1770
    (if there isn't a empty value in the enum)
 
1771
*/
 
1772
 
 
1773
int Field_enum::store(const char *from, uint length, const CHARSET_INFO * const cs)
 
1774
{
 
1775
  int err= 0;
 
1776
  uint32_t not_used;
 
1777
  char buff[STRING_BUFFER_USUAL_SIZE];
 
1778
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
 
1779
 
 
1780
  /* Convert character set if necessary */
 
1781
  if (String::needs_conversion(length, cs, field_charset, &not_used))
 
1782
  { 
 
1783
    uint dummy_errors;
 
1784
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
 
1785
    from= tmpstr.ptr();
 
1786
    length=  tmpstr.length();
 
1787
  }
 
1788
 
 
1789
  /* Remove end space */
 
1790
  length= field_charset->cset->lengthsp(field_charset, from, length);
 
1791
  uint tmp=find_type2(typelib, from, length, field_charset);
 
1792
  if (!tmp)
 
1793
  {
 
1794
    if (length < 6) // Can't be more than 99999 enums
 
1795
    {
 
1796
      /* This is for reading numbers with LOAD DATA INFILE */
 
1797
      char *end;
 
1798
      tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
 
1799
      if (err || end != from+length || tmp > typelib->count)
 
1800
      {
 
1801
        tmp=0;
 
1802
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
 
1803
      }
 
1804
      if (!table->in_use->count_cuted_fields)
 
1805
        err= 0;
 
1806
    }
 
1807
    else
 
1808
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
 
1809
  }
 
1810
  store_type((uint64_t) tmp);
 
1811
  return err;
 
1812
}
 
1813
 
 
1814
 
 
1815
int Field_enum::store(double nr)
 
1816
{
 
1817
  return Field_enum::store((int64_t) nr, false);
 
1818
}
 
1819
 
 
1820
 
 
1821
int Field_enum::store(int64_t nr,
 
1822
                      bool unsigned_val __attribute__((unused)))
 
1823
{
 
1824
  int error= 0;
 
1825
  if ((uint64_t) nr > typelib->count || nr == 0)
 
1826
  {
 
1827
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
 
1828
    if (nr != 0 || table->in_use->count_cuted_fields)
 
1829
    {
 
1830
      nr= 0;
 
1831
      error= 1;
 
1832
    }
 
1833
  }
 
1834
  store_type((uint64_t) (uint) nr);
 
1835
  return error;
 
1836
}
 
1837
 
 
1838
 
 
1839
double Field_enum::val_real(void)
 
1840
{
 
1841
  return (double) Field_enum::val_int();
 
1842
}
 
1843
 
 
1844
 
 
1845
int64_t Field_enum::val_int(void)
 
1846
{
 
1847
  switch (packlength) {
 
1848
  case 1:
 
1849
    return (int64_t) ptr[0];
 
1850
  case 2:
 
1851
  {
 
1852
    uint16_t tmp;
 
1853
#ifdef WORDS_BIGENDIAN
 
1854
    if (table->s->db_low_byte_first)
 
1855
      tmp=sint2korr(ptr);
 
1856
    else
 
1857
#endif
 
1858
      shortget(tmp,ptr);
 
1859
    return (int64_t) tmp;
 
1860
  }
 
1861
  case 3:
 
1862
    return (int64_t) uint3korr(ptr);
 
1863
  case 4:
 
1864
  {
 
1865
    uint32_t tmp;
 
1866
#ifdef WORDS_BIGENDIAN
 
1867
    if (table->s->db_low_byte_first)
 
1868
      tmp=uint4korr(ptr);
 
1869
    else
 
1870
#endif
 
1871
      longget(tmp,ptr);
 
1872
    return (int64_t) tmp;
 
1873
  }
 
1874
  case 8:
 
1875
  {
 
1876
    int64_t tmp;
 
1877
#ifdef WORDS_BIGENDIAN
 
1878
    if (table->s->db_low_byte_first)
 
1879
      tmp=sint8korr(ptr);
 
1880
    else
 
1881
#endif
 
1882
      int64_tget(tmp,ptr);
 
1883
    return tmp;
 
1884
  }
 
1885
  }
 
1886
  return 0;                                     // impossible
 
1887
}
 
1888
 
 
1889
 
 
1890
/**
 
1891
   Save the field metadata for enum fields.
 
1892
 
 
1893
   Saves the real type in the first byte and the pack length in the 
 
1894
   second byte of the field metadata array at index of *metadata_ptr and
 
1895
   *(metadata_ptr + 1).
 
1896
 
 
1897
   @param   metadata_ptr   First byte of field metadata
 
1898
 
 
1899
   @returns number of bytes written to metadata_ptr
 
1900
*/
 
1901
int Field_enum::do_save_field_metadata(uchar *metadata_ptr)
 
1902
{
 
1903
  *metadata_ptr= real_type();
 
1904
  *(metadata_ptr + 1)= pack_length();
 
1905
  return 2;
 
1906
}
 
1907
 
 
1908
 
 
1909
String *Field_enum::val_str(String *val_buffer __attribute__((unused)),
 
1910
                            String *val_ptr)
 
1911
{
 
1912
  uint tmp=(uint) Field_enum::val_int();
 
1913
  if (!tmp || tmp > typelib->count)
 
1914
    val_ptr->set("", 0, field_charset);
 
1915
  else
 
1916
    val_ptr->set((const char*) typelib->type_names[tmp-1],
 
1917
                 typelib->type_lengths[tmp-1],
 
1918
                 field_charset);
 
1919
  return val_ptr;
 
1920
}
 
1921
 
 
1922
int Field_enum::cmp(const uchar *a_ptr, const uchar *b_ptr)
 
1923
{
 
1924
  uchar *old= ptr;
 
1925
  ptr= (uchar*) a_ptr;
 
1926
  uint64_t a=Field_enum::val_int();
 
1927
  ptr= (uchar*) b_ptr;
 
1928
  uint64_t b=Field_enum::val_int();
 
1929
  ptr= old;
 
1930
  return (a < b) ? -1 : (a > b) ? 1 : 0;
 
1931
}
 
1932
 
 
1933
void Field_enum::sort_string(uchar *to,uint length __attribute__((unused)))
 
1934
{
 
1935
  uint64_t value=Field_enum::val_int();
 
1936
  to+=packlength-1;
 
1937
  for (uint i=0 ; i < packlength ; i++)
 
1938
  {
 
1939
    *to-- = (uchar) (value & 255);
 
1940
    value>>=8;
 
1941
  }
 
1942
}
 
1943
 
 
1944
 
 
1945
void Field_enum::sql_type(String &res) const
 
1946
{
 
1947
  char buffer[255];
 
1948
  String enum_item(buffer, sizeof(buffer), res.charset());
 
1949
 
 
1950
  res.length(0);
 
1951
  res.append(STRING_WITH_LEN("enum("));
 
1952
 
 
1953
  bool flag=0;
 
1954
  uint *len= typelib->type_lengths;
 
1955
  for (const char **pos= typelib->type_names; *pos; pos++, len++)
 
1956
  {
 
1957
    uint dummy_errors;
 
1958
    if (flag)
 
1959
      res.append(',');
 
1960
    /* convert to res.charset() == utf8, then quote */
 
1961
    enum_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
 
1962
    append_unescaped(&res, enum_item.ptr(), enum_item.length());
 
1963
    flag= 1;
 
1964
  }
 
1965
  res.append(')');
 
1966
}
 
1967
 
 
1968
 
 
1969
Field *Field_enum::new_field(MEM_ROOT *root, struct st_table *new_table,
 
1970
                             bool keep_type)
 
1971
{
 
1972
  Field_enum *res= (Field_enum*) Field::new_field(root, new_table, keep_type);
 
1973
  if (res)
 
1974
    res->typelib= copy_typelib(root, typelib);
 
1975
  return res;
 
1976
}
 
1977
 
 
1978
 
1607
1979
/**
1608
1980
  @retval
1609
1981
    1  if the fields are equally defined
1631
2003
 
1632
2004
  if (typelib->count < from_lib->count)
1633
2005
    return 0;
1634
 
  for (uint32_t i=0 ; i < from_lib->count ; i++)
 
2006
  for (uint i=0 ; i < from_lib->count ; i++)
1635
2007
    if (my_strnncoll(field_charset,
1636
 
                     (const unsigned char*)typelib->type_names[i],
 
2008
                     (const uchar*)typelib->type_names[i],
1637
2009
                     strlen(typelib->type_names[i]),
1638
 
                     (const unsigned char*)from_lib->type_names[i],
 
2010
                     (const uchar*)from_lib->type_names[i],
1639
2011
                     strlen(from_lib->type_names[i])))
1640
2012
      return 0;
1641
2013
  return 1;
1658
2030
}
1659
2031
 
1660
2032
 
1661
 
uint32_t Field_num::is_equal(Create_field *new_field)
 
2033
uint Field_num::is_equal(Create_field *new_field)
1662
2034
{
1663
2035
  return ((new_field->sql_type == real_type()) &&
1664
 
          ((new_field->flags & UNSIGNED_FLAG) == (uint32_t) (flags &
 
2036
          ((new_field->flags & UNSIGNED_FLAG) == (uint) (flags &
1665
2037
                                                         UNSIGNED_FLAG)) &&
1666
2038
          ((new_field->flags & AUTO_INCREMENT_FLAG) ==
1667
 
           (uint32_t) (flags & AUTO_INCREMENT_FLAG)) &&
 
2039
           (uint) (flags & AUTO_INCREMENT_FLAG)) &&
1668
2040
          (new_field->length <= max_display_length()));
1669
2041
}
1670
2042
 
1687
2059
    pack_length= calc_pack_length(sql_type, length);
1688
2060
    break;
1689
2061
  case DRIZZLE_TYPE_ENUM:
 
2062
  case DRIZZLE_TYPE_SET:
1690
2063
    /* Pack_length already calculated in sql_parse.cc */
1691
2064
    length*= charset->mbmaxlen;
1692
2065
    key_length= pack_length;
1748
2121
    true  on error
1749
2122
*/
1750
2123
 
1751
 
bool Create_field::init(THD *thd __attribute__((unused)), char *fld_name, enum_field_types fld_type,
 
2124
bool Create_field::init(THD *thd, char *fld_name, enum_field_types fld_type,
1752
2125
                        char *fld_length, char *fld_decimals,
1753
 
                        uint32_t fld_type_modifier, Item *fld_default_value,
 
2126
                        uint fld_type_modifier, Item *fld_default_value,
1754
2127
                        Item *fld_on_update_value, LEX_STRING *fld_comment,
1755
2128
                        char *fld_change, List<String> *fld_interval_list,
1756
2129
                        const CHARSET_INFO * const fld_charset,
1757
 
                        uint32_t fld_geom_type __attribute__((unused)),
 
2130
                        uint fld_geom_type __attribute__((unused)),
1758
2131
                        enum column_format_type column_format)
1759
2132
{
1760
 
  uint32_t sign_len, allowed_type_modifier= 0;
 
2133
  uint sign_len, allowed_type_modifier= 0;
1761
2134
  uint32_t max_field_charlength= MAX_FIELD_CHARLENGTH;
1762
2135
 
1763
2136
  field= 0;
1764
2137
  field_name= fld_name;
1765
2138
  def= fld_default_value;
1766
2139
  flags= fld_type_modifier;
1767
 
  flags|= (((uint32_t)column_format & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
 
2140
  flags|= (((uint)column_format & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
1768
2141
  unireg_check= (fld_type_modifier & AUTO_INCREMENT_FLAG ?
1769
2142
                 Field::NEXT_NUMBER : Field::NONE);
1770
 
  decimals= fld_decimals ? (uint32_t)atoi(fld_decimals) : 0;
 
2143
  decimals= fld_decimals ? (uint)atoi(fld_decimals) : 0;
1771
2144
  if (decimals >= NOT_FIXED_DEC)
1772
2145
  {
1773
2146
    my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
1792
2165
      (fld_type_modifier & NOT_NULL_FLAG) && fld_type != DRIZZLE_TYPE_TIMESTAMP)
1793
2166
    flags|= NO_DEFAULT_VALUE_FLAG;
1794
2167
 
1795
 
  if (fld_length && !(length= (uint32_t) atoi(fld_length)))
 
2168
  if (fld_length && !(length= (uint) atoi(fld_length)))
1796
2169
    fld_length= 0; /* purecov: inspected */
1797
2170
  sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1;
1798
2171
 
1802
2175
      length= MAX_TINYINT_WIDTH+sign_len;
1803
2176
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
1804
2177
    break;
 
2178
  case DRIZZLE_TYPE_SHORT:
 
2179
    if (!fld_length)
 
2180
      length= MAX_SMALLINT_WIDTH+sign_len;
 
2181
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
 
2182
    break;
1805
2183
  case DRIZZLE_TYPE_LONG:
1806
2184
    if (!fld_length)
1807
2185
      length= MAX_INT_WIDTH+sign_len;
1846
2224
      /* Allow empty as default value. */
1847
2225
      String str,*res;
1848
2226
      res= fld_default_value->val_str(&str);
 
2227
      /*
 
2228
        A default other than '' is always an error, and any non-NULL
 
2229
        specified default is an error in strict mode.
 
2230
      */
 
2231
      if (res->length() || (thd->variables.sql_mode &
 
2232
                            (MODE_STRICT_TRANS_TABLES |
 
2233
                             MODE_STRICT_ALL_TABLES)))
 
2234
      {
 
2235
        my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
 
2236
                 fld_name); /* purecov: inspected */
 
2237
        return(true);
 
2238
      }
 
2239
      else
 
2240
      {
 
2241
        /*
 
2242
          Otherwise a default of '' is just a warning.
 
2243
        */
 
2244
        push_warning_printf(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
2245
                            ER_BLOB_CANT_HAVE_DEFAULT,
 
2246
                            ER(ER_BLOB_CANT_HAVE_DEFAULT),
 
2247
                            fld_name);
 
2248
      }
 
2249
      def= 0;
1849
2250
    }
1850
2251
    flags|= BLOB_FLAG;
1851
2252
    break;
1876
2277
        and 19 as length of 4.1 compatible representation.
1877
2278
      */
1878
2279
      length= ((length+1)/2)*2; /* purecov: inspected */
1879
 
      length= cmin(length, (uint32_t)MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
 
2280
      length= min(length, (uint32_t)MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
1880
2281
    }
1881
2282
    flags|= UNSIGNED_FLAG;
1882
2283
    if (fld_default_value)
1917
2318
                                              Field::NONE));
1918
2319
    }
1919
2320
    break;
 
2321
  case DRIZZLE_TYPE_DATE:
 
2322
    /* Old date type. */
 
2323
    sql_type= DRIZZLE_TYPE_NEWDATE;
 
2324
    /* fall trough */
1920
2325
  case DRIZZLE_TYPE_NEWDATE:
1921
2326
    length= 10;
1922
2327
    break;
1926
2331
  case DRIZZLE_TYPE_DATETIME:
1927
2332
    length= MAX_DATETIME_WIDTH;
1928
2333
    break;
 
2334
  case DRIZZLE_TYPE_SET:
 
2335
    {
 
2336
      pack_length= get_set_pack_length(fld_interval_list->elements);
 
2337
 
 
2338
      List_iterator<String> it(*fld_interval_list);
 
2339
      String *tmp;
 
2340
      while ((tmp= it++))
 
2341
        interval_list.push_back(tmp);
 
2342
      /*
 
2343
        Set fake length to 1 to pass the below conditions.
 
2344
        Real length will be set in mysql_prepare_table()
 
2345
        when we know the character set of the column
 
2346
      */
 
2347
      length= 1;
 
2348
      break;
 
2349
    }
1929
2350
  case DRIZZLE_TYPE_ENUM:
1930
2351
    {
1931
2352
      /* Should be safe. */
1943
2364
  char_length= length;
1944
2365
 
1945
2366
  if (!(flags & BLOB_FLAG) &&
1946
 
      ((length > max_field_charlength &&
 
2367
      ((length > max_field_charlength && fld_type != DRIZZLE_TYPE_SET &&
1947
2368
        fld_type != DRIZZLE_TYPE_ENUM &&
1948
2369
        (fld_type != DRIZZLE_TYPE_VARCHAR || fld_default_value)) ||
1949
2370
       (!length && fld_type != DRIZZLE_TYPE_VARCHAR)))
1983
2404
  switch (type) {
1984
2405
  case DRIZZLE_TYPE_VARCHAR:     return (length + (length < 256 ? 1: 2));
1985
2406
  case DRIZZLE_TYPE_TINY        : return 1;
 
2407
  case DRIZZLE_TYPE_SHORT : return 2;
 
2408
  case DRIZZLE_TYPE_DATE:
1986
2409
  case DRIZZLE_TYPE_NEWDATE:
1987
2410
  case DRIZZLE_TYPE_TIME:   return 3;
1988
2411
  case DRIZZLE_TYPE_TIMESTAMP:
1992
2415
  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
1993
2416
  case DRIZZLE_TYPE_NULL        : return 0;
1994
2417
  case DRIZZLE_TYPE_BLOB:               return 4+portable_sizeof_char_ptr;
 
2418
  case DRIZZLE_TYPE_SET:
1995
2419
  case DRIZZLE_TYPE_ENUM:
1996
2420
  case DRIZZLE_TYPE_NEWDECIMAL:
1997
2421
    abort(); return 0;                          // This shouldn't happen
2001
2425
}
2002
2426
 
2003
2427
 
2004
 
uint32_t pack_length_to_packflag(uint32_t type)
 
2428
uint pack_length_to_packflag(uint type)
2005
2429
{
2006
2430
  switch (type) {
2007
 
    case 1: return f_settype((uint32_t) DRIZZLE_TYPE_TINY);
2008
 
    case 2: assert(1);
 
2431
    case 1: return f_settype((uint) DRIZZLE_TYPE_TINY);
 
2432
    case 2: return f_settype((uint) DRIZZLE_TYPE_SHORT);
2009
2433
    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);
 
2434
    case 4: return f_settype((uint) DRIZZLE_TYPE_LONG);
 
2435
    case 8: return f_settype((uint) DRIZZLE_TYPE_LONGLONG);
2012
2436
  }
2013
2437
  return 0;                                     // This shouldn't happen
2014
2438
}
2015
2439
 
2016
2440
 
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,
 
2441
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32_t field_length,
 
2442
                  uchar *null_pos, uchar null_bit,
 
2443
                  uint pack_flag,
2020
2444
                  enum_field_types field_type,
2021
2445
                  const CHARSET_INFO * field_charset,
2022
2446
                  Field::utype unireg_check,
2030
2454
  }
2031
2455
  else
2032
2456
  {
2033
 
    null_bit= ((unsigned char) 1) << null_bit;
 
2457
    null_bit= ((uchar) 1) << null_bit;
2034
2458
  }
2035
2459
 
2036
2460
  switch (field_type) {
 
2461
  case DRIZZLE_TYPE_DATE:
2037
2462
  case DRIZZLE_TYPE_NEWDATE:
2038
2463
  case DRIZZLE_TYPE_TIME:
2039
2464
  case DRIZZLE_TYPE_DATETIME:
2056
2481
      return 0;                                 // Error
2057
2482
    }
2058
2483
 
2059
 
    uint32_t pack_length=calc_pack_length((enum_field_types)
 
2484
    uint pack_length=calc_pack_length((enum_field_types)
2060
2485
                                      f_packtype(pack_flag),
2061
2486
                                      field_length);
2062
2487
 
2070
2495
        return new Field_enum(ptr,field_length,null_pos,null_bit,
2071
2496
                                  unireg_check, field_name,
2072
2497
                                  pack_length, interval, field_charset);
 
2498
      else
 
2499
        return new Field_set(ptr,field_length,null_pos,null_bit,
 
2500
                             unireg_check, field_name,
 
2501
                             pack_length, interval, field_charset);
2073
2502
    }
2074
2503
  }
2075
2504
 
2091
2520
                          unireg_check, field_name,
2092
2521
                          false,
2093
2522
                          f_is_dec(pack_flag) == 0);
 
2523
  case DRIZZLE_TYPE_SHORT:
 
2524
    return new Field_short(ptr,field_length,null_pos,null_bit,
 
2525
                           unireg_check, field_name,
 
2526
                           false,
 
2527
                           f_is_dec(pack_flag) == 0);
2094
2528
  case DRIZZLE_TYPE_LONG:
2095
2529
    return new Field_long(ptr,field_length,null_pos,null_bit,
2096
2530
                           unireg_check, field_name,
2105
2539
    return new Field_timestamp(ptr,field_length, null_pos, null_bit,
2106
2540
                               unireg_check, field_name, share,
2107
2541
                               field_charset);
 
2542
  case DRIZZLE_TYPE_DATE:
2108
2543
  case DRIZZLE_TYPE_NEWDATE:
2109
2544
    return new Field_newdate(ptr,null_pos,null_bit,
2110
2545
                             unireg_check, field_name, field_charset);
2153
2588
    break;
2154
2589
    /* Change CHAR -> VARCHAR if dynamic record length */
2155
2590
  case DRIZZLE_TYPE_ENUM:
 
2591
  case DRIZZLE_TYPE_SET:
2156
2592
  case DRIZZLE_TYPE_VARCHAR:
2157
2593
    /* This is corrected in create_length_to_internal_length */
2158
2594
    length= (length+charset->mbmaxlen-1) / charset->mbmaxlen;
2220
2656
*/
2221
2657
 
2222
2658
bool 
2223
 
Field::set_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code,
 
2659
Field::set_warning(DRIZZLE_ERROR::enum_warning_level level, uint code,
2224
2660
                   int cuted_increment)
2225
2661
{
2226
2662
  /*
2258
2694
void 
2259
2695
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
2260
2696
                            unsigned int code, 
2261
 
                            const char *str, uint32_t str_length, 
2262
 
                            enum enum_drizzle_timestamp_type ts_type, int cuted_increment)
 
2697
                            const char *str, uint str_length, 
 
2698
                            timestamp_type ts_type, int cuted_increment)
2263
2699
{
2264
2700
  THD *thd= table ? table->in_use : current_thd;
2265
2701
  if ((thd->really_abort_on_warning() &&
2286
2722
*/
2287
2723
 
2288
2724
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,
 
2725
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint code, 
 
2726
                            int64_t nr, timestamp_type ts_type,
2291
2727
                            int cuted_increment)
2292
2728
{
2293
2729
  THD *thd= table ? table->in_use : current_thd;
2296
2732
  {
2297
2733
    char str_nr[22];
2298
2734
    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), 
 
2735
    make_truncated_value_warning(thd, level, str_nr, (uint) (str_end - str_nr), 
2300
2736
                                 ts_type, field_name);
2301
2737
  }
2302
2738
}
2317
2753
*/
2318
2754
 
2319
2755
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)
 
2756
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint code, 
 
2757
                            double nr, timestamp_type ts_type)
2322
2758
{
2323
2759
  THD *thd= table ? table->in_use : current_thd;
2324
2760
  if (thd->really_abort_on_warning() ||
2326
2762
  {
2327
2763
    /* DBL_DIG is enough to print '-[digits].E+###' */
2328
2764
    char str_nr[DBL_DIG + 8];
2329
 
    uint32_t str_len= sprintf(str_nr, "%g", nr);
 
2765
    uint str_len= sprintf(str_nr, "%g", nr);
2330
2766
    make_truncated_value_warning(thd, level, str_nr, str_len, ts_type,
2331
2767
                                 field_name);
2332
2768
  }