← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

enable remaining subselect tests, merge with latest from the trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.cc
1
 
/* Copyright (C) 2000-2006 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 MySQL
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; either version 2 of the License, or
 
9
 *  (at your option) any later version.
 
10
 *
 
11
 *  This program is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *  GNU General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU General Public License
 
17
 *  along with this program; if not, write to the Free Software
 
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
19
 */
16
20
 
17
21
/**
18
22
  @file
23
27
#include <drizzled/server_includes.h>
24
28
#include "sql_select.h"
25
29
#include <errno.h>
26
 
#include <drizzled/drizzled_error_messages.h>
 
30
#include <drizzled/error.h>
 
31
#include <drizzled/virtual_column_info.h>
 
32
#include <drizzled/field/str.h>
 
33
#include <drizzled/field/longstr.h>
 
34
#include <drizzled/field/num.h>
 
35
#include <drizzled/field/blob.h>
 
36
#include <drizzled/field/enum.h>
 
37
#include <drizzled/field/null.h>
 
38
#include <drizzled/field/date.h>
 
39
#include <drizzled/field/decimal.h>
 
40
#include <drizzled/field/real.h>
 
41
#include <drizzled/field/double.h>
 
42
#include <drizzled/field/long.h>
 
43
#include <drizzled/field/int64_t.h>
 
44
#include <drizzled/field/num.h>
 
45
#include <drizzled/field/timetype.h>
 
46
#include <drizzled/field/timestamp.h>
 
47
#include <drizzled/field/datetime.h>
 
48
#include <drizzled/field/varstring.h>
27
49
 
28
 
// Maximum allowed exponent value for converting string to decimal
29
 
#define MAX_EXPONENT 1024
30
50
 
31
51
/*****************************************************************************
32
52
  Instansiate templates and static variables
38
58
#endif
39
59
 
40
60
 
41
 
/*
42
 
  Rules for merging different types of fields in UNION
43
 
 
44
 
  NOTE: to avoid 256*256 table, gap in table types numeration is skiped
45
 
  following #defines describe that gap and how to canculate number of fields
46
 
  and index of field in thia array.
47
 
*/
48
 
#define FIELDTYPE_TEAR_FROM (DRIZZLE_TYPE_VARCHAR + 1)
49
 
#define FIELDTYPE_TEAR_TO   (DRIZZLE_TYPE_NEWDECIMAL - 1)
50
 
#define FIELDTYPE_NUM (FIELDTYPE_TEAR_FROM + (255 - FIELDTYPE_TEAR_TO))
51
 
inline int field_type2index (enum_field_types field_type)
52
 
{
53
 
  return (field_type < FIELDTYPE_TEAR_FROM ?
54
 
          field_type :
55
 
          ((int)FIELDTYPE_TEAR_FROM) + (field_type - FIELDTYPE_TEAR_TO) - 1);
56
 
}
57
 
 
58
 
 
59
 
static enum_field_types field_types_merge_rules [FIELDTYPE_NUM][FIELDTYPE_NUM]=
60
 
