← Back to branch summary

~skinny.moey/drizzle/bug755201

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/libdrizzle/column.cc

  • Committer: Lee Bieber
  • Date: 2011-03-23 18:58:39 UTC
  • mfrom: (2246.1.3 build)
  • Revision ID: kalebral@gmail.com-20110323185839-u96hq6u213nexixv
Merge Patrick - Updated dbqp's ld_lib_paths to find the new libdrizzle locations
Merge Monty - Splits out libdrizzle-1.0 and libdrizzle-2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/libdrizzle/column.cc
 
1
/*
 
2
 * Drizzle Client & Protocol Library
 
3
 *
 
4
 * Copyright (C) 2008 Eric Day (eday@oddments.org)
 
5
 * All rights reserved.
 
6
 *
 
7
 * Redistribution and use in source and binary forms, with or without
 
8
 * modification, are permitted provided that the following conditions are
 
9
 * met:
 
10
 *
 
11
 *     * Redistributions of source code must retain the above copyright
 
12
 * notice, this list of conditions and the following disclaimer.
 
13
 *
 
14
 *     * Redistributions in binary form must reproduce the above
 
15
 * copyright notice, this list of conditions and the following disclaimer
 
16
 * in the documentation and/or other materials provided with the
 
17
 * distribution.
 
18
 *
 
19
 *     * The names of its contributors may not be used to endorse or
 
20
 * promote products derived from this software without specific prior
 
21
 * written permission.
 
22
 *
 
23
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
24
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
25
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
26
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
27
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
28
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
29
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
30
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
31
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
32
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
33
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
34
 *
 
35
 */
 
36
 
 
37
 
 
38
/**
 
39
 * @file
 
40
 * @brief Column definitions
 
41
 */
 
42
 
 
43
#include "common.h"
 
44
 
 
45
/*
 
46
 * Private variables.
 
47
 */
 
48
 
 
49
static drizzle_column_type_t _column_type_drizzle_map_to[]=
 
50
{
 
51
 DRIZZLE_COLUMN_TYPE_TINY,
 
52
 DRIZZLE_COLUMN_TYPE_LONG,
 
53
 DRIZZLE_COLUMN_TYPE_DOUBLE,
 
54
 DRIZZLE_COLUMN_TYPE_NULL,
 
55
 DRIZZLE_COLUMN_TYPE_TIMESTAMP,
 
56
 DRIZZLE_COLUMN_TYPE_LONGLONG,
 
57
 DRIZZLE_COLUMN_TYPE_DATETIME,
 
58
 DRIZZLE_COLUMN_TYPE_NEWDATE,
 
59
 DRIZZLE_COLUMN_TYPE_VARCHAR,
 
60
 DRIZZLE_COLUMN_TYPE_NEWDECIMAL,
 
61
 DRIZZLE_COLUMN_TYPE_ENUM,
 
62
 DRIZZLE_COLUMN_TYPE_BLOB
 
63
};
 
64
 
 
65
static drizzle_column_type_drizzle_t _column_type_drizzle_map_from[]=
 
66
{
 
67
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 0 */
 
68
 DRIZZLE_COLUMN_TYPE_DRIZZLE_BOOLEAN,
 
69
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
70
 DRIZZLE_COLUMN_TYPE_DRIZZLE_LONG,
 
71
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
72
 DRIZZLE_COLUMN_TYPE_DRIZZLE_DOUBLE,
 
73
 DRIZZLE_COLUMN_TYPE_DRIZZLE_NULL,
 
74
 DRIZZLE_COLUMN_TYPE_DRIZZLE_TIMESTAMP,
 
75
 DRIZZLE_COLUMN_TYPE_DRIZZLE_LONGLONG,
 
76
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
77
 
 
78
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 10 */
 
79
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
80
 DRIZZLE_COLUMN_TYPE_DRIZZLE_DATETIME,
 
81
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
82
 DRIZZLE_COLUMN_TYPE_DRIZZLE_DATE,
 
83
 DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR,
 
84
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
85
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
86
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
87
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
88
 
 
89
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 20 */
 
90
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
91
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
92
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
93
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
94
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
95
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
96
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
97
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
98
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
99
 
 
100
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 30 */
 
101
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
102
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
103
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
104
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
105
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
106
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
107
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
108
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
109
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
110
 
 
111
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 40 */
 
112
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
113
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
114
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
115
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
116
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
117
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
118
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
119
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
120
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
121
 
 
122
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 50 */
 
123
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
124
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
125
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
126
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
127
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
128
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
129
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
130
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
131
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
132
 
 
133
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 60 */
 
134
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
135
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
136
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
137
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
138
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
139
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
140
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
141
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
142
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
143
 
 
144
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 70 */
 
145
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
146
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
147
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
148
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
149
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
150
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
151
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
152
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
153
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
154
 
 
155
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 80 */
 
156
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
157
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
158
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
159
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
160
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
161
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
162
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
163
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
164
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
165
 
 
166
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 90 */
 
167
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
168
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
169
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
170
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
171
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
172
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
173
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
174
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
175
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
176
 
 
177
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 100 */
 
178
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
179
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
180
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
181
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
182
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
183
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
184
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
185
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
186
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
187
 
 
188
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 110 */
 
189
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
190
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
191
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
192
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
193
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
194
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
195
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
196
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
197
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
198
 
 
199
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 120 */
 
200
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
201
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
202
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
203
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
204
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
205
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
206
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
207
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
208
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
209
 
 
210
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 130 */
 
211
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
212
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
213
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
214
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
215
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
216
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
217
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
218
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
219
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
220
 
 
221
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 140 */
 
222
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
223
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
224
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
225
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
226
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
227
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
228
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
229
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
230
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
231
 
 
232
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 150 */
 
233
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
234
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
235
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
236
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
237
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
238
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
239
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
240
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
241
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
242
 
 
243
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 160 */
 
244
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
245
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
246
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
247
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
248
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
249
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
250
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
251
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
252
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
253
 
 
254
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 170 */
 
255
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
256
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
257
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
258
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
259
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
260
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
261
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
262
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
263
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
264
 
 
265
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 180 */
 
266
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
267
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
268
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
269
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
270
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
271
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
272
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
273
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
274
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
275
 
 
276
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 190 */
 
277
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
278
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
279
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
280
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
281
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
282
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
283
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
284
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
285
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
286
 
 
287
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 200 */
 
288
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
289
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
290
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
291
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
292
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
293
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
294
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
295
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
296
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
297
 
 
298
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 210 */
 
299
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
300
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
301
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
302
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
303
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
304
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
305
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
306
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
307
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
308
 
 
309
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 220 */
 
310
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
311
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
312
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
313
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
314
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
315
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
316
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
317
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
318
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
319
 
 
320
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 230 */
 
321
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
322
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
323
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
324
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
325
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
326
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
327
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
328
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
329
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
330
 
 
331
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 240 */
 
332
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
333
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
334
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
335
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
336
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
337
 DRIZZLE_COLUMN_TYPE_DRIZZLE_NEWDECIMAL,
 
338
 DRIZZLE_COLUMN_TYPE_DRIZZLE_ENUM,
 
339
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
340
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
341
 
 
342
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 250 */
 
343
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
344
 DRIZZLE_COLUMN_TYPE_DRIZZLE_BLOB,
 
345
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
346
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
 
347
 DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX
 
348
};
 
349
 
 
350
/*
 
351
 * Common definitions
 
352
 */
 
353
 
 
354
drizzle_column_st *drizzle_column_create(drizzle_result_st *result,
 
355
                                         drizzle_column_st *column)
 