{
61
 
  /* DRIZZLE_TYPE_DECIMAL -> */
62
 
  {
63
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
64
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
65
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
66
 
    DRIZZLE_TYPE_NEWDECIMAL,  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_DATE         DRIZZLE_TYPE_TIME
74
 
    DRIZZLE_TYPE_VARCHAR,     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
 
  },
 
61
static enum_field_types
 
62
field_types_merge_rules [DRIZZLE_TYPE_MAX+1][DRIZZLE_TYPE_MAX+1]=
 
63
{
84
64
  /* DRIZZLE_TYPE_TINY -> */
85
65
  {
86
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
87
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_TINY,
88
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
89
 
    DRIZZLE_TYPE_SHORT,       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_DATE         DRIZZLE_TYPE_TIME
97
 
    DRIZZLE_TYPE_VARCHAR,     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_SHORT -> */
108
 
  {
109
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
110
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_SHORT,
111
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
112
 
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_LONG,
113
 
  //DRIZZLE_TYPE_DOUBLE
114
 
    DRIZZLE_TYPE_DOUBLE,
115
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
116
 
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_VARCHAR,
117
 
  //DRIZZLE_TYPE_LONGLONG
118
 
    DRIZZLE_TYPE_LONGLONG,
119
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
120
 
    DRIZZLE_TYPE_VARCHAR,     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
 
66
    //DRIZZLE_TYPE_TINY
 
67
    DRIZZLE_TYPE_TINY,
 
68
    //DRIZZLE_TYPE_LONG
 
69
    DRIZZLE_TYPE_LONG,
 
70
    //DRIZZLE_TYPE_DOUBLE
 
71
    DRIZZLE_TYPE_DOUBLE,
 
72
    //DRIZZLE_TYPE_NULL
 
73
    DRIZZLE_TYPE_TINY,
 
74
    //DRIZZLE_TYPE_TIMESTAMP
 
75
    DRIZZLE_TYPE_VARCHAR,
 
76
    //DRIZZLE_TYPE_LONGLONG
 
77
    DRIZZLE_TYPE_LONGLONG,
 
78
    //DRIZZLE_TYPE_TIME
 
79
    DRIZZLE_TYPE_VARCHAR,
 
80
    //DRIZZLE_TYPE_DATETIME
 
81
    DRIZZLE_TYPE_VARCHAR,
 
82
    //DRIZZLE_TYPE_DATE
 
83
    DRIZZLE_TYPE_VARCHAR,
 
84
    //DRIZZLE_TYPE_VARCHAR
 
85
    DRIZZLE_TYPE_VARCHAR,
 
86
    //DRIZZLE_TYPE_VIRTUAL
 
87
    DRIZZLE_TYPE_VIRTUAL,
 
88
    //DRIZZLE_TYPE_NEWDECIMAL
 
89
    DRIZZLE_TYPE_NEWDECIMAL,
 
90
    //DRIZZLE_TYPE_ENUM
 
91
    DRIZZLE_TYPE_VARCHAR,
 
92
    //DRIZZLE_TYPE_BLOB
128
93
    DRIZZLE_TYPE_BLOB,
129
94
  },
130
95
  /* DRIZZLE_TYPE_LONG -> */
131
96
  {
132
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
133
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_LONG,
134
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
135
 
    DRIZZLE_TYPE_LONG,        DRIZZLE_TYPE_LONG,
136
 
  //DRIZZLE_TYPE_DOUBLE
 
97
    //DRIZZLE_TYPE_TINY
 
98
    DRIZZLE_TYPE_LONG,
 
99
    //DRIZZLE_TYPE_LONG
 
100
    DRIZZLE_TYPE_LONG,
 
101
    //DRIZZLE_TYPE_DOUBLE
137
102
    DRIZZLE_TYPE_DOUBLE,
138
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
139
 
    DRIZZLE_TYPE_LONG,         DRIZZLE_TYPE_VARCHAR,
140
 
  //DRIZZLE_TYPE_LONGLONG
 
103
    //DRIZZLE_TYPE_NULL
 
104
    DRIZZLE_TYPE_LONG,
 
105
    //DRIZZLE_TYPE_TIMESTAMP
 
106
    DRIZZLE_TYPE_VARCHAR,
 
107
    //DRIZZLE_TYPE_LONGLONG
141
108
    DRIZZLE_TYPE_LONGLONG,
142
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
143
 
    DRIZZLE_TYPE_VARCHAR,     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_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
150
 
  //DRIZZLE_TYPE_BLOB
 
109
    //DRIZZLE_TYPE_TIME
 
110
    DRIZZLE_TYPE_VARCHAR,
 
111
    //DRIZZLE_TYPE_DATETIME
 
112
    DRIZZLE_TYPE_VARCHAR,
 
113
    //DRIZZLE_TYPE_DATE
 
114
    DRIZZLE_TYPE_VARCHAR,
 
115
    //DRIZZLE_TYPE_VARCHAR
 
116
    DRIZZLE_TYPE_VARCHAR,
 
117
    //DRIZZLE_TYPE_VIRTUAL
 
118
    DRIZZLE_TYPE_VIRTUAL,
 
119
    //DRIZZLE_TYPE_NEWDECIMAL
 
120
    DRIZZLE_TYPE_NEWDECIMAL,
 
121
    //DRIZZLE_TYPE_ENUM
 
122
    DRIZZLE_TYPE_VARCHAR,
 
123
    //DRIZZLE_TYPE_BLOB
151
124
    DRIZZLE_TYPE_BLOB,
152
125
  },
153
126
  /* DRIZZLE_TYPE_DOUBLE -> */
154
127
  {
155
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
156
 
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_DOUBLE,
157
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
158
 
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_DOUBLE,
159
 
  //DRIZZLE_TYPE_DOUBLE
160
 
    DRIZZLE_TYPE_DOUBLE,
161
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
162
 
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_VARCHAR,
163
 
  //DRIZZLE_TYPE_LONGLONG
164
 
    DRIZZLE_TYPE_DOUBLE,
165
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
166
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
167
 
  //DRIZZLE_TYPE_DATETIME
168
 
    DRIZZLE_TYPE_VARCHAR,
169
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
170
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
171
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
172
 
    DRIZZLE_TYPE_DOUBLE,      DRIZZLE_TYPE_VARCHAR,
173
 
  //DRIZZLE_TYPE_BLOB
 
128
    //DRIZZLE_TYPE_TINY
 
129
    DRIZZLE_TYPE_DOUBLE,
 
130
    //DRIZZLE_TYPE_LONG
 
131
    DRIZZLE_TYPE_DOUBLE,
 
132
    //DRIZZLE_TYPE_DOUBLE
 
133
    DRIZZLE_TYPE_DOUBLE,
 
134
    //DRIZZLE_TYPE_NULL
 
135
    DRIZZLE_TYPE_DOUBLE,
 
136
    //DRIZZLE_TYPE_TIMESTAMP
 
137
    DRIZZLE_TYPE_VARCHAR,
 
138
    //DRIZZLE_TYPE_LONGLONG
 
139
    DRIZZLE_TYPE_DOUBLE,
 
140
    //DRIZZLE_TYPE_TIME
 
141
    DRIZZLE_TYPE_VARCHAR,
 
142
    //DRIZZLE_TYPE_DATETIME
 
143
    DRIZZLE_TYPE_VARCHAR,
 
144
    //DRIZZLE_TYPE_DATE
 
145
    DRIZZLE_TYPE_VARCHAR,
 
146
    //DRIZZLE_TYPE_VARCHAR
 
147
    DRIZZLE_TYPE_VARCHAR,
 
148
    //DRIZZLE_TYPE_VIRTUAL
 
149
    DRIZZLE_TYPE_VIRTUAL,
 
150
    //DRIZZLE_TYPE_NEWDECIMAL
 
151
    DRIZZLE_TYPE_DOUBLE,
 
152
    //DRIZZLE_TYPE_ENUM
 
153
    DRIZZLE_TYPE_VARCHAR,
 
154
    //DRIZZLE_TYPE_BLOB
174
155
    DRIZZLE_TYPE_BLOB,
175
156
  },
176
157
  /* DRIZZLE_TYPE_NULL -> */
177
158
  {
178
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
179
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_TINY,
180
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
181
 
    DRIZZLE_TYPE_SHORT,       DRIZZLE_TYPE_LONG,
182
 
  //DRIZZLE_TYPE_DOUBLE
 
159
    //DRIZZLE_TYPE_TINY
 
160
    DRIZZLE_TYPE_TINY,
 
161
    //DRIZZLE_TYPE_LONG
 
162
    DRIZZLE_TYPE_LONG,
 
163
    //DRIZZLE_TYPE_DOUBLE
183
164
    DRIZZLE_TYPE_DOUBLE,
184
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
185
 
    DRIZZLE_TYPE_NULL,        DRIZZLE_TYPE_TIMESTAMP,
186
 
  //DRIZZLE_TYPE_LONGLONG
 
165
    //DRIZZLE_TYPE_NULL
 
166
    DRIZZLE_TYPE_NULL,
 
167
    //DRIZZLE_TYPE_TIMESTAMP
 
168
    DRIZZLE_TYPE_TIMESTAMP,
 
169
    //DRIZZLE_TYPE_LONGLONG
187
170
    DRIZZLE_TYPE_LONGLONG,
188
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
189
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_TIME,
190
 
  //DRIZZLE_TYPE_DATETIME
 
171
    //DRIZZLE_TYPE_TIME
 
172
    DRIZZLE_TYPE_TIME,
 
173
    //DRIZZLE_TYPE_DATETIME
191
174
    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_NEWDECIMAL,  DRIZZLE_TYPE_ENUM,
196
 
  //DRIZZLE_TYPE_BLOB
 
175
    //DRIZZLE_TYPE_DATE
 
176
    DRIZZLE_TYPE_DATE,
 
177
    //DRIZZLE_TYPE_VARCHAR
 
178
    DRIZZLE_TYPE_VARCHAR,
 
179
    //DRIZZLE_TYPE_VIRTUAL
 
180
    DRIZZLE_TYPE_VIRTUAL,
 
181
    //DRIZZLE_TYPE_NEWDECIMAL
 
182
    DRIZZLE_TYPE_NEWDECIMAL,
 
183
    //DRIZZLE_TYPE_ENUM
 
184
    DRIZZLE_TYPE_ENUM,
 
185
    //DRIZZLE_TYPE_BLOB
197
186
    DRIZZLE_TYPE_BLOB,
198
187
  },
199
188
  /* DRIZZLE_TYPE_TIMESTAMP -> */
200
189
  {
201
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
202
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
203
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
204
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
205
 
  //DRIZZLE_TYPE_DOUBLE
206
 
    DRIZZLE_TYPE_VARCHAR,
207
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
208
 
    DRIZZLE_TYPE_TIMESTAMP,   DRIZZLE_TYPE_TIMESTAMP,
209
 
  //DRIZZLE_TYPE_LONGLONG
210
 
    DRIZZLE_TYPE_VARCHAR,
211
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
212
 
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_DATETIME,
213
 
  //DRIZZLE_TYPE_DATETIME
214
 
    DRIZZLE_TYPE_DATETIME,
215
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
216
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
217
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
218
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
219
 
  //DRIZZLE_TYPE_BLOB
 
190
    //DRIZZLE_TYPE_TINY
 
191
    DRIZZLE_TYPE_VARCHAR,
 
192
    //DRIZZLE_TYPE_LONG
 
193
    DRIZZLE_TYPE_VARCHAR,
 
194
    //DRIZZLE_TYPE_DOUBLE
 
195
    DRIZZLE_TYPE_VARCHAR,
 
196
    //DRIZZLE_TYPE_NULL
 
197
    DRIZZLE_TYPE_TIMESTAMP,
 
198
    //DRIZZLE_TYPE_TIMESTAMP
 
199
    DRIZZLE_TYPE_TIMESTAMP,
 
200
    //DRIZZLE_TYPE_LONGLONG
 
201
    DRIZZLE_TYPE_VARCHAR,
 
202
    //DRIZZLE_TYPE_TIME
 
203
    DRIZZLE_TYPE_DATETIME,
 
204
    //DRIZZLE_TYPE_DATETIME
 
205
    DRIZZLE_TYPE_DATETIME,
 
206
    //DRIZZLE_TYPE_DATE
 
207
    DRIZZLE_TYPE_DATE,
 
208
    //DRIZZLE_TYPE_VARCHAR
 
209
    DRIZZLE_TYPE_VARCHAR,
 
210
    //DRIZZLE_TYPE_VIRTUAL
 
211
    DRIZZLE_TYPE_VIRTUAL,
 
212
    //DRIZZLE_TYPE_NEWDECIMAL
 
213
    DRIZZLE_TYPE_VARCHAR,
 
214
    //DRIZZLE_TYPE_ENUM
 
215
    DRIZZLE_TYPE_VARCHAR,
 
216
    //DRIZZLE_TYPE_BLOB
220
217
    DRIZZLE_TYPE_BLOB,
221
218
  },
222
219
  /* DRIZZLE_TYPE_LONGLONG -> */
223
220
  {
224
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
225
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_LONGLONG,
226
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
227
 
    DRIZZLE_TYPE_LONGLONG,    DRIZZLE_TYPE_LONGLONG,
228
 
  //DRIZZLE_TYPE_DOUBLE
 
221
    //DRIZZLE_TYPE_TINY
 
222
    DRIZZLE_TYPE_LONGLONG,
 
223
    //DRIZZLE_TYPE_LONG
 
224
    DRIZZLE_TYPE_LONGLONG,
 
225
    //DRIZZLE_TYPE_DOUBLE
229
226
    DRIZZLE_TYPE_DOUBLE,
230
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
231
 
    DRIZZLE_TYPE_LONGLONG,    DRIZZLE_TYPE_VARCHAR,
232
 
  //DRIZZLE_TYPE_LONGLONG
233
 
    DRIZZLE_TYPE_LONGLONG,
234
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
235
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
236
 
  //DRIZZLE_TYPE_DATETIME
237
 
    DRIZZLE_TYPE_VARCHAR,
238
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
239
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
240
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
241
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
242
 
  //DRIZZLE_TYPE_BLOB
243
 
    DRIZZLE_TYPE_BLOB,
244
 
  },
245
 
  /* DRIZZLE_TYPE_DATE -> */
246
 
  {
247
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
248
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
249
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
250
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
251
 
  //DRIZZLE_TYPE_DOUBLE
252
 
    DRIZZLE_TYPE_VARCHAR,
253
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
254
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
255
 
  //DRIZZLE_TYPE_LONGLONG
256
 
    DRIZZLE_TYPE_VARCHAR,
257
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
258
 
    DRIZZLE_TYPE_NEWDATE,     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
 
227
    //DRIZZLE_TYPE_NULL
 
228
    DRIZZLE_TYPE_LONGLONG,
 
229
    //DRIZZLE_TYPE_TIMESTAMP
 
230
    DRIZZLE_TYPE_VARCHAR,
 
231
    //DRIZZLE_TYPE_LONGLONG
 
232
    DRIZZLE_TYPE_LONGLONG,
 
233
    //DRIZZLE_TYPE_TIME
 
234
    DRIZZLE_TYPE_VARCHAR,
 
235
    //DRIZZLE_TYPE_DATETIME
 
236
    DRIZZLE_TYPE_VARCHAR,
 
237
    //DRIZZLE_TYPE_DATE
 
238
    DRIZZLE_TYPE_DATE,
 
239
    //DRIZZLE_TYPE_VARCHAR
 
240
    DRIZZLE_TYPE_VARCHAR,
 
241
    //DRIZZLE_TYPE_VIRTUAL
 
242
    DRIZZLE_TYPE_VIRTUAL,
 
243
    //DRIZZLE_TYPE_NEWDECIMAL
 
244
    //DRIZZLE_TYPE_ENUM
 
245
    DRIZZLE_TYPE_NEWDECIMAL,
 
246
    DRIZZLE_TYPE_VARCHAR,
 
247
    //DRIZZLE_TYPE_BLOB
266
248
    DRIZZLE_TYPE_BLOB,
267
249
  },
268
250
  /* DRIZZLE_TYPE_TIME -> */
269
251
  {
270
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
271
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
272
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
273
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
274
 
  //DRIZZLE_TYPE_DOUBLE
275
 
    DRIZZLE_TYPE_VARCHAR,
276
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
277
 
    DRIZZLE_TYPE_TIME,        DRIZZLE_TYPE_DATETIME,
278
 
  //DRIZZLE_TYPE_LONGLONG
279
 
    DRIZZLE_TYPE_VARCHAR,
280
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
281
 
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_TIME,
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
 
252
    //DRIZZLE_TYPE_TINY
 
253
    DRIZZLE_TYPE_VARCHAR,
 
254
    //DRIZZLE_TYPE_LONG
 
255
    DRIZZLE_TYPE_VARCHAR,
 
256
    //DRIZZLE_TYPE_DOUBLE
 
257
    DRIZZLE_TYPE_VARCHAR,
 
258
    //DRIZZLE_TYPE_NULL
 
259
    DRIZZLE_TYPE_TIME,
 
260
    //DRIZZLE_TYPE_TIMESTAMP
 
261
    DRIZZLE_TYPE_DATETIME,
 
262
    //DRIZZLE_TYPE_LONGLONG
 
263
    DRIZZLE_TYPE_VARCHAR,
 
264
    //DRIZZLE_TYPE_TIME
 
265
    DRIZZLE_TYPE_TIME,
 
266
    //DRIZZLE_TYPE_DATETIME
 
267
    DRIZZLE_TYPE_DATETIME,
 
268
    //DRIZZLE_TYPE_DATE
 
269
    DRIZZLE_TYPE_DATE,
 
270
    //DRIZZLE_TYPE_VARCHAR
 
271
    DRIZZLE_TYPE_VARCHAR,
 
272
    //DRIZZLE_TYPE_VIRTUAL
 
273
    DRIZZLE_TYPE_VIRTUAL,
 
274
    //DRIZZLE_TYPE_NEWDECIMAL
 
275
    DRIZZLE_TYPE_VARCHAR,
 
276
    //DRIZZLE_TYPE_ENUM
 
277
    DRIZZLE_TYPE_VARCHAR,
 
278
    //DRIZZLE_TYPE_BLOB
289
279
    DRIZZLE_TYPE_BLOB,
290
280
  },
291
281
  /* DRIZZLE_TYPE_DATETIME -> */
292
282
  {
293
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
294
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
295
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
296
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
297
 
  //DRIZZLE_TYPE_DOUBLE
298
 
    DRIZZLE_TYPE_VARCHAR,
299
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
300
 
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_DATETIME,
301
 
  //DRIZZLE_TYPE_LONGLONG
302
 
    DRIZZLE_TYPE_VARCHAR,
303
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
304
 
    DRIZZLE_TYPE_DATETIME,    DRIZZLE_TYPE_DATETIME,
305
 
  //DRIZZLE_TYPE_DATETIME
306
 
    DRIZZLE_TYPE_DATETIME,
307
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
308
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
309
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
310
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
311
 
  //DRIZZLE_TYPE_BLOB
 
283
    //DRIZZLE_TYPE_TINY
 
284
    DRIZZLE_TYPE_VARCHAR,
 
285
    //DRIZZLE_TYPE_LONG
 
286
    DRIZZLE_TYPE_VARCHAR,
 
287
    //DRIZZLE_TYPE_DOUBLE
 
288
    DRIZZLE_TYPE_VARCHAR,
 
289
    //DRIZZLE_TYPE_NULL
 
290
    DRIZZLE_TYPE_DATETIME,
 
291
    //DRIZZLE_TYPE_TIMESTAMP
 
292
    DRIZZLE_TYPE_DATETIME,
 
293
    //DRIZZLE_TYPE_LONGLONG
 
294
    DRIZZLE_TYPE_VARCHAR,
 
295
    //DRIZZLE_TYPE_TIME
 
296
    DRIZZLE_TYPE_DATETIME,
 
297
    //DRIZZLE_TYPE_DATETIME
 
298
    DRIZZLE_TYPE_DATETIME,
 
299
    //DRIZZLE_TYPE_DATE
 
300
    DRIZZLE_TYPE_DATE,
 
301
    //DRIZZLE_TYPE_VARCHAR
 
302
    DRIZZLE_TYPE_VARCHAR,
 
303
    //DRIZZLE_TYPE_VIRTUAL
 
304
    DRIZZLE_TYPE_VIRTUAL,
 
305
    //DRIZZLE_TYPE_NEWDECIMAL
 
306
    DRIZZLE_TYPE_VARCHAR,
 
307
    //DRIZZLE_TYPE_ENUM
 
308
    DRIZZLE_TYPE_VARCHAR,
 
309
    //DRIZZLE_TYPE_BLOB
312
310
    DRIZZLE_TYPE_BLOB,
313
311
  },
314
 
  /* DRIZZLE_TYPE_NEWDATE -> */
 
312
  /* DRIZZLE_TYPE_DATE -> */
315
313
  {
316
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
317
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
318
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
319
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
320
 
  //DRIZZLE_TYPE_DOUBLE
321
 
    DRIZZLE_TYPE_VARCHAR,
322
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
323
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
324
 
  //DRIZZLE_TYPE_LONGLONG
325
 
    DRIZZLE_TYPE_VARCHAR,
326
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
327
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_DATETIME,
328
 
  //DRIZZLE_TYPE_DATETIME
329
 
    DRIZZLE_TYPE_DATETIME,
330
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
331
 
    DRIZZLE_TYPE_NEWDATE,     DRIZZLE_TYPE_VARCHAR,
332
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
333
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
334
 
  //DRIZZLE_TYPE_BLOB
 
314
    //DRIZZLE_TYPE_TINY
 
315
    DRIZZLE_TYPE_VARCHAR,
 
316
    //DRIZZLE_TYPE_LONG
 
317
    DRIZZLE_TYPE_VARCHAR,
 
318
    //DRIZZLE_TYPE_DOUBLE
 
319
    DRIZZLE_TYPE_VARCHAR,
 
320
    //DRIZZLE_TYPE_NULL
 
321
    DRIZZLE_TYPE_DATE,
 
322
    //DRIZZLE_TYPE_TIMESTAMP
 
323
    DRIZZLE_TYPE_DATETIME,
 
324
    //DRIZZLE_TYPE_LONGLONG
 
325
    DRIZZLE_TYPE_VARCHAR,
 
326
    //DRIZZLE_TYPE_TIME
 
327
    DRIZZLE_TYPE_DATETIME,
 
328
    //DRIZZLE_TYPE_DATETIME
 
329
    DRIZZLE_TYPE_DATETIME,
 
330
    //DRIZZLE_TYPE_DATE
 
331
    DRIZZLE_TYPE_DATE,
 
332
    //DRIZZLE_TYPE_VARCHAR
 
333
    DRIZZLE_TYPE_VARCHAR,
 
334
    //DRIZZLE_TYPE_VIRTUAL
 
335
    DRIZZLE_TYPE_VIRTUAL,
 
336
    //DRIZZLE_TYPE_NEWDECIMAL
 
337
    DRIZZLE_TYPE_VARCHAR,
 
338
    //DRIZZLE_TYPE_ENUM
 
339
    DRIZZLE_TYPE_VARCHAR,
 
340
    //DRIZZLE_TYPE_BLOB
335
341
    DRIZZLE_TYPE_BLOB,
336
342
  },
337
343
  /* DRIZZLE_TYPE_VARCHAR -> */
338
344
  {
339
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
340
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
341
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
342
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
343
 
  //DRIZZLE_TYPE_DOUBLE
344
 
    DRIZZLE_TYPE_VARCHAR,
345
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
346
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
347
 
  //DRIZZLE_TYPE_LONGLONG
348
 
    DRIZZLE_TYPE_VARCHAR,
349
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
350
 
    DRIZZLE_TYPE_VARCHAR,     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
 
345
    //DRIZZLE_TYPE_TINY
 
346
    DRIZZLE_TYPE_VARCHAR,
 
347
    //DRIZZLE_TYPE_LONG
 
348
    DRIZZLE_TYPE_VARCHAR,
 
349
    //DRIZZLE_TYPE_DOUBLE
 
350
    DRIZZLE_TYPE_VARCHAR,
 
351
    //DRIZZLE_TYPE_NULL
 
352
    DRIZZLE_TYPE_VARCHAR,
 
353
    //DRIZZLE_TYPE_TIMESTAMP
 
354
    DRIZZLE_TYPE_VARCHAR,
 
355
    //DRIZZLE_TYPE_LONGLONG
 
356
    DRIZZLE_TYPE_VARCHAR,
 
357
    //DRIZZLE_TYPE_TIME
 
358
    DRIZZLE_TYPE_VARCHAR,
 
359
    //DRIZZLE_TYPE_DATETIME
 
360
    DRIZZLE_TYPE_VARCHAR,
 
361
    //DRIZZLE_TYPE_DATE
 
362
    DRIZZLE_TYPE_VARCHAR,
 
363
    //DRIZZLE_TYPE_VARCHAR
 
364
    DRIZZLE_TYPE_VARCHAR,
 
365
    //DRIZZLE_TYPE_VIRTUAL
 
366
    DRIZZLE_TYPE_VIRTUAL,
 
367
    //DRIZZLE_TYPE_NEWDECIMAL
 
368
    DRIZZLE_TYPE_VARCHAR,
 
369
    //DRIZZLE_TYPE_ENUM
 
370
    DRIZZLE_TYPE_VARCHAR,
 
371
    //DRIZZLE_TYPE_BLOB
358
372
    DRIZZLE_TYPE_BLOB,
359
373
  },
 
374
  /* DRIZZLE_TYPE_VIRTUAL -> */
 
375
  {
 
376
    //DRIZZLE_TYPE_TINY
 
377
    DRIZZLE_TYPE_VIRTUAL,
 
378
    //DRIZZLE_TYPE_LONG
 
379
    DRIZZLE_TYPE_VIRTUAL,
 
380
    //DRIZZLE_TYPE_DOUBLE
 
381
    DRIZZLE_TYPE_VIRTUAL,
 
382
    //DRIZZLE_TYPE_NULL
 
383
    DRIZZLE_TYPE_VIRTUAL,
 
384
    //DRIZZLE_TYPE_TIMESTAMP
 
385
    DRIZZLE_TYPE_VIRTUAL,
 
386
    //DRIZZLE_TYPE_LONGLONG
 
387
    DRIZZLE_TYPE_VIRTUAL,
 
388
    //DRIZZLE_TYPE_TIME
 
389
    DRIZZLE_TYPE_VIRTUAL,
 
390
    //DRIZZLE_TYPE_DATETIME
 
391
    DRIZZLE_TYPE_VIRTUAL,
 
392
    //DRIZZLE_TYPE_DATE
 
393
    DRIZZLE_TYPE_VIRTUAL,
 
394
    //DRIZZLE_TYPE_VARCHAR
 
395
    DRIZZLE_TYPE_VIRTUAL,
 
396
    //DRIZZLE_TYPE_VIRTUAL
 
397
    DRIZZLE_TYPE_VIRTUAL,
 
398
    //DRIZZLE_TYPE_NEWDECIMAL
 
399
    DRIZZLE_TYPE_VIRTUAL,
 
400
    //DRIZZLE_TYPE_ENUM
 
401
    DRIZZLE_TYPE_VIRTUAL,
 
402
    //DRIZZLE_TYPE_BLOB
 
403
    DRIZZLE_TYPE_VIRTUAL,
 
404
  },
360
405
  /* DRIZZLE_TYPE_NEWDECIMAL -> */
361
406
  {
362
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
363
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
364
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
365
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_NEWDECIMAL,
366
 
  //DRIZZLE_TYPE_DOUBLE
 
407
    //DRIZZLE_TYPE_TINY
 
408
    DRIZZLE_TYPE_NEWDECIMAL,
 
409
    //DRIZZLE_TYPE_LONG
 
410
    DRIZZLE_TYPE_NEWDECIMAL,
 
411
    //DRIZZLE_TYPE_DOUBLE
367
412
    DRIZZLE_TYPE_DOUBLE,
368
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
369
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
370
 
  //DRIZZLE_TYPE_LONGLONG
371
 
    DRIZZLE_TYPE_NEWDECIMAL,
372
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
373
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
374
 
  //DRIZZLE_TYPE_DATETIME
375
 
    DRIZZLE_TYPE_VARCHAR,
376
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
377
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
378
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
379
 
    DRIZZLE_TYPE_NEWDECIMAL,  DRIZZLE_TYPE_VARCHAR,
380
 
  //DRIZZLE_TYPE_BLOB
 
413
    //DRIZZLE_TYPE_NULL
 
414
    DRIZZLE_TYPE_NEWDECIMAL,
 
415
    //DRIZZLE_TYPE_TIMESTAMP
 
416
    DRIZZLE_TYPE_VARCHAR,
 
417
    //DRIZZLE_TYPE_LONGLONG
 
418
    DRIZZLE_TYPE_NEWDECIMAL,
 
419
    //DRIZZLE_TYPE_TIME
 
420
    DRIZZLE_TYPE_VARCHAR,
 
421
    //DRIZZLE_TYPE_DATETIME
 
422
    DRIZZLE_TYPE_VARCHAR,
 
423
    //DRIZZLE_TYPE_DATE
 
424
    DRIZZLE_TYPE_VARCHAR,
 
425
    //DRIZZLE_TYPE_VARCHAR
 
426
    DRIZZLE_TYPE_VARCHAR,
 
427
    //DRIZZLE_TYPE_VIRTUAL
 
428
    DRIZZLE_TYPE_VIRTUAL,
 
429
    //DRIZZLE_TYPE_NEWDECIMAL
 
430
    DRIZZLE_TYPE_NEWDECIMAL,
 
431
    //DRIZZLE_TYPE_ENUM
 
432
    DRIZZLE_TYPE_VARCHAR,
 
433
    //DRIZZLE_TYPE_BLOB
381
434
    DRIZZLE_TYPE_BLOB,
382
435
  },
383
436
  /* DRIZZLE_TYPE_ENUM -> */
384
437
  {
385
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
386
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
387
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
388
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
389
 
  //DRIZZLE_TYPE_DOUBLE
390
 
    DRIZZLE_TYPE_VARCHAR,
391
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
392
 
    DRIZZLE_TYPE_ENUM,        DRIZZLE_TYPE_VARCHAR,
393
 
  //DRIZZLE_TYPE_LONGLONG
394
 
    DRIZZLE_TYPE_VARCHAR,
395
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
396
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
397
 
  //DRIZZLE_TYPE_DATETIME
398
 
    DRIZZLE_TYPE_VARCHAR,
399
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
400
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
401
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
402
 
    DRIZZLE_TYPE_VARCHAR,     DRIZZLE_TYPE_VARCHAR,
403
 
  //DRIZZLE_TYPE_BLOB
 
438
    //DRIZZLE_TYPE_TINY
 
439
    DRIZZLE_TYPE_VARCHAR,
 
440
    //DRIZZLE_TYPE_LONG
 
441
    DRIZZLE_TYPE_VARCHAR,
 
442
    //DRIZZLE_TYPE_DOUBLE
 
443
    DRIZZLE_TYPE_VARCHAR,
 
444
    //DRIZZLE_TYPE_NULL
 
445
    DRIZZLE_TYPE_ENUM,
 
446
    //DRIZZLE_TYPE_TIMESTAMP
 
447
    DRIZZLE_TYPE_VARCHAR,
 
448
    //DRIZZLE_TYPE_LONGLONG
 
449
    DRIZZLE_TYPE_VARCHAR,
 
450
    //DRIZZLE_TYPE_TIME
 
451
    DRIZZLE_TYPE_VARCHAR,
 
452
    //DRIZZLE_TYPE_DATETIME
 
453
    DRIZZLE_TYPE_VARCHAR,
 
454
    //DRIZZLE_TYPE_DATE
 
455
    DRIZZLE_TYPE_VARCHAR,
 
456
    //DRIZZLE_TYPE_VARCHAR
 
457
    DRIZZLE_TYPE_VARCHAR,
 
458
    //DRIZZLE_TYPE_VIRTUAL
 
459
    DRIZZLE_TYPE_VIRTUAL,
 
460
    //DRIZZLE_TYPE_NEWDECIMAL
 
461
    DRIZZLE_TYPE_VARCHAR,
 
462
    //DRIZZLE_TYPE_ENUM
 
463
    DRIZZLE_TYPE_VARCHAR,
 
464
    //DRIZZLE_TYPE_BLOB
404
465
    DRIZZLE_TYPE_BLOB,
405
466
  },
406
467
  /* DRIZZLE_TYPE_BLOB -> */
407
468
  {
408
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
409
 
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
410
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
411
 
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
412
 
  //DRIZZLE_TYPE_DOUBLE
413
 
    DRIZZLE_TYPE_BLOB,
414
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
415
 
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
416
 
  //DRIZZLE_TYPE_LONGLONG
417
 
    DRIZZLE_TYPE_BLOB,
418
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
419
 
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
420
 
  //DRIZZLE_TYPE_DATETIME
421
 
    DRIZZLE_TYPE_BLOB,
422
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
423
 
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
424
 
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
425
 
    DRIZZLE_TYPE_BLOB,        DRIZZLE_TYPE_BLOB,
426
 
  //DRIZZLE_TYPE_BLOB
 
469
    //DRIZZLE_TYPE_TINY
 
470
    DRIZZLE_TYPE_BLOB,
 
471
    //DRIZZLE_TYPE_LONG
 
472
    DRIZZLE_TYPE_BLOB,
 
473
    //DRIZZLE_TYPE_DOUBLE
 
474
    DRIZZLE_TYPE_BLOB,
 
475
    //DRIZZLE_TYPE_NULL
 
476
    DRIZZLE_TYPE_BLOB,
 
477
    //DRIZZLE_TYPE_TIMESTAMP
 
478
    DRIZZLE_TYPE_BLOB,
 
479
    //DRIZZLE_TYPE_LONGLONG
 
480
    DRIZZLE_TYPE_BLOB,
 
481
    //DRIZZLE_TYPE_TIME
 
482
    DRIZZLE_TYPE_BLOB,
 
483
    //DRIZZLE_TYPE_DATETIME
 
484
    DRIZZLE_TYPE_BLOB,
 
485
    //DRIZZLE_TYPE_DATE
 
486
    DRIZZLE_TYPE_BLOB,
 
487
    //DRIZZLE_TYPE_VARCHAR
 
488
    DRIZZLE_TYPE_BLOB,
 
489
    //DRIZZLE_TYPE_VIRTUAL
 
490
    DRIZZLE_TYPE_VIRTUAL,
 
491
    //DRIZZLE_TYPE_NEWDECIMAL
 
492
    DRIZZLE_TYPE_BLOB,
 
493
    //DRIZZLE_TYPE_ENUM
 
494
    DRIZZLE_TYPE_BLOB,
 
495
    //DRIZZLE_TYPE_BLOB
427
496
    DRIZZLE_TYPE_BLOB,
428
497
  },
429
498
};
441
510
enum_field_types Field::field_type_merge(enum_field_types a,
442
511
                                         enum_field_types b)
443
512
{
444
 
  assert(a < FIELDTYPE_TEAR_FROM || a > FIELDTYPE_TEAR_TO);
445
 
  assert(b < FIELDTYPE_TEAR_FROM || b > FIELDTYPE_TEAR_TO);
446
 
  return field_types_merge_rules[field_type2index(a)]
447
 
                                [field_type2index(b)];
 
513
  assert(a <= DRIZZLE_TYPE_MAX);
 
514
  assert(b <= DRIZZLE_TYPE_MAX);
 
515
  return field_types_merge_rules[a][b];
448
516
}
449
517
 
450
518
 
451
 
static Item_result field_types_result_type [FIELDTYPE_NUM]=
 
519
static Item_result field_types_result_type [DRIZZLE_TYPE_MAX+1]=
452
520
{
453
 
  //DRIZZLE_TYPE_DECIMAL      DRIZZLE_TYPE_TINY
454
 
  DECIMAL_RESULT,           INT_RESULT,
455
 
  //DRIZZLE_TYPE_SHORT        DRIZZLE_TYPE_LONG
456
 
  INT_RESULT,               INT_RESULT,
 
521
  //DRIZZLE_TYPE_TINY
 
522
  INT_RESULT,
 
523
  //DRIZZLE_TYPE_LONG
 
524
  INT_RESULT,
457
525
  //DRIZZLE_TYPE_DOUBLE
458
526
  REAL_RESULT,
459
 
  //DRIZZLE_TYPE_NULL         DRIZZLE_TYPE_TIMESTAMP
460
 
  STRING_RESULT,            STRING_RESULT,
 
527
  //DRIZZLE_TYPE_NULL
 
528
  STRING_RESULT,
 
529
  //DRIZZLE_TYPE_TIMESTAMP
 
530
  STRING_RESULT,
461
531
  //DRIZZLE_TYPE_LONGLONG
462
532
  INT_RESULT,
463
 
  //DRIZZLE_TYPE_DATE         DRIZZLE_TYPE_TIME
464
 
  STRING_RESULT,            STRING_RESULT,
 
533
  //DRIZZLE_TYPE_TIME
 
534
  STRING_RESULT,
465
535
  //DRIZZLE_TYPE_DATETIME
466
536
  STRING_RESULT,
467
 
  //DRIZZLE_TYPE_NEWDATE      DRIZZLE_TYPE_VARCHAR
468
 
  STRING_RESULT,            STRING_RESULT,
 
537
  //DRIZZLE_TYPE_DATE
 
538
  STRING_RESULT,
 
539
  //DRIZZLE_TYPE_VARCHAR
 
540
  STRING_RESULT,
 
541
  //DRIZZLE_TYPE_VIRTUAL
 
542
  STRING_RESULT,
469
543
  //DRIZZLE_TYPE_NEWDECIMAL   DRIZZLE_TYPE_ENUM
470
544
  DECIMAL_RESULT,           STRING_RESULT,
471
545
  //DRIZZLE_TYPE_BLOB
489
563
    true  - If string has some important data
490
564
*/
491
565
 
492
 
static bool
 
566
bool
493
567
test_if_important_data(const CHARSET_INFO * const cs, const char *str,
494
568
                       const char *strend)
495
569
{
499
573
}
500
574
 
501
575
 
502
 
/**
503
 
  Detect Item_result by given field type of UNION merge result.
504
 
 
505
 
  @param field_type  given field type
506
 
 
507
 
  @return
508
 
    Item_result (type of internal MySQL expression result)
509
 
*/
510
 
 
511
576
Item_result Field::result_merge_type(enum_field_types field_type)
512
577
{
513
 
  assert(field_type < FIELDTYPE_TEAR_FROM || field_type
514
 
              > FIELDTYPE_TEAR_TO);
515
 
  return field_types_result_type[field_type2index(field_type)];
516
 
}
 
578
  assert(field_type <= DRIZZLE_TYPE_MAX);
 
579
  return field_types_result_type[field_type];
 
580
}
 
581
 
 
582
 
 
583
bool Field::eq(Field *field)
 
584
{
 
585
  return (ptr == field->ptr && null_ptr == field->null_ptr &&
 
586
          null_bit == field->null_bit);
 
587
}
 
588
 
 
589
 
 
590
uint32_t Field::pack_length() const
 
591
{
 
592
  return field_length;
 
593
}
 
594
 
 
595
 
 
596
uint32_t Field::pack_length_in_rec() const
 
597
{
 
598
  return pack_length();
 
599
}
 
600
 
 
601
 
 
602
uint32_t Field::pack_length_from_metadata(uint32_t field_metadata)
 
603
{
 
604
  return field_metadata;
 
605
}
 
606
 
 
607
 
 
608
uint32_t Field::row_pack_length()
 
609
{
 
610
  return 0;
 
611
}
 
612
 
 
613
 
 
614
int Field::save_field_metadata(unsigned char *first_byte)
 
615
{
 
616
  return do_save_field_metadata(first_byte);
 
617
}
 
618
 
 
619
 
 
620
uint32_t Field::data_length()
 
621
{
 
622
  return pack_length();
 
623
}
 
624
 
 
625
 
 
626
uint32_t Field::used_length()
 
627
{
 
628
  return pack_length();
 
629
}
 
630
 
 
631
 
 
632
uint32_t Field::sort_length() const
 
633
{
 
634
  return pack_length();
 
635
}
 
636
 
 
637
 
 
638
uint32_t Field::max_data_length() const
 
639
{
 
640
  return pack_length();
 
641
}
 
642
 
 
643
 
 
644
int Field::reset(void)
 
645
{
 
646
  memset(ptr, 0, pack_length());
 
647
  return 0;
 
648
}
 
649
 
 
650
 
 
651
void Field::reset_fields()
 
652
{}
 
653
 
 
654
 
 
655
void Field::set_default()
 
656
{
 
657
  my_ptrdiff_t l_offset= (my_ptrdiff_t) (table->getDefaultValues() - table->record[0]);
 
658
  memcpy(ptr, ptr + l_offset, pack_length());
 
659
  if (null_ptr)
 
660
    *null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
 
661
}
 
662
 
 
663
 
 
664
bool Field::binary() const
 
665
{
 
666
  return 1;
 
667
}
 
668
 
 
669
 
 
670
bool Field::zero_pack() const
 
671
{
 
672
  return 1;
 
673
}
 
674
 
 
675
 
 
676
enum ha_base_keytype Field::key_type() const
 
677
{
 
678
  return HA_KEYTYPE_BINARY;
 
679
}
 
680
 
 
681
 
 
682
uint32_t Field::key_length() const
 
683
{
 
684
  return pack_length();
 
685
}
 
686
 
 
687
 
 
688
enum_field_types Field::real_type() const
 
689
{
 
690
  return type();
 
691
}
 
692
 
 
693
 
 
694
int Field::cmp_max(const unsigned char *a, const unsigned char *b, uint32_t)
 
695
{
 
696
  return cmp(a, b);
 
697
}
 
698
 
 
699
 
 
700
int Field::cmp_binary(const unsigned char *a,const unsigned char *b, uint32_t)
 
701
{
 
702
  return memcmp(a,b,pack_length());
 
703
}
 
704
 
 
705
 
 
706
int Field::cmp_offset(uint32_t row_offset)
 
707
{
 
708
  return cmp(ptr,ptr+row_offset);
 
709
}
 
710
 
 
711
 
 
712
int Field::cmp_binary_offset(uint32_t row_offset)
 
713
{
 
714
  return cmp_binary(ptr, ptr+row_offset);
 
715
}
 
716
 
 
717
 
 
718
int Field::key_cmp(const unsigned char *a,const unsigned char *b)
 
719
{
 
720
  return cmp(a, b);
 
721
}
 
722
 
 
723
 
 
724
int Field::key_cmp(const unsigned char *str, uint32_t)
 
725
{
 
726
  return cmp(ptr,str);
 
727
}
 
728
 
 
729
 
 
730
uint32_t Field::decimals() const
 
731
{
 
732
  return 0;
 
733
}
 
734
 
 
735
 
 
736
bool Field::is_null(my_ptrdiff_t row_offset)
 
737
{
 
738
  return null_ptr ?
 
739
    (null_ptr[row_offset] & null_bit ? true : false) :
 
740
    table->null_row;
 
741
}
 
742
 
 
743
 
 
744
bool Field::is_real_null(my_ptrdiff_t row_offset)
 
745
{
 
746
  return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : false;
 
747
}
 
748
 
 
749
 
 
750
bool Field::is_null_in_record(const unsigned char *record)
 
751
{
 
752
  if (!null_ptr)
 
753
    return false;
 
754
  return test(record[(uint32_t) (null_ptr -table->record[0])] &
 
755
              null_bit);
 
756
}
 
757
 
 
758
 
 
759
bool Field::is_null_in_record_with_offset(my_ptrdiff_t offset)
 
760
{
 
761
  if (!null_ptr)
 
762
    return false;
 
763
  return test(null_ptr[offset] & null_bit);
 
764
}
 
765
 
 
766
 
 
767
void Field::set_null(my_ptrdiff_t row_offset)
 
768
{
 
769
  if (null_ptr)
 
770
    null_ptr[row_offset]|= null_bit;
 
771
}
 
772
 
 
773
 
 
774
void Field::set_notnull(my_ptrdiff_t row_offset)
 
775
{
 
776
  if (null_ptr)
 
777
    null_ptr[row_offset]&= (unsigned char) ~null_bit;
 
778
}
 
779
 
 
780
 
 
781
bool Field::maybe_null(void)
 
782
{
 
783
  return null_ptr != 0 || table->maybe_null;
 
784
}
 
785
 
 
786
 
 
787
bool Field::real_maybe_null(void)
 
788
{
 
789
  return null_ptr != 0;
 
790
}
 
791
 
 
792
 
 
793
size_t Field::last_null_byte() const
 
794
{
 
795
  size_t bytes= do_last_null_byte();
 
796
  assert(bytes <= table->getNullBytes());
 
797
  return bytes;
 
798
}
 
799
 
517
800
 
518
801
/*****************************************************************************
519
802
  Static help functions
520
803
*****************************************************************************/
521
804
 
522
 
 
523
 
/**
524
 
  Check whether a field type can be partially indexed by a key.
525
 
 
526
 
  This is a static method, rather than a virtual function, because we need
527
 
  to check the type of a non-Field in mysql_alter_table().
528
 
 
529
 
  @param type  field type
530
 
 
531
 
  @retval
532
 
    true  Type can have a prefixed key
533
 
  @retval
534
 
    false Type can not have a prefixed key
535
 
*/
536
 
 
537
805
bool Field::type_can_have_key_part(enum enum_field_types type)
538
806
{
539
807
  switch (type) {
547
815
 
548
816
 
549
817
/**
550
 
  Numeric fields base class constructor.
551
 
*/
552
 
Field_num::Field_num(uchar *ptr_arg,uint32_t len_arg, uchar *null_ptr_arg,
553
 
                     uchar null_bit_arg, utype unireg_check_arg,
554
 
                     const char *field_name_arg,
555
 
                     uint8_t dec_arg, bool zero_arg, bool unsigned_arg)
556
 
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
557
 
         unireg_check_arg, field_name_arg),
558
 
  dec(dec_arg),decimal_precision(zero_arg),unsigned_flag(unsigned_arg)
559
 
{
560
 
  if (unsigned_flag)
561
 
    flags|=UNSIGNED_FLAG;
562
 
}
563
 
 
564
 
 
565
 
/**
566
 
  Test if given number is a int.
567
 
 
568
 
  @todo
569
 
    Make this multi-byte-character safe
570
 
 
571
 
  @param str            String to test
572
 
  @param length        Length of 'str'
573
 
  @param int_end        Pointer to char after last used digit
574
 
  @param cs             Character set
575
 
 
576
 
  @note
577
 
    This is called after one has called strntoull10rnd() function.
578
 
 
579
 
  @retval
580
 
    0   OK
581
 
  @retval
582
 
    1   error: empty string or wrong integer.
583
 
  @retval
584
 
    2   error: garbage at the end of string.
585
 
*/
586
 
 
587
 
int Field_num::check_int(const CHARSET_INFO * const cs, const char *str, int length, 
588
 
                         const char *int_end, int error)
589
 
{
590
 
  /* Test if we get an empty string or wrong integer */
591
 
  if (str == int_end || error == MY_ERRNO_EDOM)
592
 
  {
593
 
    char buff[128];
594
 
    String tmp(buff, (uint32_t) sizeof(buff), system_charset_info);
595
 
    tmp.copy(str, length, system_charset_info);
596
 
    push_warning_printf(table->in_use, DRIZZLE_ERROR::WARN_LEVEL_WARN,
597
 
                        ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, 
598
 
                        ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
599
 
                        "integer", tmp.c_ptr(), field_name,
600
 
                        (uint32_t) table->in_use->row_count);
601
 
    return 1;
602
 
  }
603
 
  /* Test if we have garbage at the end of the given string. */
604
 
  if (test_if_important_data(cs, int_end, str + length))
605
 
  {
606
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
607
 
    return 2;
608
 
  }
609
 
  return 0;
610
 
}
611
 
 
612
 
 
613
 
/*
614
 
  Conver a string to an integer then check bounds.
615
 
  
616
 
  SYNOPSIS
617
 
    Field_num::get_int
618
 
    cs            Character set
619
 
    from          String to convert
620
 
    len           Length of the string
621
 
    rnd           OUT int64_t value
622
 
    unsigned_max  max unsigned value
623
 
    signed_min    min signed value
624
 
    signed_max    max signed value
625
 
 
626
 
  DESCRIPTION
627
 
    The function calls strntoull10rnd() to get an integer value then
628
 
    check bounds and errors returned. In case of any error a warning
629
 
    is raised.
630
 
 
631
 
  RETURN
632
 
    0   ok
633
 
    1   error
634
 
*/
635
 
 
636
 
bool Field_num::get_int(const CHARSET_INFO * const cs, const char *from, uint len,
637
 
                        int64_t *rnd, uint64_t unsigned_max, 
638
 
                        int64_t signed_min, int64_t signed_max)
639
 
{
640
 
  char *end;
641
 
  int error;
642
 
  
643
 
  *rnd= (int64_t) cs->cset->strntoull10rnd(cs, from, len,
644
 
                                            unsigned_flag, &end,
645
 
                                            &error);
646
 
  if (unsigned_flag)
647
 
  {
648
 
 
649
 
    if ((((uint64_t) *rnd > unsigned_max) && (*rnd= (int64_t) unsigned_max)) ||
650
 
        error == MY_ERRNO_ERANGE)
651
 
    {
652
 
      goto out_of_range;
653
 
    }
654
 
  }
655
 
  else
656
 
  {
657
 
    if (*rnd < signed_min)
658
 
    {
659
 
      *rnd= signed_min;
660
 
      goto out_of_range;
661
 
    }
662
 
    else if (*rnd > signed_max)
663
 
    {
664
 
      *rnd= signed_max;
665
 
      goto out_of_range;
666
 
    }
667
 
  }
668
 
  if (table->in_use->count_cuted_fields &&
669
 
      check_int(cs, from, len, end, error))
670
 
    return 1;
671
 
  return 0;
672
 
 
673
 
out_of_range:
674
 
  set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
675
 
  return 1;
676
 
}
677
 
 
678
 
/**
679
818
  Process decimal library return codes and issue warnings for overflow and
680
819
  truncation.
681
820
 
703
842
}
704
843
 
705
844
 
 
845
void Field::init(Table *table_arg)
 
846
{
 
847
  orig_table= table= table_arg;
 
848
  table_name= &table_arg->alias;
 
849
}
 
850
 
 
851
 
706
852
#ifdef NOT_USED
707
853
static bool test_if_real(const char *str,int length, const CHARSET_INFO * const cs)
708
854
{
738
884
    return 1;
739
885
  if (*str == 'E' || *str == 'e')
740
886
  {
741
 
    if (length < 3 || (str[1] != '+' && str[1] != '-') || 
 
887
    if (length < 3 || (str[1] != '+' && str[1] != '-') ||
742
888
        !my_isdigit(cs,str[2]))
743
889
      return 0;
744
890
    length-=3;
767
913
String *Field::val_int_as_str(String *val_buffer, bool unsigned_val)
768
914
{
769
915
  const CHARSET_INFO * const cs= &my_charset_bin;
770
 
  uint length;
 
916
  uint32_t length;
771
917
  int64_t value= val_int();
772
918
 
773
919
  if (val_buffer->alloc(MY_INT64_NUM_DECIMAL_DIGITS))
774
920
    return 0;
775
 
  length= (uint) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
 
921
  length= (uint32_t) (*cs->cset->int64_t10_to_str)(cs, (char*) val_buffer->ptr(),
776
922
                                                MY_INT64_NUM_DECIMAL_DIGITS,
777
923
                                                unsigned_val ? 10 : -10,
778
924
                                                value);
782
928
 
783
929
 
784
930
/// This is used as a table name when the table structure is not set up
785
 
Field::Field(uchar *ptr_arg,uint32_t length_arg,uchar *null_ptr_arg,
786
 
             uchar null_bit_arg,
787
 
             utype unireg_check_arg, const char *field_name_arg)
 
931
Field::Field(unsigned char *ptr_arg,uint32_t length_arg,unsigned char *null_ptr_arg,
 
932
             unsigned char null_bit_arg,
 
933
             utype unireg_check_arg, const char *field_name_arg)
788
934
  :ptr(ptr_arg), null_ptr(null_ptr_arg),
789
935
   table(0), orig_table(0), table_name(0),
790
936
   field_name(field_name_arg),
791
937
   key_start(0), part_of_key(0), part_of_key_not_clustered(0),
792
938
   part_of_sortkey(0), unireg_check(unireg_check_arg),
793
 
   field_length(length_arg), null_bit(null_bit_arg), 
794
 
   is_created_from_null_item(false)
 
939
   field_length(length_arg), null_bit(null_bit_arg),
 
940
   is_created_from_null_item(false),
 
941
   vcol_info(NULL), is_stored(true)
795
942
{
796
943
  flags=null_ptr ? 0: NOT_NULL_FLAG;
797
944
  comment.str= (char*) "";
808
955
  }
809
956
  else
810
957
  {
811
 
    uint len= pack_length();
 
958
    uint32_t len= pack_length();
812
959
    const CHARSET_INFO * const cs= charset();
813
960
    cs->coll->hash_sort(cs, ptr, len, nr, nr2);
814
961
  }
829
976
  memcpy(ptr,ptr+row_offset,pack_length());
830
977
  if (null_ptr)
831
978
  {
832
 
    *null_ptr= (uchar) ((null_ptr[0] & (uchar) ~(uint) null_bit) | (null_ptr[row_offset] & (uchar) null_bit));
 
979
    *null_ptr= (unsigned char) ((null_ptr[0] &
 
980
                                 (unsigned char) ~(uint32_t) null_bit) |
 
981
                                (null_ptr[row_offset] &
 
982
                                 (unsigned char) null_bit));
833
983
  }
834
984
}
835
985
 
847
997
   Check to see if field size is compatible with destination.
848
998
 
849
999
   This method is used in row-based replication to verify that the slave's
850
 
   field size is less than or equal to the master's field size. The 
 
1000
   field size is less than or equal to the master's field size. The
851
1001
   encoded field metadata (from the master or source) is decoded and compared
852
 
   to the size of this field (the slave or destination). 
 
1002
   to the size of this field (the slave or destination).
853
1003
 
854
1004
   @param   field_metadata   Encoded size in field metadata
855
1005
 
856
1006
   @retval 0 if this field's size is < the source field's size
857
1007
   @retval 1 if this field's size is >= the source field's size
858
1008
*/
859
 
int Field::compatible_field_size(uint field_metadata)
 
1009
int Field::compatible_field_size(uint32_t field_metadata)
860
1010
{
861
 
  uint const source_size= pack_length_from_metadata(field_metadata);
862
 
  uint const destination_size= row_pack_length();
 
1011
  uint32_t const source_size= pack_length_from_metadata(field_metadata);
 
1012
  uint32_t const destination_size= row_pack_length();
863
1013
  return (source_size <= destination_size);
864
1014
}
865
1015
 
866
1016
 
867
 
int Field::store(const char *to, uint length, const CHARSET_INFO * const cs,
 
1017
int Field::store(const char *to, uint32_t length,
 
1018
                 const CHARSET_INFO * const cs,
868
1019
                 enum_check_fields check_level)
869
1020
{
870
1021
  int res;
913
1064
   the value of this flag is a moot point since the native format is
914
1065
   little-endian.
915
1066
*/
916
 
uchar *
917
 
Field::pack(uchar *to, const uchar *from, uint max_length,
918
 
            bool low_byte_first __attribute__((unused)))
 
1067
unsigned char *
 
1068
Field::pack(unsigned char *to, const unsigned char *from, uint32_t max_length,
 
1069
            bool)
919
1070
{
920
1071
  uint32_t length= pack_length();
921
1072
  set_if_smaller(length, max_length);
923
1074
  return to+length;
924
1075
}
925
1076
 
 
1077
 
 
1078
unsigned char *Field::pack(unsigned char *to, const unsigned char *from)
 
1079
{
 
1080
  unsigned char *result= this->pack(to, from, UINT32_MAX,
 
1081
                                    table->s->db_low_byte_first);
 
1082
  return(result);
 
1083
}
 
1084
 
 
1085
 
926
1086
/**
927
1087
   Unpack a field from row data.
928
1088
 
953
1113
 
954
1114
   @return  New pointer into memory based on from + length of the data
955
1115
*/
956
 
const uchar *
957
 
Field::unpack(uchar* to, const uchar *from, uint param_data,
958
 
              bool low_byte_first __attribute__((unused)))
 
1116
const unsigned char *
 
1117
Field::unpack(unsigned char* to, const unsigned char *from, uint32_t param_data,
 
1118
              bool)
959
1119
{
960
 
  uint length=pack_length();
 
1120
  uint32_t length=pack_length();
961
1121
  int from_type= 0;
962
1122
  /*
963
1123
    If from length is > 255, it has encoded data in the upper bits. Need
977
1137
    return from+length;
978
1138
  }
979
1139
 
980
 
  uint len= (param_data && (param_data < length)) ?
 
1140
  uint32_t len= (param_data && (param_data < length)) ?
981
1141
            param_data : length;
982
1142
 
983
1143
  memcpy(to, from, param_data > length ? length : len);
985
1145
}
986
1146
 
987
1147
 
988
 
my_decimal *Field::val_decimal(my_decimal *decimal __attribute__((unused)))
 
1148
const unsigned char *Field::unpack(unsigned char* to,
 
1149
                                   const unsigned char *from)
 
1150
{
 
1151
  const unsigned char *result= unpack(to, from, 0U,
 
1152
                                      table->s->db_low_byte_first);
 
1153
  return(result);
 
1154
}
 
1155
 
 
1156
 
 
1157
uint32_t Field::packed_col_length(const unsigned char *, uint32_t length)
 
1158
{
 
1159
  return length;
 
1160
}
 
1161
 
 
1162
 
 
1163
int Field::pack_cmp(const unsigned char *a, const unsigned char *b,
 
1164
                    uint32_t, bool)
 
1165
{
 
1166
  return cmp(a,b);
 
1167
}
 
1168
 
 
1169
 
 
1170
int Field::pack_cmp(const unsigned char *b, uint32_t, bool)
 
1171
{
 
1172
  return cmp(ptr,b);
 
1173
}
 
1174
 
 
1175
 
 
1176
my_decimal *Field::val_decimal(my_decimal *)
989
1177
{
990
1178
  /* This never have to be called */
991
1179
  assert(0);
993
1181
}
994
1182
 
995
1183
 
996
 
void Field_num::add_unsigned(String &res) const
997
 
{
998
 
  if (unsigned_flag)
999
 
    res.append(STRING_WITH_LEN(" unsigned"));
1000
 
}
1001
 
 
1002
 
 
1003
1184
void Field::make_field(Send_field *field)
1004
1185
{
1005
1186
  if (orig_table && orig_table->s->db.str && *orig_table->s->db.str)
1039
1220
  @return
1040
1221
    value converted from val
1041
1222
*/
1042
 
int64_t Field::convert_decimal2int64_t(const my_decimal *val,
1043
 
                                         bool unsigned_flag, int *err)
 
1223
int64_t Field::convert_decimal2int64_t(const my_decimal *val, bool, int *err)
1044
1224
{
1045
1225
  int64_t i;
1046
 
  if (unsigned_flag)
1047
 
  {
1048
 
    if (val->sign())
1049
 
    {
1050
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1051
 
      i= 0;
1052
 
      *err= 1;
1053
 
    }
1054
 
    else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
1055
 
                                           ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
1056
 
                                           val, true, &i)))
1057
 
    {
1058
 
      i= ~(int64_t) 0;
1059
 
      *err= 1;
1060
 
    }
1061
 
  }
1062
 
  else if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
1063
 
                                         ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
1064
 
                                         val, false, &i)))
 
1226
  if (warn_if_overflow(my_decimal2int(E_DEC_ERROR &
 
1227
                                      ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
 
1228
                                      val, false, &i)))
1065
1229
  {
1066
1230
    i= (val->sign() ? INT64_MIN : INT64_MAX);
1067
1231
    *err= 1;
1069
1233
  return i;
1070
1234
}
1071
1235
 
1072
 
 
1073
 
/**
1074
 
  Storing decimal in integer fields.
1075
 
 
1076
 
  @param val       value for storing
1077
 
 
1078
 
  @note
1079
 
    This method is used by all integer fields, real/decimal redefine it
1080
 
 
1081
 
  @retval
1082
 
    0     OK
1083
 
  @retval
1084
 
    !=0  error
1085
 
*/
1086
 
 
1087
 
int Field_num::store_decimal(const my_decimal *val)
1088
 
{
1089
 
  int err= 0;
1090
 
  int64_t i= convert_decimal2int64_t(val, unsigned_flag, &err);
1091
 
  return test(err | store(i, unsigned_flag));
1092
 
}
1093
 
 
1094
 
 
1095
 
/**
1096
 
  Return decimal value of integer field.
1097
 
 
1098
 
  @param decimal_value     buffer for storing decimal value
1099
 
 
1100
 
  @note
1101
 
    This method is used by all integer fields, real/decimal redefine it.
1102
 
    All int64_t values fit in our decimal buffer which cal store 8*9=72
1103
 
    digits of integer number
1104
 
 
1105
 
  @return
1106
 
    pointer to decimal buffer with value of field
1107
 
*/
1108
 
 
1109
 
my_decimal* Field_num::val_decimal(my_decimal *decimal_value)
1110
 
{
1111
 
  assert(result_type() == INT_RESULT);
1112
 
  int64_t nr= val_int();
1113
 
  int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
1114
 
  return decimal_value;
1115
 
}
1116
 
 
1117
 
 
1118
 
Field_str::Field_str(uchar *ptr_arg,uint32_t len_arg, uchar *null_ptr_arg,
1119
 
                     uchar null_bit_arg, utype unireg_check_arg,
1120
 
                     const char *field_name_arg, const CHARSET_INFO * const charset_arg)
1121
 
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
1122
 
         unireg_check_arg, field_name_arg)