356
{
 
357
  if (column == NULL)
 
358
  {
 
359
    column= new drizzle_column_st;
 
360
    if (column == NULL)
 
361
    {
 
362
      drizzle_set_error(result->con->drizzle, "drizzle_column_create",
 
363
                        "malloc");
 
364
      return NULL;
 
365
    }
 
366
 
 
367
    column->result = result;
 
368
    /* SET BELOW: column->next */
 
369
    column->prev = NULL;
 
370
    column->options= DRIZZLE_COLUMN_ALLOCATED;
 
371
    column->catalog[0] = '\0';
 
372
    column->db[0] = '\0';
 
373
    column->table[0] = '\0';
 
374
    column->orig_table[0] = '\0';
 
375
    column->name[0] = '\0';
 
376
    column->orig_name[0] = '\0';
 
377
    column->charset = 0;
 
378
    column->size = 0;
 
379
    column->max_size = 0;
 
380
    column->type = static_cast<drizzle_column_type_t>(0);
 
381
    column->flags = 0;
 
382
    column->decimals = 0;
 
383
    /* UNSET: column->default_value */
 
384
    column->default_value_size = 0;
 
385
 
 
386
  }
 
387
  else
 
388
  {
 
389
    column->result = result;
 
390
    /* SET BELOW: column->next */
 
391
    column->prev = NULL;
 
392
    column->options= 0;
 
393
    column->catalog[0] = '\0';
 
394
    column->db[0] = '\0';
 
395
    column->table[0] = '\0';
 
396
    column->orig_table[0] = '\0';
 
397
    column->name[0] = '\0';
 
398
    column->orig_name[0] = '\0';
 
399
    column->charset = 0;
 
400
    column->size = 0;
 
401
    column->max_size = 0;
 
402
    column->type = static_cast<drizzle_column_type_t>(0);
 
403
    column->flags = 0;
 
404
    column->decimals = 0;
 
405
    /* UNSET: column->default_value */
 
406
    column->default_value_size = 0;
 
407
  }
 
408
 
 
409
  column->result= result;
 
410
 
 
411
  if (result->column_list)
 
412
    result->column_list->prev= column;
 
413
  column->next= result->column_list;
 
414
  result->column_list= column;
 
415
 
 
416
  return column;
 
417
}
 
418
 
 
419
void drizzle_column_free(drizzle_column_st *column)
 
420
{
 
421
  if (column->result->column_list == column)
 
422
    column->result->column_list= column->next;
 
423
  if (column->prev)
 
424
    column->prev->next= column->next;
 
425
  if (column->next)
 
426
    column->next->prev= column->prev;
 
427
 
 
428
  if (column->options & DRIZZLE_COLUMN_ALLOCATED)
 
429
    delete column;
 
430
}
 
431
 
 
432
drizzle_result_st *drizzle_column_drizzle_result(drizzle_column_st *column)
 
433
{
 
434
  return column->result;
 
435
}
 
436
 
 
437
const char *drizzle_column_catalog(drizzle_column_st *column)
 
438
{
 
439
  return column->catalog;
 
440
}
 
441
 
 
442
const char *drizzle_column_db(drizzle_column_st *column)
 
443
{
 
444
  return column->db;
 
445
}
 
446
 
 
447
const char *drizzle_column_table(drizzle_column_st *column)
 
448
{
 
449
  return column->table;
 
450
}
 
451
 
 
452
const char *drizzle_column_orig_table(drizzle_column_st *column)
 
453
{
 
454
  return column->orig_table;
 
455
}
 
456
 
 
457
const char *drizzle_column_name(drizzle_column_st *column)
 
458
{
 
459
  return column->name;
 
460
}
 
461
 
 
462
const char *drizzle_column_orig_name(drizzle_column_st *column)
 
463
{
 
464
  return column->orig_name;
 
465
}
 
466
 
 
467
drizzle_charset_t drizzle_column_charset(drizzle_column_st *column)
 
468
{
 
469
  return column->charset;
 
470
}
 
471
 
 
472
uint32_t drizzle_column_size(drizzle_column_st *column)
 
473
{
 
474
  return column->size;
 
475
}
 