1123
 
{
1124
 
  field_charset= charset_arg;
1125
 
  if (charset_arg->state & MY_CS_BINSORT)
1126
 
    flags|=BINARY_FLAG;
1127
 
  field_derivation= DERIVATION_IMPLICIT;
1128
 
}
1129
 
 
1130
 
 
1131
 
void Field_num::make_field(Send_field *field)
1132
 
{
1133
 
  Field::make_field(field);
1134
 
  field->decimals= dec;
1135
 
}
1136
 
 
1137
 
/**
1138
 
  Decimal representation of Field_str.
1139
 
 
1140
 
  @param d         value for storing
1141
 
 
1142
 
  @note
1143
 
    Field_str is the base class for fields like Field_enum,
1144
 
    Field_date and some similar. Some dates use fraction and also
1145
 
    string value should be converted to floating point value according
1146
 
    our rules, so we use double to store value of decimal in string.
1147
 
 
1148
 
  @todo
1149
 
    use decimal2string?
1150
 
 
1151
 
  @retval
1152
 
    0     OK
1153
 
  @retval
1154
 
    !=0  error
1155
 
*/
1156
 
 
1157
 
int Field_str::store_decimal(const my_decimal *d)
1158
 
{
1159
 
  double val;
1160
 
  /* TODO: use decimal2string? */
1161
 
  int err= warn_if_overflow(my_decimal2double(E_DEC_FATAL_ERROR &
1162
 
                                            ~E_DEC_OVERFLOW, d, &val));
1163
 
  return err | store(val);
1164
 
}
1165
 
 
1166
 
 
1167
 