476
 
 
477
size_t drizzle_column_max_size(drizzle_column_st *column)
 
478
{
 
479
  return column->max_size;
 
480
}
 
481
 
 
482
void drizzle_column_set_max_size(drizzle_column_st *column, size_t size)
 
483
{
 
484
  column->max_size= size;
 
485
}
 
486
 
 
487
drizzle_column_type_t drizzle_column_type(drizzle_column_st *column)
 
488
{
 
489
  return column->type;
 
490
}
 
491
 
 
492
drizzle_column_type_drizzle_t
 
493
drizzle_column_type_drizzle(drizzle_column_st *column)
 
494
{
 
495
  return _column_type_drizzle_map_from[column->type];
 
496
}
 
497
 
 
498
int drizzle_column_flags(drizzle_column_st *column)
 
499
{
 
500
  return column->flags;
 
501
}
 
502
 
 
503
uint8_t drizzle_column_decimals(drizzle_column_st *column)
 
504
{
 
505
  return column->decimals;
 
506
}
 
507
 
 
508
const uint8_t *drizzle_column_default_value(drizzle_column_st *column,
 
509
                                            size_t *size)
 
510
{
 
511
  *size= column->default_value_size;
 
512
  return column->default_value;
 
513
}
 
514
 
 
515
/*
 
516
 * Client definitions
 
517
 */
 
518
 
 
519
drizzle_return_t drizzle_column_skip(drizzle_result_st *result)
 
520
{
 
521
  if (drizzle_state_none(result->con))
 
522
  {
 
523
    result->options|= DRIZZLE_RESULT_SKIP_COLUMN;
 
524
 
 
525
    drizzle_state_push(result->con, drizzle_state_column_read);
 
526
    drizzle_state_push(result->con, drizzle_state_packet_read);
 
527
  }
 
528
 
 
529
  return drizzle_state_loop(result->con);
 
530
}
 
531
 
 
532
drizzle_column_st *drizzle_column_read(drizzle_result_st *result,
 
533
                                       drizzle_column_st *column,
 
534
                                       drizzle_return_t *ret_ptr)
 
535
{
 
536
  if (drizzle_state_none(result->con))
 
537
  {
 
538
    result->column= column;
 
539
 
 
540
    drizzle_state_push(result->con, drizzle_state_column_read);
 
541
    drizzle_state_push(result->con, drizzle_state_packet_read);
 
542
  }
 
543
 
 
544
  *ret_ptr= drizzle_state_loop(result->con);
 
545
  return result->column;
 
546
}
 
547
 
 
548
drizzle_return_t drizzle_column_buffer(drizzle_result_st *result)
 
549
{
 
550
  drizzle_return_t ret;
 
551
 
 
552
  if (result->column_buffer == NULL)
 
553
  {
 
554
    if (result->column_count == 0)
 
555
    {
 
556
      result->options|= DRIZZLE_RESULT_BUFFER_COLUMN;
 
557
      return DRIZZLE_RETURN_OK;
 
558
    }
 
559
 
 
560
    result->column_buffer= new drizzle_column_st[result->column_count];
 
561
    if (result->column_buffer == NULL)
 
562
    {
 
563
      drizzle_set_error(result->con->drizzle, "drizzle_column_buffer",
 
564
                        "malloc");
 
565
      return DRIZZLE_RETURN_MEMORY;
 
566
    }
 
567
  }
 
568
 
 
569
  /* No while body, just keep calling to buffer columns. */
 
570
  while (drizzle_column_read(result,
 
571
                             &(result->column_buffer[result->column_current]),
 
572
                             &ret) != NULL && ret == DRIZZLE_RETURN_OK)
 
573
  { }
 
574
 
 
575
  if (ret == DRIZZLE_RETURN_OK)
 
576
  {
 
577
    result->column_current= 0;
 
578
    result->options|= DRIZZLE_RESULT_BUFFER_COLUMN;
 
579
  }
 
580
 
 
581
  return ret;
 
582
}
 
583
 
 
584
drizzle_column_st *drizzle_column_next(drizzle_result_st *result)
 
585
{
 
586
  if (result->column_current == result->column_count)
 
587
    return NULL;
 
588
 
 
589
  result->column_current++;
 
590
  return &(result->column_buffer[result->column_current - 1]);
 
591
}
 
592
 
 
593
drizzle_column_st *drizzle_column_prev(drizzle_result_st *result)
 
594
{
 
595
  if (result->column_current == 0)
 
596
    return NULL;
 
597
 
 
598
  result->column_current--;
 
599
  return &(result->column_buffer[result->column_current]);
 
600
}
 
601
 
 
602
void drizzle_column_seek(drizzle_result_st *result, uint16_t column)
 
603
{
 
604
  if (column <= result->column_count)
 
605
    result->column_current= column;
 
606
}
 
607
 
 
608
drizzle_column_st *drizzle_column_index(drizzle_result_st *result,
 
609
                                        uint16_t column)
 
610
{
 
611
  if (column >= result->column_count)
 
612
    return NULL;
 
613
 
 
614
  return &(result->column_buffer[column]);
 
615
}
 
616
 
 
617
uint16_t drizzle_column_current(drizzle_result_st *result)
 
618
{
 
619
  return result->column_current;
 
620
}
 
621
 
 
622
/*
 
623
 * Server definitions
 
624
 */
 
625
 
 
626
drizzle_return_t drizzle_column_write(drizzle_result_st *result,
 
627
                                      drizzle_column_st *column)
 
628
{
 
629
  if (drizzle_state_none(result->con))
 
630
  {
 
631
    result->column= column;
 
632
 
 
633
    drizzle_state_push(result->con, drizzle_state_column_write);
 
634
  }
 
635
 
 
636
  return drizzle_state_loop(result->con);
 
637
}
 
638
 
 
639
void drizzle_column_set_catalog(drizzle_column_st *column, const char *catalog)
 
640
{
 
641
  if (catalog == NULL)
 
642
    column->catalog[0]= 0;
 
643
  else
 
644
  {
 
645
    strncpy(column->catalog, catalog, DRIZZLE_MAX_CATALOG_SIZE);
 
646
    column->catalog[DRIZZLE_MAX_CATALOG_SIZE - 1]= 0;
 
647
  }
 
648
}
 
649
 
 
650
void drizzle_column_set_db(drizzle_column_st *column, const char *db)
 
651
{
 
652
  if (db == NULL)
 
653
    column->db[0]= 0;
 
654
  else
 
655
  {
 
656
    strncpy(column->db, db, DRIZZLE_MAX_DB_SIZE);
 
657
    column->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
 
658
  }
 
659
}
 
660
 
 
661
void drizzle_column_set_table(drizzle_column_st *column, const char *table)
 
662
{
 
663
  if (table == NULL)
 
664
    column->table[0]= 0;
 
665
  else
 
666
  {
 
667
    strncpy(column->table, table, DRIZZLE_MAX_TABLE_SIZE);
 
668
    column->table[DRIZZLE_MAX_TABLE_SIZE - 1]= 0;
 
669
  }
 
670
}
 
671
 
 
672
void drizzle_column_set_orig_table(drizzle_column_st *column,
 
673
                                   const char *orig_table)
 
674
{
 
675
  if (orig_table == NULL)
 
676
    column->orig_table[0]= 0;
 
677
  else
 
678
  {
 
679
    strncpy(column->orig_table, orig_table, DRIZZLE_MAX_TABLE_SIZE);
 
680
    column->orig_table[DRIZZLE_MAX_TABLE_SIZE - 1]= 0;
 
681
  }
 
682
}
 
683
 
 
684
void drizzle_column_set_name(drizzle_column_st *column, const char *name)
 