my_decimal *Field_str::val_decimal(my_decimal *decimal_value)
1168
 
{
1169
 
  int64_t nr= val_int();
1170
 
  int2my_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value);
1171
 
  return decimal_value;
1172
 
}
1173
 
 
1174
 
 
1175
 
uint Field::fill_cache_field(CACHE_FIELD *copy)
1176
 
{
1177
 
  uint store_length;
 
1236
uint32_t Field::fill_cache_field(CACHE_FIELD *copy)
 
1237
{
 
1238
  uint32_t store_length;
1178
1239
  copy->str=ptr;
1179
1240
  copy->length=pack_length();
1180
1241
  copy->blob_field=0;
1194
1255
}
1195
1256
 
1196
1257
 
1197
 
bool Field::get_date(DRIZZLE_TIME *ltime,uint fuzzydate)
 
1258
bool Field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
1198
1259
{
1199
1260
  char buff[40];
1200
1261
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1222
1283
    Needs to be changed if/when we want to support different time formats.
1223
1284
*/
1224
1285
 
1225
 
int Field::store_time(DRIZZLE_TIME *ltime,
1226
 
                      timestamp_type type_arg __attribute__((unused)))
 
1286
int Field::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
1227
1287
{
1228
1288
  char buff[MAX_DATE_STRING_REP_LENGTH];
1229
 
  uint length= (uint) my_TIME_to_str(ltime, buff);
 
1289
  uint32_t length= (uint32_t) my_TIME_to_str(ltime, buff);
1230
1290
  return store(buff, length, &my_charset_bin);
1231
1291
}
1232
1292
 
1233
1293
 
1234
 
bool Field::optimize_range(uint idx, uint part)
 
1294
bool Field::optimize_range(uint32_t idx, uint32_t part)
1235
1295
{
1236
1296
  return test(table->file->index_flags(idx, part, 1) & HA_READ_RANGE);
1237
1297
}
1238
1298
 
1239
1299
 
1240
 
Field *Field::new_field(MEM_ROOT *root, struct st_table *new_table,
1241
 
                        bool keep_type __attribute__((unused)))
 
1300
Field *Field::new_field(MEM_ROOT *root, Table *new_table, bool)
1242
1301
{
1243
1302
  Field *tmp;
1244
1303
  if (!(tmp= (Field*) memdup_root(root,(char*) this,size_of())))
1257
1316
}
1258
1317
 
1259
1318
 
1260
 
Field *Field::new_key_field(MEM_ROOT *root, struct st_table *new_table,
1261
 
                            uchar *new_ptr, uchar *new_null_ptr,
1262
 
                            uint new_null_bit)
 
1319
Field *Field::new_key_field(MEM_ROOT *root, Table *new_table,
 
1320
                            unsigned char *new_ptr, unsigned char *new_null_ptr,
 
1321
                            uint32_t new_null_bit)
1263
1322
{
1264
1323
  Field *tmp;
1265
1324
  if ((tmp= new_field(root, new_table, table == new_table)))
1272
1331
}
1273
1332
 
1274
1333
 
1275
 
/* 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 */
1276
1335
 
1277
 
Field *Field::clone(MEM_ROOT *root, struct st_table *new_table)
 
1336
Field *Field::clone(MEM_ROOT *root, Table *new_table)
1278
1337
{
1279
1338
  Field *tmp;
1280
1339
  if ((tmp= (Field*) memdup_root(root,(char*) this,size_of())))
1287
1346
}
1288
1347
 
1289
1348
 
1290
 
/****************************************************************************
1291
 
** tiny int
1292
 
****************************************************************************/
1293
 
 
1294
 
int Field_tiny::store(const char *from,uint len, const CHARSET_INFO * const cs)
1295
 
{
1296
 
  int error;
1297
 
  int64_t rnd;
1298
 
  
1299
 
  error= get_int(cs, from, len, &rnd, 255, -128, 127);
1300
 
  ptr[0]= unsigned_flag ? (char) (uint64_t) rnd : (char) rnd;
1301
 
  return error;
1302
 
}
1303
 
 
1304
 
 
1305
 
int Field_tiny::store(double nr)
1306
 
{
1307
 
  int error= 0;
1308
 
  nr=rint(nr);
1309
 
  if (unsigned_flag)
1310
 
  {
1311
 
    if (nr < 0.0)
1312
 
    {
1313
 
      *ptr=0;
1314
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1315
 
      error= 1;
1316
 
    }
1317
 
    else if (nr > 255.0)
1318
 
    {
1319
 
      *ptr=(char) 255;
1320
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1321
 
      error= 1;
1322
 
    }
1323
 
    else
1324
 
      *ptr=(char) nr;
1325
 
  }
1326
 
  else
1327
 
  {
1328
 
    if (nr < -128.0)
1329
 
    {
1330
 
      *ptr= (char) -128;
1331
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1332
 
      error= 1;
1333
 
    }
1334
 
    else if (nr > 127.0)
1335
 
    {
1336
 
      *ptr=127;
1337
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1338
 
      error= 1;
1339
 
    }
1340
 
    else
1341
 
      *ptr=(char) (int) nr;
1342
 
  }
1343
 
  return error;
1344
 
}
1345
 
 
1346
 
 
1347
 
int Field_tiny::store(int64_t nr, bool unsigned_val)
1348
 
{
1349
 
  int error= 0;
1350
 
 
1351
 
  if (unsigned_flag)
1352
 
  {
1353
 
    if (nr < 0 && !unsigned_val)
1354
 
    {
1355
 
      *ptr= 0;
1356
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1357
 
      error= 1;
1358
 
    }
1359
 
    else if ((uint64_t) nr > (uint64_t) 255)
1360
 
    {
1361
 
      *ptr= (char) 255;
1362
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1363
 
      error= 1;
1364
 
    }
1365
 
    else
1366
 
      *ptr=(char) nr;
1367
 
  }
1368
 
  else
1369
 
  {
1370
 
    if (nr < 0 && unsigned_val)
1371
 
      nr= 256;                                    // Generate overflow
1372
 
    if (nr < -128)
1373
 
    {
1374
 
      *ptr= (char) -128;
1375
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1376
 
      error= 1;
1377
 
    }
1378
 
    else if (nr > 127)
1379
 
    {
1380
 
      *ptr=127;
1381
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
1382
 
      error= 1;
1383
 
    }
1384
 
    else
1385
 
      *ptr=(char) nr;
1386
 
  }
1387
 
  return error;
1388
 
}
1389
 
 
1390
 
 
1391
 
double Field_tiny::val_real(void)
1392
 
{
1393
 
  int tmp= unsigned_flag ? (int) ptr[0] :
1394
 
    (int) ((signed char*) ptr)[0];
1395
 
  return (double) tmp;
1396
 
}
1397
 
 
1398
 
 
1399
 
int64_t Field_tiny::val_int(void)
1400
 
{
1401
 
  int tmp= unsigned_flag ? (int) ptr[0] :
1402
 
    (int) ((signed char*) ptr)[0];
1403
 
  return (int64_t) tmp;
1404
 
}
1405
 
 
1406
 
 
1407
 
String *Field_tiny::val_str(String *val_buffer,
1408
 
                            String *val_ptr __attribute__((unused)))
1409
 
{
1410
 
  const CHARSET_INFO * const cs= &my_charset_bin;
1411
 
  uint length;
1412
 
  uint mlength=max(field_length+1,5*cs->mbmaxlen);
1413
 
  val_buffer->alloc(mlength);
1414
 
  char *to=(char*) val_buffer->ptr();
1415
 
 
1416
 
  if (unsigned_flag)
1417
 
    length= (uint) cs->cset->long10_to_str(cs,to,mlength, 10,
1418
 
                                           (long) *ptr);
1419
 
  else
1420
 
    length= (uint) cs->cset->long10_to_str(cs,to,mlength,-10,
1421
 
                                           (long) *((signed char*) ptr));
1422
 
  
1423
 
  val_buffer->length(length);
1424
 
 
1425
 
  return val_buffer;
1426
 
}
1427
 
 
1428
 
bool Field_tiny::send_binary(Protocol *protocol)
1429
 
{
1430
 
  return protocol->store_tiny((int64_t) (int8_t) ptr[0]);
1431
 
}
1432
 
 
1433
 
int Field_tiny::cmp(const uchar *a_ptr, const uchar *b_ptr)
1434
 
{
1435
 
  signed char a,b;
1436
 
  a=(signed char) a_ptr[0]; b= (signed char) b_ptr[0];
1437
 
  if (unsigned_flag)
1438
 
    return ((uchar) a < (uchar) b) ? -1 : ((uchar) a > (uchar) b) ? 1 : 0;
1439
 
  return (a < b) ? -1 : (a > b) ? 1 : 0;
1440
 
}
1441
 
 
1442
 
void Field_tiny::sort_string(uchar *to,uint length __attribute__((unused)))
1443
 
{
1444
 
  if (unsigned_flag)
1445
 
    *to= *ptr;
1446
 
  else
1447
 
    to[0] = (char) (ptr[0] ^ (uchar) 128);      /* Revers signbit */
1448
 
}
1449
 
 
1450
 
void Field_tiny::sql_type(String &res) const
1451
 
{
1452
 
  const CHARSET_INFO * const cs=res.charset();
1453
 
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(),
1454
 
                          "tinyint(%d)",(int) field_length));
1455
 
  add_unsigned(res);
1456
 
}
1457
 
 
1458
 
 
1459
 