685
{
 
686
  if (name == NULL)
 
687
    column->name[0]= 0;
 
688
  else
 
689
  {
 
690
    strncpy(column->name, name, DRIZZLE_MAX_COLUMN_NAME_SIZE);
 
691
    column->name[DRIZZLE_MAX_COLUMN_NAME_SIZE - 1]= 0;
 
692
  }
 
693
}
 
694
 
 
695
void drizzle_column_set_orig_name(drizzle_column_st *column,
 
696
                                  const char *orig_name)
 
697
{
 
698
  if (orig_name == NULL)
 
699
    column->orig_name[0]= 0;
 
700
  else
 
701
  {
 
702
    strncpy(column->orig_name, orig_name, DRIZZLE_MAX_COLUMN_NAME_SIZE);
 
703
    column->orig_name[DRIZZLE_MAX_COLUMN_NAME_SIZE - 1]= 0;
 
704
  }
 
705
}
 
706
 
 
707
void drizzle_column_set_charset(drizzle_column_st *column,
 
708
                                drizzle_charset_t charset)
 
709
{
 
710
  column->charset= charset;
 
711
}
 
712
 
 
713
void drizzle_column_set_size(drizzle_column_st *column, uint32_t size)
 
714
{
 
715
  column->size= size;
 
716
}
 
717
 
 
718
void drizzle_column_set_type(drizzle_column_st *column,
 
719
                             drizzle_column_type_t type)
 
720
{
 
721
  column->type= type;
 
722
}
 
723
 
 
724
void drizzle_column_set_flags(drizzle_column_st *column,
 
725
                              int flags)
 
726
{
 
727
  column->flags= flags;
 
728
}
 
729
 
 
730
void drizzle_column_set_decimals(drizzle_column_st *column, uint8_t decimals)
 
731
{
 
732
  column->decimals= decimals;
 
733
}
 
734
 
 
735
void drizzle_column_set_default_value(drizzle_column_st *column,
 
736
                                      const uint8_t *default_value,
 
737
                                      size_t size)
 
738
{
 
739
  if (default_value == NULL)
 
740
    column->default_value[0]= 0;
 
741
  else
 
742
  {
 
743
    if (size < DRIZZLE_MAX_DEFAULT_VALUE_SIZE)
 
744
    {
 
745
      memcpy(column->default_value, default_value, size);
 
746
      column->default_value[size]= 0;
 
747
      column->default_value_size= size;
 
748
    }
 
749
    else
 
750
    {
 
751
      memcpy(column->default_value, default_value,
 
752
             DRIZZLE_MAX_DEFAULT_VALUE_SIZE - 1);
 
753
      column->default_value[DRIZZLE_MAX_DEFAULT_VALUE_SIZE - 1]= 0;
 
754
      column->default_value_size= DRIZZLE_MAX_DEFAULT_VALUE_SIZE;
 
755
    }
 
756
  }
 
757
}
 
758
 
 
759
/*
 
760
 * Internal state functions.
 
761
 */
 
762
 
 
763
drizzle_return_t drizzle_state_column_read(drizzle_con_st *con)
 
764
{
 
765
  drizzle_column_st *column;
 
766
  drizzle_column_type_drizzle_t drizzle_type;
 
767
 
 
768
  drizzle_log_debug(con->drizzle, "drizzle_state_column_read");
 
769
 
 
770
  /* Assume the entire column packet will fit in the buffer. */
 
771
  if (con->buffer_size < con->packet_size)
 
772
  {
 
773
    drizzle_state_push(con, drizzle_state_read);
 
774
    return DRIZZLE_RETURN_OK;
 
775
  }
 
776
 
 
777
  if (con->packet_size == 5 && con->buffer_ptr[0] == 254)
 
778
  {
 
779
    /* EOF packet marking end of columns. */
 
780
    con->result->column= NULL;
 
781
    con->result->warning_count= drizzle_get_byte2(con->buffer_ptr + 1);
 
782
    con->status= (drizzle_con_status_t)drizzle_get_byte2(con->buffer_ptr + 3);
 
783
    con->buffer_ptr+= 5;
 
784
    con->buffer_size-= 5;
 
785
 
 
786
    drizzle_state_pop(con);
 
787
  }
 
788
  else if (con->result->options & DRIZZLE_RESULT_SKIP_COLUMN)
 
789
  {
 
790
    con->buffer_ptr+= con->packet_size;
 
791
    con->buffer_size-= con->packet_size;
 
792
    con->packet_size= 0;
 
793
 
 
794
    drizzle_state_push(con, drizzle_state_packet_read);
 
795
  }
 
796
  else
 
797
  {
 
798
    column= drizzle_column_create(con->result, con->result->column);
 
799
    if (column == NULL)
 
800
      return DRIZZLE_RETURN_MEMORY;
 
801
 
 
802
    con->result->column= column;
 
803
 
 
804
    /* These functions can only fail if they need to read data, but we know we
 
805
       buffered the entire packet, so ignore returns. */
 
806
    (void)drizzle_unpack_string(con, column->catalog, DRIZZLE_MAX_CATALOG_SIZE);
 
807
    (void)drizzle_unpack_string(con, column->db, DRIZZLE_MAX_DB_SIZE);
 
808
    (void)drizzle_unpack_string(con, column->table, DRIZZLE_MAX_TABLE_SIZE);
 
809
    (void)drizzle_unpack_string(con, column->orig_table,
 
810
                                DRIZZLE_MAX_TABLE_SIZE);
 
811
    (void)drizzle_unpack_string(con, column->name,
 
812
                                DRIZZLE_MAX_COLUMN_NAME_SIZE);
 
813
    (void)drizzle_unpack_string(con, column->orig_name,
 
814
                                DRIZZLE_MAX_COLUMN_NAME_SIZE);
 
815
 
 
816
    /* Skip one filler byte. */
 
817
    column->charset= (drizzle_charset_t)drizzle_get_byte2(con->buffer_ptr + 1);
 
818
    column->size= drizzle_get_byte4(con->buffer_ptr + 3);
 
819
 
 
820
    if (con->options & DRIZZLE_CON_MYSQL)
 
821
      column->type= (drizzle_column_type_t)con->buffer_ptr[7];
 
822
    else
 
823
    {
 
824
      drizzle_type= (drizzle_column_type_drizzle_t)con->buffer_ptr[7];
 
825
      if (drizzle_type >= DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX)
 
826
        drizzle_type= DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX;
 
827
      column->type= _column_type_drizzle_map_to[drizzle_type];
 
828
    }
 
829
 
 
830
    column->flags= drizzle_get_byte2(con->buffer_ptr + 8);
 
831
    if (column->type <= DRIZZLE_COLUMN_TYPE_INT24 &&
 
832
        column->type != DRIZZLE_COLUMN_TYPE_TIMESTAMP)
 
833
    {
 
834
      column->flags|= DRIZZLE_COLUMN_FLAGS_NUM;
 
835
    }
 
836
 
 
837
    column->decimals= con->buffer_ptr[10];
 
838
    /* Skip two reserved bytes. */
 
839
 
 
840
    con->buffer_ptr+= 13;
 
841
    con->buffer_size-= 13;
 
842
    con->packet_size-= 13;
 
843
 
 
844
    if (con->packet_size > 0)
 
845
    {
 
846
      drizzle_column_set_default_value(column, con->buffer_ptr,
 
847
                                       con->packet_size);
 
848
 
 
849
      con->buffer_ptr+= con->packet_size;
 
850
      con->buffer_size-= con->packet_size;
 
851
    }
 
852
    else
 
853
      column->default_value[0]= 0;
 
854
 
 
855
    con->result->column_current++;
 
856
 
 
857
    drizzle_state_pop(con);
 
858
  }
 
859
 
 
860
  return DRIZZLE_RETURN_OK;
 
861
}
 
862
 
 
863
drizzle_return_t drizzle_state_column_write(drizzle_con_st *con)
 