/*
1460
 
  Report "not well formed" or "cannot convert" error
1461
 
  after storing a character string info a field.
1462
 
 
1463
 
  SYNOPSIS
1464
 
    check_string_copy_error()
1465
 
    field                    - Field
1466
 
    well_formed_error_pos    - where not well formed data was first met
1467
 
    cannot_convert_error_pos - where a not-convertable character was first met
1468
 
    end                      - end of the string
1469
 
    cs                       - character set of the string
1470
 
 
1471
 
  NOTES
1472
 
    As of version 5.0 both cases return the same error:
1473
 
  
1474
 
      "Invalid string value: 'xxx' for column 't' at row 1"
1475
 
  
1476
 
  Future versions will possibly introduce a new error message:
1477
 
 
1478
 
      "Cannot convert character string: 'xxx' for column 't' at row 1"
1479
 
 
1480
 
  RETURN
1481
 
    false - If errors didn't happen
1482
 
    true  - If an error happened
1483
 
*/
1484
 
 
1485
 
bool
1486
 
check_string_copy_error(Field_str *field,
1487
 
                        const char *well_formed_error_pos,
1488
 
                        const char *cannot_convert_error_pos,
1489
 
                        const char *end,
1490
 
                        const CHARSET_INFO * const cs)
1491
 