864
{
 
865
  uint8_t *start= con->buffer_ptr + con->buffer_size;
 
866
  uint8_t *ptr;
 
867
  drizzle_column_st *column= con->result->column;
 
868
 
 
869
  drizzle_log_debug(con->drizzle, "drizzle_state_column_write");
 
870
 
 
871
  /* Calculate max packet size. */
 
872
  con->packet_size= 9 + strlen(column->catalog)
 
873
                  + 9 + strlen(column->db)
 
874
                  + 9 + strlen(column->table)
 
875
                  + 9 + strlen(column->orig_table)
 
876
                  + 9 + strlen(column->name)
 
877
                  + 9 + strlen(column->orig_name)
 
878
                  + 1   /* Unused */
 
879
                  + 2   /* Charset */
 
880
                  + 4   /* Size */
 
881
                  + 1   /* Type */
 
882
                  + 2   /* Flags */
 
883
                  + 1   /* Decimals */
 
884
                  + 2   /* Unused */
 
885
                  + column->default_value_size;
 
886
 
 
887
  /* Assume the entire column packet will fit in the buffer. */
 
888
  if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
 
889
  {
 
890
    drizzle_set_error(con->drizzle, "drizzle_state_column_write",
 
891
                      "buffer too small:%zu", con->packet_size + 4);
 
892
    return DRIZZLE_RETURN_INTERNAL_ERROR;
 
893
  }
 
894
 
 
895
  /* Flush buffer if there is not enough room. */
 
896
  if (((size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer)) <
 
897
      con->packet_size)
 
898
  {
 
899
    drizzle_state_push(con, drizzle_state_write);
 
900
    return DRIZZLE_RETURN_OK;
 
901
  }
 
902
 
 
903
  /* Store packet size at the end since it may change. */
 
904
  ptr= start;
 
905
  ptr[3]= con->packet_number;
 
906
  con->packet_number++;
 
907
  ptr+= 4;
 
908
 
 
909
  ptr= drizzle_pack_string(column->catalog, ptr);
 
910
  ptr= drizzle_pack_string(column->db, ptr);
 
911
  ptr= drizzle_pack_string(column->table, ptr);
 
912
  ptr= drizzle_pack_string(column->orig_table, ptr);
 
913
  ptr= drizzle_pack_string(column->name, ptr);
 
914
  ptr= drizzle_pack_string(column->orig_name, ptr);
 
915
 
 
916
  /* This unused byte is set to 12 for some reason. */
 
917
  ptr[0]= 12;
 
918
  ptr++;
 
919
 
 
920
  drizzle_set_byte2(ptr, column->charset);
 
921
  ptr+= 2;
 
922
 
 
923
  drizzle_set_byte4(ptr, column->size);
 
924
  ptr+= 4;
 
925
 
 
926
  if (con->options & DRIZZLE_CON_MYSQL)
 
927
    ptr[0]= column->type;
 
928
  else
 
929
    ptr[0]= _column_type_drizzle_map_from[column->type];
 
930
  ptr++;
 
931
 
 
932
  drizzle_set_byte2(ptr, column->flags);
 
933
  ptr+= 2;
 
934
 
 
935
  ptr[0]= column->decimals;
 
936
  ptr++;
 
937
 
 
938
  memset(ptr, 0, 2);
 
939
  ptr+= 2;
 
940
 
 
941
  if (column->default_value_size > 0)
 
942
  {
 
943
    memcpy(ptr, column->default_value, column->default_value_size);
 
944
    ptr+= column->default_value_size;
 
945
  }
 
946
 
 
947
  con->packet_size= ((size_t)(ptr - start) - 4);
 
948
  con->buffer_size+= (4 + con->packet_size);
 
949
 
 
950
  /* Store packet size now. */
 
951
  drizzle_set_byte3(start, con->packet_size);
 
952
 
 
953
  con->result->column_current++;
 
954
 
 
955
  drizzle_state_pop(con);
 
956
 
 
957
  return DRIZZLE_RETURN_OK;
 
958
}