{
1492
 
  const char *pos, *end_orig;
1493
 
  char tmp[64], *t;
1494
 
  
1495
 
  if (!(pos= well_formed_error_pos) &&
1496
 
      !(pos= cannot_convert_error_pos))
1497
 
    return false;
1498
 
 
1499
 
  end_orig= end;
1500
 
  set_if_smaller(end, pos + 6);
1501
 
 
1502
 
  for (t= tmp; pos < end; pos++)
1503
 
  {
1504
 
    /*
1505
 
      If the source string is ASCII compatible (mbminlen==1)
1506
 
      and the source character is in ASCII printable range (0x20..0x7F),
1507
 
      then display the character as is.
1508
 
      
1509
 
      Otherwise, if the source string is not ASCII compatible (e.g. UCS2),
1510
 
      or the source character is not in the printable range,
1511
 
      then print the character using HEX notation.
1512
 
    */
1513
 
    if (((unsigned char) *pos) >= 0x20 &&
1514
 
        ((unsigned char) *pos) <= 0x7F &&
1515
 
        cs->mbminlen == 1)
1516
 
    {
1517
 
      *t++= *pos;
1518
 
    }
1519
 
    else
1520
 
    {
1521
 
      *t++= '\\';
1522
 
      *t++= 'x';
1523
 
      *t++= _dig_vec_upper[((unsigned char) *pos) >> 4];
1524
 
      *t++= _dig_vec_upper[((unsigned char) *pos) & 15];
1525
 
    }
1526
 
  }
1527
 
  if (end_orig > end)
1528
 
  {
1529
 
    *t++= '.';
1530
 
    *t++= '.';
1531
 
    *t++= '.';
1532
 
  }
1533
 
  *t= '\0';
1534
 
  push_warning_printf(field->table->in_use, 
1535
 
                      field->table->in_use->abort_on_warning ?
1536
 
                      DRIZZLE_ERROR::WARN_LEVEL_ERROR :
1537
 
                      DRIZZLE_ERROR::WARN_LEVEL_WARN,
1538
 
                      ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, 
1539
 
                      ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
1540
 
                      "string", tmp, field->field_name,
1541
 
                      (uint32_t) field->table->in_use->row_count);
1542
 
  return true;
1543
 
}
1544
 
 
1545
 
 
1546
 
/*
1547
 
  Check if we lost any important data and send a truncation error/warning
1548
 
 
1549
 
  SYNOPSIS
1550
 
    Field_longstr::report_if_important_data()
1551
 
    ptr                      - Truncated rest of string
1552
 
    end                      - End of truncated string
1553
 
 
1554
 
  RETURN VALUES
1555
 
    0   - None was truncated (or we don't count cut fields)
1556
 
    2   - Some bytes was truncated
1557
 
 
1558
 
  NOTE
1559
 
    Check if we lost any important data (anything in a binary string,
1560
 
    or any non-space in others). If only trailing spaces was lost,
1561
 
    send a truncation note, otherwise send a truncation error.
1562
 
*/
1563
 
 
1564
 
int
1565
 
Field_longstr::report_if_important_data(const char *ptr, const char *end)
1566
 
{
1567
 
  if ((ptr < end) && table->in_use->count_cuted_fields)
1568
 
  {
1569
 
    if (test_if_important_data(field_charset, ptr, end))
1570
 
    {
1571
 
      if (table->in_use->abort_on_warning)
1572
 
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
1573
 
      else
1574
 
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
1575
 
    }
1576
 
    else /* If we lost only spaces then produce a NOTE, not a WARNING */
1577
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_NOTE, ER_WARN_DATA_TRUNCATED, 1);
1578
 
    return 2;
1579
 
  }
1580
 
  return 0;
1581
 
}
1582
 
 
1583
 
 
1584
 
/**
1585
 
  Store double value in Field_varstring.
1586
 
 
1587
 
  Pretty prints double number into field_length characters buffer.
1588
 
 
1589
 
  @param nr            number
1590
 
*/
1591
 
 
1592
 
int Field_str::store(double nr)
1593
 
{
1594
 
  char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
1595
 
  uint local_char_length= field_length / charset()->mbmaxlen;
1596
 
  size_t length;
1597
 
  bool error;
1598
 
 
1599
 
  length= my_gcvt(nr, MY_GCVT_ARG_DOUBLE, local_char_length, buff, &error);
1600
 
  if (error)
1601
 
  {
1602
 
    if (table->in_use->abort_on_warning)
1603
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
1604
 
    else
1605
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
1606
 
  }
1607
 
  return store(buff, length, charset());
1608
 
}
1609
 
 
1610
 
 
1611
 
uint Field::is_equal(Create_field *new_field)
 
1349
uint32_t Field::is_equal(Create_field *new_field)
1612
1350
{
1613
1351
  return (new_field->sql_type == real_type());
1614
1352
}
1615
1353
 
1616
 
 
1617
 
/* If one of the fields is binary and the other one isn't return 1 else 0 */
1618
 
 
1619
 
bool Field_str::compare_str_field_flags(Create_field *new_field, uint32_t flag_arg)
1620
 
{
1621
 
  return (((new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
1622
 
          !(flag_arg & (BINCMP_FLAG | BINARY_FLAG))) ||
1623
 
         (!(new_field->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
1624
 
          (flag_arg & (BINCMP_FLAG | BINARY_FLAG))));
1625
 
}
1626
 
 
1627
 
 
1628
 
uint Field_str::is_equal(Create_field *new_field)
1629
 
{
1630
 
  if (compare_str_field_flags(new_field, flags))
1631
 
    return 0;
1632
 
 
1633
 
  return ((new_field->sql_type == real_type()) &&
1634
 
          new_field->charset == field_charset &&
1635
 
          new_field->length == max_display_length());
1636
 
}
1637
 
 
1638
 
 
1639
 
int Field_longstr::store_decimal(const my_decimal *d)
1640
 
{
1641
 
  char buff[DECIMAL_MAX_STR_LENGTH+1];
1642
 
  String str(buff, sizeof(buff), &my_charset_bin);
1643
 
  my_decimal2string(E_DEC_FATAL_ERROR, d, 0, 0, 0, &str);
1644
 
  return store(str.ptr(), str.length(), str.charset());
1645
 
}
1646
 
 
1647
 
uint32_t Field_longstr::max_data_length() const
1648
 
{
1649
 
  return field_length + (field_length > 255 ? 2 : 1);
1650
 
}
1651
 
 
1652
 
 
1653
 
/****************************************************************************
1654
 
** enum type.
1655
 
** This is a string which only can have a selection of different values.
1656
 
** If one uses this string in a number context one gets the type number.
1657
 
****************************************************************************/
1658
 
 
1659
 
enum ha_base_keytype Field_enum::key_type() const
1660
 
{
1661
 
  switch (packlength) {
1662
 
  default: return HA_KEYTYPE_BINARY;
1663
 
  case 2: return HA_KEYTYPE_USHORT_INT;
1664
 
  case 3: return HA_KEYTYPE_UINT24;
1665
 
  case 4: return HA_KEYTYPE_ULONG_INT;
1666
 
  case 8: return HA_KEYTYPE_ULONGLONG;
1667
 
  }
1668
 
}
1669
 
 
1670
 
void Field_enum::store_type(uint64_t value)
1671
 
{
1672
 
  switch (packlength) {
1673
 
  case 1: ptr[0]= (uchar) value;  break;
1674
 
  case 2:
1675
 
#ifdef WORDS_BIGENDIAN
1676
 
  if (table->s->db_low_byte_first)
1677
 
  {
1678
 
    int2store(ptr,(unsigned short) value);
1679
 
  }
1680
 
  else
1681
 
#endif
1682
 
    shortstore(ptr,(unsigned short) value);
1683
 
  break;
1684
 
  case 3: int3store(ptr,(long) value); break;
1685
 
  case 4:
1686
 
#ifdef WORDS_BIGENDIAN
1687
 
  if (table->s->db_low_byte_first)
1688
 
  {
1689
 
    int4store(ptr,value);
1690
 
  }
1691
 
  else
1692
 
#endif
1693
 
    longstore(ptr,(long) value);
1694
 
  break;
1695
 
  case 8:
1696
 
#ifdef WORDS_BIGENDIAN
1697
 
  if (table->s->db_low_byte_first)
1698
 
  {
1699
 
    int8store(ptr,value);
1700
 
  }
1701
 
  else
1702
 
#endif
1703
 
    int64_tstore(ptr,value); break;
1704
 
  }
1705
 
}
1706
 
 
1707
 
 
1708
 
/**
1709
 
  @note
1710
 
    Storing a empty string in a enum field gives a warning
1711
 
    (if there isn't a empty value in the enum)
1712
 
*/
1713
 
 
1714
 
int Field_enum::store(const char *from, uint length, const CHARSET_INFO * const cs)
1715
 
{
1716
 
  int err= 0;
1717
 
  uint32_t not_used;
1718
 
  char buff[STRING_BUFFER_USUAL_SIZE];
1719
 
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
1720
 
 
1721
 
  /* Convert character set if necessary */
1722
 
  if (String::needs_conversion(length, cs, field_charset, &not_used))
1723
 
  { 
1724
 
    uint dummy_errors;
1725
 
    tmpstr.copy(from, length, cs, field_charset, &dummy_errors);
1726
 
    from= tmpstr.ptr();
1727
 
    length=  tmpstr.length();
1728
 
  }
1729
 
 
1730
 
  /* Remove end space */
1731
 
  length= field_charset->cset->lengthsp(field_charset, from, length);
1732
 
  uint tmp=find_type2(typelib, from, length, field_charset);
1733
 
  if (!tmp)
1734
 
  {
1735
 
    if (length < 6) // Can't be more than 99999 enums
1736
 
    {
1737
 
      /* This is for reading numbers with LOAD DATA INFILE */
1738
 
      char *end;
1739
 
      tmp=(uint) my_strntoul(cs,from,length,10,&end,&err);
1740
 
      if (err || end != from+length || tmp > typelib->count)
1741
 
      {
1742
 
        tmp=0;
1743
 
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
1744
 
      }
1745
 
      if (!table->in_use->count_cuted_fields)
1746
 
        err= 0;
1747
 
    }
1748
 
    else
1749
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
1750
 
  }
1751
 
  store_type((uint64_t) tmp);
1752
 
  return err;
1753
 
}
1754
 
 
1755
 
 
1756
 
int Field_enum::store(double nr)
1757
 
{
1758
 
  return Field_enum::store((int64_t) nr, false);
1759
 
}
1760
 
 
1761
 
 
1762
 
int Field_enum::store(int64_t nr,
1763
 
                      bool unsigned_val __attribute__((unused)))
1764
 
{
1765
 
  int error= 0;
1766
 
  if ((uint64_t) nr > typelib->count || nr == 0)
1767
 
  {
1768
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
1769
 
    if (nr != 0 || table->in_use->count_cuted_fields)
1770
 
    {
1771
 
      nr= 0;
1772
 
      error= 1;
1773
 
    }
1774
 
  }
1775
 
  store_type((uint64_t) (uint) nr);
1776
 
  return error;
1777
 
}
1778
 
 
1779
 
 
1780
 
double Field_enum::val_real(void)
1781
 
{
1782
 
  return (double) Field_enum::val_int();
1783
 
}
1784
 
 
1785
 
 
1786
 
int64_t Field_enum::val_int(void)
1787
 
{
1788
 
  switch (packlength) {
1789
 
  case 1:
1790
 
    return (int64_t) ptr[0];
1791
 
  case 2:
1792
 
  {
1793
 
    uint16_t tmp;
1794
 
#ifdef WORDS_BIGENDIAN
1795
 
    if (table->s->db_low_byte_first)
1796
 
      tmp=sint2korr(ptr);
1797
 
    else
1798
 
#endif
1799
 
      shortget(tmp,ptr);
1800
 
    return (int64_t) tmp;
1801
 
  }
1802
 
  case 3:
1803
 
    return (int64_t) uint3korr(ptr);
1804
 
  case 4:
1805
 
  {
1806
 
    uint32_t tmp;
1807
 
#ifdef WORDS_BIGENDIAN
1808
 
    if (table->s->db_low_byte_first)
1809
 
      tmp=uint4korr(ptr);
1810
 
    else
1811
 
#endif
1812
 
      longget(tmp,ptr);
1813
 
    return (int64_t) tmp;
1814
 
  }
1815
 
  case 8:
1816
 
  {
1817
 
    int64_t tmp;
1818
 
#ifdef WORDS_BIGENDIAN
1819
 
    if (table->s->db_low_byte_first)
1820
 
      tmp=sint8korr(ptr);
1821
 
    else
1822
 
#endif
1823
 
      int64_tget(tmp,ptr);
1824
 
    return tmp;
1825
 
  }
1826
 
  }
1827
 
  return 0;                                     // impossible
1828
 
}
1829
 
 
1830
 
 
1831
 
/**
1832
 
   Save the field metadata for enum fields.
1833
 
 
1834
 
   Saves the real type in the first byte and the pack length in the 
1835
 
   second byte of the field metadata array at index of *metadata_ptr and
1836
 
   *(metadata_ptr + 1).
1837
 
 
1838
 
   @param   metadata_ptr   First byte of field metadata
1839
 
 
1840
 
   @returns number of bytes written to metadata_ptr
1841
 
*/
1842
 
int Field_enum::do_save_field_metadata(uchar *metadata_ptr)
1843
 
{
1844
 
  *metadata_ptr= real_type();
1845
 
  *(metadata_ptr + 1)= pack_length();
1846
 
  return 2;
1847
 
}
1848
 
 
1849
 
 
1850
 
String *Field_enum::val_str(String *val_buffer __attribute__((unused)),
1851
 
                            String *val_ptr)
1852
 
{
1853
 
  uint tmp=(uint) Field_enum::val_int();
1854
 
  if (!tmp || tmp > typelib->count)
1855
 
    val_ptr->set("", 0, field_charset);
1856
 
  else
1857
 
    val_ptr->set((const char*) typelib->type_names[tmp-1],
1858
 
                 typelib->type_lengths[tmp-1],
1859
 
                 field_charset);
1860
 
  return val_ptr;
1861
 
}
1862
 
 
1863
 
int Field_enum::cmp(const uchar *a_ptr, const uchar *b_ptr)
1864
 
{
1865
 
  uchar *old= ptr;
1866
 
  ptr= (uchar*) a_ptr;
1867
 
  uint64_t a=Field_enum::val_int();
1868
 
  ptr= (uchar*) b_ptr;
1869
 
  uint64_t b=Field_enum::val_int();
1870
 
  ptr= old;
1871
 
  return (a < b) ? -1 : (a > b) ? 1 : 0;
1872
 
}
1873
 
 
1874
 
void Field_enum::sort_string(uchar *to,uint length __attribute__((unused)))
1875
 
{
1876
 
  uint64_t value=Field_enum::val_int();
1877
 
  to+=packlength-1;
1878
 
  for (uint i=0 ; i < packlength ; i++)
1879
 
  {
1880
 
    *to-- = (uchar) (value & 255);
1881
 
    value>>=8;
1882
 
  }
1883
 
}
1884
 
 
1885
 
 
1886
 
void Field_enum::sql_type(String &res) const
1887
 
{
1888
 
  char buffer[255];
1889
 
  String enum_item(buffer, sizeof(buffer), res.charset());
1890
 
 
1891
 
  res.length(0);
1892
 
  res.append(STRING_WITH_LEN("enum("));
1893
 
 
1894
 
  bool flag=0;
1895
 
  uint *len= typelib->type_lengths;
1896
 
  for (const char **pos= typelib->type_names; *pos; pos++, len++)
1897
 
  {
1898
 
    uint dummy_errors;
1899
 
    if (flag)
1900
 
      res.append(',');
1901
 
    /* convert to res.charset() == utf8, then quote */
1902
 
    enum_item.copy(*pos, *len, charset(), res.charset(), &dummy_errors);
1903
 
    append_unescaped(&res, enum_item.ptr(), enum_item.length());
1904
 
    flag= 1;
1905
 
  }
1906
 
  res.append(')');
1907
 
}
1908
 
 
1909
 
 
1910
 
Field *Field_enum::new_field(MEM_ROOT *root, struct st_table *new_table,
1911
 
                             bool keep_type)
1912
 
{
1913
 
  Field_enum *res= (Field_enum*) Field::new_field(root, new_table, keep_type);
1914
 
  if (res)
1915
 
    res->typelib= copy_typelib(root, typelib);
1916
 
  return res;
1917
 
}
1918
 
 
1919
 
 
1920
1354
/**
1921
1355
  @retval
1922
1356
    1  if the fields are equally defined
1944
1378
 
1945
1379
  if (typelib->count < from_lib->count)
1946
1380
    return 0;
1947
 
  for (uint i=0 ; i < from_lib->count ; i++)
 
1381
  for (uint32_t i=0 ; i < from_lib->count ; i++)
1948
1382
    if (my_strnncoll(field_charset,
1949
 
                     (const uchar*)typelib->type_names[i],
 
1383
                     (const unsigned char*)typelib->type_names[i],
1950
1384
                     strlen(typelib->type_names[i]),
1951
 
                     (const uchar*)from_lib->type_names[i],
 
1385
                     (const unsigned char*)from_lib->type_names[i],
1952
1386
                     strlen(from_lib->type_names[i])))
1953
1387
      return 0;
1954
1388
  return 1;
1955
1389
}
1956
1390
 
1957
 
/**
1958
 
  @return
1959
 
  returns 1 if the fields are equally defined
1960
 
*/
1961
 
bool Field_num::eq_def(Field *field)
1962
 
{
1963
 
  if (!Field::eq_def(field))
1964
 
    return 0;
1965
 
  Field_num *from_num= (Field_num*) field;
1966
 
 
1967
 
  if (unsigned_flag != from_num->unsigned_flag ||
1968
 
      dec != from_num->dec)
1969
 
    return 0;
1970
 
  return 1;
1971
 
}
1972
 
 
1973
 
 
1974
 
uint Field_num::is_equal(Create_field *new_field)
1975
 
{
1976
 
  return ((new_field->sql_type == real_type()) &&
1977
 
          ((new_field->flags & UNSIGNED_FLAG) == (uint) (flags &
1978
 
                                                         UNSIGNED_FLAG)) &&
1979
 
          ((new_field->flags & AUTO_INCREMENT_FLAG) ==
1980
 
           (uint) (flags & AUTO_INCREMENT_FLAG)) &&
1981
 
          (new_field->length <= max_display_length()));
1982
 
}
1983
 
 
1984
 
 
1985
1391
/*****************************************************************************
1986
1392
  Handling of field and Create_field
1987
1393
*****************************************************************************/
2036
1442
              ((decimals_arg & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
2037
1443
              (maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
2038
1444
              (is_unsigned ? 0 : FIELDFLAG_DECIMAL));
 
1445
  vcol_info= NULL;
 
1446
  is_stored= true;
2039
1447
}
2040
1448
 
2041
1449
 
2042
1450
/**
2043
1451
  Initialize field definition for create.
2044
1452
 
2045
 
  @param thd                   Thread handle
 
1453
  @param session                   Thread handle
2046
1454
  @param fld_name              Field name
2047
1455
  @param fld_type              Field type
2048
1456
  @param fld_length            Field length
2054
1462
  @param fld_change            Field change
2055
1463
  @param fld_interval_list     Interval list (if any)
2056
1464
  @param fld_charset           Field charset
 
1465
  @param fld_vcol_info         Virtual column data
2057
1466
 
2058
1467
  @retval
2059
1468
    false on success
2061
1470
    true  on error
2062
1471
*/
2063
1472
 
2064
 
bool Create_field::init(THD *thd, char *fld_name, enum_field_types fld_type,
 
1473
bool Create_field::init(Session *, char *fld_name, enum_field_types fld_type,
2065
1474
                        char *fld_length, char *fld_decimals,
2066
 
                        uint fld_type_modifier, Item *fld_default_value,
 
1475
                        uint32_t fld_type_modifier, Item *fld_default_value,
2067
1476
                        Item *fld_on_update_value, LEX_STRING *fld_comment,
2068
1477
                        char *fld_change, List<String> *fld_interval_list,
2069
1478
                        const CHARSET_INFO * const fld_charset,
2070
 
                        uint fld_geom_type __attribute__((unused)),
2071
 
                        enum column_format_type column_format)
 
1479
                        uint32_t, enum column_format_type column_format,
 
1480
                        virtual_column_info *fld_vcol_info)
2072
1481
{
2073
 
  uint sign_len, allowed_type_modifier= 0;
 
1482
  uint32_t sign_len, allowed_type_modifier= 0;
2074
1483
  uint32_t max_field_charlength= MAX_FIELD_CHARLENGTH;
2075
1484
 
2076
1485
  field= 0;
2077
1486
  field_name= fld_name;
2078
1487
  def= fld_default_value;
2079
1488
  flags= fld_type_modifier;
2080
 
  flags|= (((uint)column_format & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
 
1489
  flags|= (((uint32_t)column_format & COLUMN_FORMAT_MASK) << COLUMN_FORMAT_FLAGS);
2081
1490
  unireg_check= (fld_type_modifier & AUTO_INCREMENT_FLAG ?
2082
1491
                 Field::NEXT_NUMBER : Field::NONE);
2083
 
  decimals= fld_decimals ? (uint)atoi(fld_decimals) : 0;
 
1492
  decimals= fld_decimals ? (uint32_t)atoi(fld_decimals) : 0;
2084
1493
  if (decimals >= NOT_FIXED_DEC)
2085
1494
  {
2086
1495
    my_error(ER_TOO_BIG_SCALE, MYF(0), decimals, fld_name,
2097
1506
  interval_list.empty();
2098
1507
 
2099
1508
  comment= *fld_comment;
 
1509
  vcol_info= fld_vcol_info;
 
1510
  is_stored= true;
 
1511
 
 
1512
  /* Initialize data for a virtual field */
 
1513
  if (fld_type == DRIZZLE_TYPE_VIRTUAL)
 
1514
  {
 
1515
    assert(vcol_info && vcol_info->expr_item);
 
1516
    is_stored= vcol_info->get_field_stored();
 
1517
    /*
 
1518
      Perform per item-type checks to determine if the expression is
 
1519
      allowed for a virtual column.
 
1520
      Note that validation of the specific function is done later in
 
1521
      procedures open_table_from_share and fix_fields_vcol_func
 
1522
    */
 
1523
    switch (vcol_info->expr_item->type()) {
 
1524
    case Item::FUNC_ITEM:
 
1525
         if (((Item_func *)vcol_info->expr_item)->functype() == Item_func::FUNC_SP)
 
1526
         {
 
1527
           my_error(ER_VIRTUAL_COLUMN_FUNCTION_IS_NOT_ALLOWED, MYF(0), field_name);
 
1528
           return(true);
 
1529
         }
 
1530
         break;
 
1531
    case Item::COPY_STR_ITEM:
 
1532
    case Item::FIELD_AVG_ITEM:
 
1533
    case Item::PROC_ITEM:
 
1534
    case Item::REF_ITEM:
 
1535
    case Item::FIELD_STD_ITEM:
 
1536
    case Item::FIELD_VARIANCE_ITEM:
 
1537
    case Item::INSERT_VALUE_ITEM:
 
1538
    case Item::SUBSELECT_ITEM:
 
1539
    case Item::CACHE_ITEM:
 
1540
    case Item::TYPE_HOLDER:
 
1541
    case Item::PARAM_ITEM:
 
1542
         my_error(ER_VIRTUAL_COLUMN_FUNCTION_IS_NOT_ALLOWED, MYF(0), field_name);
 
1543
         return true;
 
1544
         break;
 
1545
    default:
 
1546
      // Continue with the field creation
 
1547
      break;
 
1548
    }
 
1549
    /*
 
1550
      Make a field created for the real type.
 
1551
      Note that "real" and virtual fields differ from each other
 
1552
      only by Field::vcol_info, which is always 0 for normal columns.
 
1553
      vcol_info is updated for fields later in procedure open_binary_frm.
 
1554
    */
 
1555
    sql_type= fld_type= vcol_info->get_real_type();
 
1556
  }
 
1557
 
2100
1558
  /*
2101
1559
    Set NO_DEFAULT_VALUE_FLAG if this field doesn't have a default value and
2102
1560
    it is NOT NULL, not an AUTO_INCREMENT field and not a TIMESTAMP.
2105
1563
      (fld_type_modifier & NOT_NULL_FLAG) && fld_type != DRIZZLE_TYPE_TIMESTAMP)
2106
1564
    flags|= NO_DEFAULT_VALUE_FLAG;
2107
1565
 
2108
 
  if (fld_length && !(length= (uint) atoi(fld_length)))
 
1566
  if (fld_length && !(length= (uint32_t) atoi(fld_length)))
2109
1567
    fld_length= 0; /* purecov: inspected */
2110
1568
  sign_len= fld_type_modifier & UNSIGNED_FLAG ? 0 : 1;
2111
1569
 
2115
1573
      length= MAX_TINYINT_WIDTH+sign_len;
2116
1574
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
2117
1575
    break;
2118
 
  case DRIZZLE_TYPE_SHORT:
2119
 
    if (!fld_length)
2120
 
      length= MAX_SMALLINT_WIDTH+sign_len;
2121
 
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
2122
 
    break;
2123
1576
  case DRIZZLE_TYPE_LONG:
2124
1577
    if (!fld_length)
2125
1578
      length= MAX_INT_WIDTH+sign_len;
2164
1617
      /* Allow empty as default value. */
2165
1618
      String str,*res;
2166
1619
      res= fld_default_value->val_str(&str);
2167
 
      /*
2168
 
        A default other than '' is always an error, and any non-NULL
2169
 
        specified default is an error in strict mode.
2170
 
      */
2171
 
      if (res->length() || (thd->variables.sql_mode &
2172
 
                            (MODE_STRICT_TRANS_TABLES |
2173
 
                             MODE_STRICT_ALL_TABLES)))
2174
 
      {
2175
 
        my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
2176
 
                 fld_name); /* purecov: inspected */
2177
 
        return(true);
2178
 
      }
2179
 
      else
2180
 
      {
2181
 
        /*
2182
 
          Otherwise a default of '' is just a warning.
2183
 
        */
2184
 
        push_warning_printf(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
2185
 
                            ER_BLOB_CANT_HAVE_DEFAULT,
2186
 
                            ER(ER_BLOB_CANT_HAVE_DEFAULT),
2187
 
                            fld_name);
2188
 
      }
2189
 
      def= 0;
2190
1620
    }
2191
1621
    flags|= BLOB_FLAG;
2192
1622
    break;
2217
1647
        and 19 as length of 4.1 compatible representation.
2218
1648
      */
2219
1649
      length= ((length+1)/2)*2; /* purecov: inspected */
2220
 
      length= min(length, (uint32_t)MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
 
1650
      length= cmin(length, (uint32_t)MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
2221
1651
    }
2222
1652
    flags|= UNSIGNED_FLAG;
2223
1653
    if (fld_default_value)
2224
1654
    {
2225
1655
      /* Grammar allows only NOW() value for ON UPDATE clause */
2226
 
      if (fld_default_value->type() == Item::FUNC_ITEM && 
 
1656
      if (fld_default_value->type() == Item::FUNC_ITEM &&
2227
1657
          ((Item_func*)fld_default_value)->functype() == Item_func::NOW_FUNC)
2228
1658
      {
2229
1659
        unireg_check= (fld_on_update_value ? Field::TIMESTAMP_DNUN_FIELD:
2259
1689
    }
2260
1690
    break;
2261
1691
  case DRIZZLE_TYPE_DATE:
2262
 
    /* Old date type. */
2263
 
    sql_type= DRIZZLE_TYPE_NEWDATE;
2264
 
    /* fall trough */
2265
 
  case DRIZZLE_TYPE_NEWDATE:
2266
1692
    length= 10;
2267
1693
    break;
2268
1694
  case DRIZZLE_TYPE_TIME:
2283
1709
      length= 1; /* See comment for DRIZZLE_TYPE_SET above. */
2284
1710
      break;
2285
1711
   }
 
1712
  case DRIZZLE_TYPE_VIRTUAL: // Must not happen
 
1713
    assert(0);
2286
1714
  }
2287
1715
  /* Remember the value of length */
2288
1716
  char_length= length;
2309
1737
}
2310
1738
 
2311
1739
 
2312
 
enum_field_types get_blob_type_from_length(uint32_t length __attribute__((unused)))
 
1740
enum_field_types get_blob_type_from_length(uint32_t)
2313
1741
{
2314
1742
  enum_field_types type;
2315
1743
 
2328
1756
  switch (type) {
2329
1757
  case DRIZZLE_TYPE_VARCHAR:     return (length + (length < 256 ? 1: 2));
2330
1758
  case DRIZZLE_TYPE_TINY        : return 1;
2331
 
  case DRIZZLE_TYPE_SHORT : return 2;
2332
1759
  case DRIZZLE_TYPE_DATE:
2333
 
  case DRIZZLE_TYPE_NEWDATE:
2334
1760
  case DRIZZLE_TYPE_TIME:   return 3;
2335
1761
  case DRIZZLE_TYPE_TIMESTAMP:
2336
1762
  case DRIZZLE_TYPE_LONG        : return 4;
2348
1774
}
2349
1775
 
2350
1776
 
2351
 
uint pack_length_to_packflag(uint type)
 
1777
uint32_t pack_length_to_packflag(uint32_t type)
2352
1778
{
2353
1779
  switch (type) {
2354
 
    case 1: return f_settype((uint) DRIZZLE_TYPE_TINY);
2355
 
    case 2: return f_settype((uint) DRIZZLE_TYPE_SHORT);
 
1780
    case 1: return 1 << FIELDFLAG_PACK_SHIFT;
 
1781
    case 2: assert(1);
2356
1782
    case 3: assert(1);
2357
 
    case 4: return f_settype((uint) DRIZZLE_TYPE_LONG);
2358
 
    case 8: return f_settype((uint) DRIZZLE_TYPE_LONGLONG);
 
1783
    case 4: return f_settype((uint32_t) DRIZZLE_TYPE_LONG);
 
1784
    case 8: return f_settype((uint32_t) DRIZZLE_TYPE_LONGLONG);
2359
1785
  }
2360
1786
  return 0;                                     // This shouldn't happen
2361
1787
}
2362
1788
 
2363
1789
 
2364
 
Field *make_field(TABLE_SHARE *share, uchar *ptr, uint32_t field_length,
2365
 
                  uchar *null_pos, uchar null_bit,
2366
 
                  uint pack_flag,
 
1790
Field *make_field(TABLE_SHARE *share, unsigned char *ptr, uint32_t field_length,
 
1791
                  unsigned char *null_pos, unsigned char null_bit,
 
1792
                  uint32_t pack_flag,
2367
1793
                  enum_field_types field_type,
2368
1794
                  const CHARSET_INFO * field_charset,
2369
1795
                  Field::utype unireg_check,
2377
1803
  }
2378
1804
  else
2379
1805
  {
2380
 
    null_bit= ((uchar) 1) << null_bit;
 
1806
    null_bit= ((unsigned char) 1) << null_bit;
2381
1807
  }
2382
1808
 
2383
1809
  switch (field_type) {
2384
1810
  case DRIZZLE_TYPE_DATE:
2385
 
  case DRIZZLE_TYPE_NEWDATE:
2386
1811
  case DRIZZLE_TYPE_TIME:
2387
1812
  case DRIZZLE_TYPE_DATETIME:
2388
1813
  case DRIZZLE_TYPE_TIMESTAMP:
2404
1829
      return 0;                                 // Error
2405
1830
    }
2406
1831
 
2407
 
    uint pack_length=calc_pack_length((enum_field_types)
 
1832
    uint32_t pack_length=calc_pack_length((enum_field_types)
2408
1833
                                      f_packtype(pack_flag),
2409
1834
                                      field_length);
2410
1835
 
2415
1840
    if (interval)
2416
1841
    {
2417
1842
      if (f_is_enum(pack_flag))
 
1843
{
2418
1844
        return new Field_enum(ptr,field_length,null_pos,null_bit,
2419
1845
                                  unireg_check, field_name,
2420
 
                                  pack_length, interval, field_charset);
 
1846
                                  get_enum_pack_length(interval->count),
 
1847
                                  interval, field_charset);
 
1848
}
2421
1849
    }
2422
1850
  }
2423
1851
 
2435
1863
                            false,
2436
1864
                            f_is_dec(pack_flag)== 0);
2437
1865
  case DRIZZLE_TYPE_TINY:
2438
 
    return new Field_tiny(ptr,field_length,null_pos,null_bit,
2439
 
                          unireg_check, field_name,
2440
 
                          false,
2441
 
                          f_is_dec(pack_flag) == 0);
2442
 
  case DRIZZLE_TYPE_SHORT:
2443
 
    return new Field_short(ptr,field_length,null_pos,null_bit,
2444
 
                           unireg_check, field_name,
2445
 
                           false,
2446
 
                           f_is_dec(pack_flag) == 0);
 
1866
    assert(0);
2447
1867
  case DRIZZLE_TYPE_LONG:
2448
1868
    return new Field_long(ptr,field_length,null_pos,null_bit,
2449
1869
                           unireg_check, field_name,
2459
1879
                               unireg_check, field_name, share,
2460
1880
                               field_charset);
2461
1881
  case DRIZZLE_TYPE_DATE:
2462
 
  case DRIZZLE_TYPE_NEWDATE:
2463
 
    return new Field_newdate(ptr,null_pos,null_bit,
 
1882
    return new Field_date(ptr,null_pos,null_bit,
2464
1883
                             unireg_check, field_name, field_charset);
2465
1884
  case DRIZZLE_TYPE_TIME:
2466
1885
    return new Field_time(ptr,null_pos,null_bit,
2471
1890
  case DRIZZLE_TYPE_NULL:
2472
1891
    return new Field_null(ptr, field_length, unireg_check, field_name,
2473
1892
                          field_charset);
 
1893
  case DRIZZLE_TYPE_VIRTUAL:                    // Must not happen
 
1894
    assert(0);
2474
1895
  default:                                      // Impossible (Wrong version)
2475
1896
    break;
2476
1897
  }
2493
1914
  charset=    old_field->charset();             // May be NULL ptr
2494
1915
  comment=    old_field->comment;
2495
1916
  decimals=   old_field->decimals();
 
1917
  vcol_info=  old_field->vcol_info;
 
1918
  is_stored= old_field->is_stored;
2496
1919
 
2497
1920
  /* Fix if the original table had 4 byte pointer blobs */
2498
1921
  if (flags & BLOB_FLAG)
2525
1948
  if (!(flags & (NO_DEFAULT_VALUE_FLAG | BLOB_FLAG)) &&
2526
1949
      old_field->ptr && orig_field &&
2527
1950
      (sql_type != DRIZZLE_TYPE_TIMESTAMP ||                /* set def only if */
2528
 
       old_field->table->timestamp_field != old_field ||  /* timestamp field */ 
 
1951
       old_field->table->timestamp_field != old_field ||  /* timestamp field */
2529
1952
       unireg_check == Field::TIMESTAMP_UN_FIELD))        /* has default val */
2530
1953
  {
2531
1954
    char buff[MAX_FIELD_WIDTH];
2573
1996
    0 otherwise
2574
1997
*/
2575
1998
 
2576
 
bool 
2577
 
Field::set_warning(DRIZZLE_ERROR::enum_warning_level level, uint code,
 
1999
bool
 
2000
Field::set_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code,
2578
2001
                   int cuted_increment)
2579
2002
{
2580
2003
  /*
2581
2004
    If this field was created only for type conversion purposes it
2582
2005
    will have table == NULL.
2583
2006
  */
2584
 
  THD *thd= table ? table->in_use : current_thd;
2585
 
  if (thd->count_cuted_fields)
 
2007
  Session *session= table ? table->in_use : current_session;
 
2008
  if (session->count_cuted_fields)
2586
2009
  {
2587
 
    thd->cuted_fields+= cuted_increment;
2588
 
    push_warning_printf(thd, level, code, ER(code), field_name,
2589
 
                        thd->row_count);
 
2010
    session->cuted_fields+= cuted_increment;
 
2011
    push_warning_printf(session, level, code, ER(code), field_name,
 
2012
                        session->row_count);
2590
2013
    return 0;
2591
2014
  }
2592
2015
  return level >= DRIZZLE_ERROR::WARN_LEVEL_WARN;
2609
2032
    thread.
2610
2033
*/
2611
2034
 
2612
 
void 
2613
 
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, 
2614
 
                            unsigned int code, 
2615
 
                            const char *str, uint str_length, 
2616
 
                            timestamp_type ts_type, int cuted_increment)
 
2035
void
 
2036
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
 
2037
                            unsigned int code,
 
2038
                            const char *str, uint32_t str_length,
 
2039
                            enum enum_drizzle_timestamp_type ts_type, int cuted_increment)
2617
2040
{
2618
 
  THD *thd= table ? table->in_use : current_thd;
2619
 
  if ((thd->really_abort_on_warning() &&
 
2041
  Session *session= table ? table->in_use : current_session;
 
2042
  if ((session->really_abort_on_warning() &&
2620
2043
       level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
2621
2044
      set_warning(level, code, cuted_increment))
2622
 
    make_truncated_value_warning(thd, level, str, str_length, ts_type,
 
2045
    make_truncated_value_warning(session, level, str, str_length, ts_type,
2623
2046
                                 field_name);
2624
2047
}
2625
2048
 
2639
2062
    thread.
2640
2063
*/
2641
2064
 
2642
 
void 
2643
 
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint code, 
2644
 
                            int64_t nr, timestamp_type ts_type,
 
2065
void
 
2066
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint32_t code,
 
2067
                            int64_t nr, enum enum_drizzle_timestamp_type ts_type,
2645
2068
                            int cuted_increment)
2646
2069
{
2647
 
  THD *thd= table ? table->in_use : current_thd;
2648
 
  if (thd->really_abort_on_warning() ||
 
2070
  Session *session= table ? table->in_use : current_session;
 
2071
  if (session->really_abort_on_warning() ||
2649
2072
      set_warning(level, code, cuted_increment))
2650
2073
  {
2651
2074
    char str_nr[22];
2652
2075
    char *str_end= int64_t10_to_str(nr, str_nr, -10);
2653
 
    make_truncated_value_warning(thd, level, str_nr, (uint) (str_end - str_nr), 
 
2076
    make_truncated_value_warning(session, level, str_nr, (uint32_t) (str_end - str_nr),
2654
2077
                                 ts_type, field_name);
2655
2078
  }
2656
2079
}
2670
2093
    thread.
2671
2094
*/
2672
2095
 
2673
 
void 
2674
 
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, uint code, 
2675
 
                            double nr, timestamp_type ts_type)
 
2096
void
 
2097
Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level, const uint32_t code,
 
2098
                            double nr, enum enum_drizzle_timestamp_type ts_type)
2676
2099
{
2677
 
  THD *thd= table ? table->in_use : current_thd;
2678
 
  if (thd->really_abort_on_warning() ||
 
2100
  Session *session= table ? table->in_use : current_session;
 
2101
  if (session->really_abort_on_warning() ||
2679
2102
      set_warning(level, code, 1))
2680
2103
  {
2681
2104
    /* DBL_DIG is enough to print '-[digits].E+###' */
2682
2105
    char str_nr[DBL_DIG + 8];
2683
 
    uint str_len= sprintf(str_nr, "%g", nr);
2684
 
    make_truncated_value_warning(thd, level, str_nr, str_len, ts_type,
 
2106
    uint32_t str_len= sprintf(str_nr, "%g", nr);
 
2107
    make_truncated_value_warning(session, level, str_nr, str_len, ts_type,
2685
2108
                                 field_name);
2686
2109
  }
2687
2110
}
 
2111