Drizzled Public API Documentation

column.cc
Go to the documentation of this file.
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2  *
3  * Drizzle Client & Protocol Library
4  *
5  * Copyright (C) 2008 Eric Day (eday@oddments.org)
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are
10  * met:
11  *
12  * * Redistributions of source code must retain the above copyright
13  * notice, this list of conditions and the following disclaimer.
14  *
15  * * Redistributions in binary form must reproduce the above
16  * copyright notice, this list of conditions and the following disclaimer
17  * in the documentation and/or other materials provided with the
18  * distribution.
19  *
20  * * The names of its contributors may not be used to endorse or
21  * promote products derived from this software without specific prior
22  * written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35  *
36  */
37 
38 
44 #include <libdrizzle/common.h>
45 
46 /*
47  * Private variables.
48  */
49 
50 static drizzle_column_type_t _column_type_drizzle_map_to[]=
51 {
52  DRIZZLE_COLUMN_TYPE_TINY,
53  DRIZZLE_COLUMN_TYPE_LONG,
54  DRIZZLE_COLUMN_TYPE_DOUBLE,
55  DRIZZLE_COLUMN_TYPE_NULL,
56  DRIZZLE_COLUMN_TYPE_TIMESTAMP,
57  DRIZZLE_COLUMN_TYPE_LONGLONG,
58  DRIZZLE_COLUMN_TYPE_DATETIME,
59  DRIZZLE_COLUMN_TYPE_NEWDATE,
60  DRIZZLE_COLUMN_TYPE_VARCHAR,
61  DRIZZLE_COLUMN_TYPE_NEWDECIMAL,
62  DRIZZLE_COLUMN_TYPE_ENUM,
63  DRIZZLE_COLUMN_TYPE_BLOB
64 };
65 
66 static drizzle_column_type_drizzle_t _column_type_drizzle_map_from[]=
67 {
68  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 0 */
69  DRIZZLE_COLUMN_TYPE_DRIZZLE_BOOLEAN,
70  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
71  DRIZZLE_COLUMN_TYPE_DRIZZLE_LONG,
72  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
73  DRIZZLE_COLUMN_TYPE_DRIZZLE_DOUBLE,
74  DRIZZLE_COLUMN_TYPE_DRIZZLE_NULL,
75  DRIZZLE_COLUMN_TYPE_DRIZZLE_TIMESTAMP,
76  DRIZZLE_COLUMN_TYPE_DRIZZLE_LONGLONG,
77  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
78 
79  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 10 */
80  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
81  DRIZZLE_COLUMN_TYPE_DRIZZLE_DATETIME,
82  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
83  DRIZZLE_COLUMN_TYPE_DRIZZLE_DATE,
84  DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR,
85  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
86  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
87  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
88  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
89 
90  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 20 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
100 
101  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 30 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
111 
112  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 40 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
122 
123  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 50 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
133 
134  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 60 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
144 
145  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 70 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
155 
156  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 80 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
166 
167  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 90 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
177 
178  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 100 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
188 
189  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 110 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
199 
200  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 120 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
210 
211  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 130 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
221 
222  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 140 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
232 
233  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 150 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
243 
244  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 160 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
254 
255  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 170 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
265 
266  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 180 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
276 
277  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 190 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
287 
288  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 200 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
298 
299  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 210 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
309 
310  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 220 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
320 
321  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 230 */
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  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
331 
332  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 240 */
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_MAX,
338  DRIZZLE_COLUMN_TYPE_DRIZZLE_NEWDECIMAL,
339  DRIZZLE_COLUMN_TYPE_DRIZZLE_ENUM,
340  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
341  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
342 
343  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 250 */
344  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
345  DRIZZLE_COLUMN_TYPE_DRIZZLE_BLOB,
346  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
347  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
348  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX
349 };
350 
351 /*
352  * Common definitions
353  */
354 
355 drizzle_column_st *drizzle_column_create(drizzle_result_st *result,
356  drizzle_column_st *column)
357 {
358  if (result == NULL)
359  {
360  return NULL;
361  }
362 
363  if (column == NULL)
364  {
365  column= new (std::nothrow) (drizzle_column_st);
366  if (column == NULL)
367  {
368  drizzle_set_error(result->con->drizzle, __func__, "Failed to allocate.");
369  return NULL;
370  }
371 
372  column->result = result;
373  /* SET BELOW: column->next */
374  column->prev = NULL;
375  column->options= DRIZZLE_COLUMN_ALLOCATED;
376  column->catalog[0] = '\0';
377  column->db[0] = '\0';
378  column->table[0] = '\0';
379  column->orig_table[0] = '\0';
380  column->name[0] = '\0';
381  column->orig_name[0] = '\0';
382  column->charset = 0;
383  column->size = 0;
384  column->max_size = 0;
385  column->type = drizzle_column_type_t();
386  column->flags = drizzle_column_flags_t();
387  column->decimals = 0;
388  /* UNSET: column->default_value */
389  column->default_value_size = 0;
390 
391  }
392  else
393  {
394  column->result = result;
395  /* SET BELOW: column->next */
396  column->prev = NULL;
397  column->options= drizzle_column_options_t();
398  column->catalog[0] = '\0';
399  column->db[0] = '\0';
400  column->table[0] = '\0';
401  column->orig_table[0] = '\0';
402  column->name[0] = '\0';
403  column->orig_name[0] = '\0';
404  column->charset = 0;
405  column->size = 0;
406  column->max_size = 0;
407  column->type = drizzle_column_type_t();
408  column->flags = drizzle_column_flags_t();
409  column->decimals = 0;
410  /* UNSET: column->default_value */
411  column->default_value_size = 0;
412  }
413 
414  column->result= result;
415 
416  if (result->column_list)
417  result->column_list->prev= column;
418 
419  column->next= result->column_list;
420  result->column_list= column;
421 
422  return column;
423 }
424 
425 void drizzle_column_free(drizzle_column_st *column)
426 {
427  if (column == NULL)
428  {
429  return;
430  }
431 
432  if (column->result->column_list == column)
433  column->result->column_list= column->next;
434 
435  if (column->prev)
436  column->prev->next= column->next;
437 
438  if (column->next)
439  column->next->prev= column->prev;
440 
441  if (column->options & DRIZZLE_COLUMN_ALLOCATED)
442  {
443  delete column;
444  }
445 }
446 
447 drizzle_result_st *drizzle_column_drizzle_result(drizzle_column_st *column)
448 {
449  if (column == NULL)
450  {
451  return NULL;
452  }
453 
454  return column->result;
455 }
456 
457 const char *drizzle_column_catalog(drizzle_column_st *column)
458 {
459  if (column == NULL)
460  {
461  return NULL;
462  }
463 
464  return column->catalog;
465 }
466 
467 const char *drizzle_column_db(drizzle_column_st *column)
468 {
469  if (column == NULL)
470  {
471  return NULL;
472  }
473 
474  return column->db;
475 }
476 
477 const char *drizzle_column_table(drizzle_column_st *column)
478 {
479  if (column == NULL)
480  {
481  return NULL;
482  }
483 
484  return column->table;
485 }
486 
487 const char *drizzle_column_orig_table(drizzle_column_st *column)
488 {
489  if (column == NULL)
490  {
491  return NULL;
492  }
493 
494  return column->orig_table;
495 }
496 
497 const char *drizzle_column_name(drizzle_column_st *column)
498 {
499  if (column == NULL)
500  {
501  return NULL;
502  }
503 
504  return column->name;
505 }
506 
507 const char *drizzle_column_orig_name(drizzle_column_st *column)
508 {
509  if (column == NULL)
510  {
511  return NULL;
512  }
513 
514  return column->orig_name;
515 }
516 
517 drizzle_charset_t drizzle_column_charset(drizzle_column_st *column)
518 {
519  if (column == NULL)
520  {
521  return drizzle_charset_t();
522  }
523 
524  return column->charset;
525 }
526 
527 uint32_t drizzle_column_size(drizzle_column_st *column)
528 {
529  if (column == NULL)
530  {
531  return 0;
532  }
533 
534  return column->size;
535 }
536 
537 size_t drizzle_column_max_size(drizzle_column_st *column)
538 {
539  if (column == NULL)
540  {
541  return 0;
542  }
543 
544  return column->max_size;
545 }
546 
547 void drizzle_column_set_max_size(drizzle_column_st *column, size_t size)
548 {
549  if (column == NULL)
550  {
551  return;
552  }
553 
554  column->max_size= size;
555 }
556 
557 drizzle_column_type_t drizzle_column_type(drizzle_column_st *column)
558 {
559  if (column == NULL)
560  {
561  return drizzle_column_type_t();
562  }
563 
564  return column->type;
565 }
566 
567 drizzle_column_type_drizzle_t
568 drizzle_column_type_drizzle(drizzle_column_st *column)
569 {
570  if (column == NULL)
571  {
572  return drizzle_column_type_drizzle_t();
573  }
574 
575  return _column_type_drizzle_map_from[column->type];
576 }
577 
578 drizzle_column_flags_t drizzle_column_flags(drizzle_column_st *column)
579 {
580  if (column == NULL)
581  {
582  return drizzle_column_flags_t();
583  }
584 
585  return drizzle_column_flags_t(column->flags);
586 }
587 
588 uint8_t drizzle_column_decimals(drizzle_column_st *column)
589 {
590  if (column == NULL)
591  {
592  return 0;
593  }
594 
595  return column->decimals;
596 }
597 
598 const uint8_t *drizzle_column_default_value(drizzle_column_st *column,
599  size_t *size)
600 {
601  if (column == NULL)
602  {
603  return NULL;
604  }
605 
606  *size= column->default_value_size;
607  return column->default_value;
608 }
609 
610 /*
611  * Client definitions
612  */
613 
614 drizzle_return_t drizzle_column_skip(drizzle_result_st *result)
615 {
616  if (result == NULL)
617  {
618  return DRIZZLE_RETURN_INVALID_ARGUMENT;
619  }
620 
621  drizzle_return_t ret;
622  if (drizzle_state_none(result->con))
623  {
624  result->options|= int(DRIZZLE_RESULT_SKIP_COLUMN);
625 
626  drizzle_state_push(result->con, drizzle_state_column_read);
627  drizzle_state_push(result->con, drizzle_state_packet_read);
628  }
629  ret= drizzle_state_loop(result->con);
630  result->options&= ~int(DRIZZLE_RESULT_SKIP_COLUMN);
631  return ret;
632 }
633 
634 drizzle_return_t drizzle_column_skip_all(drizzle_result_st *result)
635 {
636  if (result == NULL)
637  {
638  return DRIZZLE_RETURN_INVALID_ARGUMENT;
639  }
640 
641  for (uint16_t it= 1; it <= result->column_count; it++)
642  {
643  drizzle_return_t ret= drizzle_column_skip(result);
644 
645  if (ret != DRIZZLE_RETURN_OK)
646  {
647  return ret;
648  }
649  }
650 
651  return DRIZZLE_RETURN_OK;
652 }
653 
654 drizzle_column_st *drizzle_column_read(drizzle_result_st *result,
655  drizzle_column_st *column,
656  drizzle_return_t *ret_ptr)
657 {
658  drizzle_return_t unused_ret;
659  if (ret_ptr == NULL)
660  {
661  ret_ptr= &unused_ret;
662  }
663 
664  if (result == NULL)
665  {
666  return NULL;
667  }
668 
669  if (drizzle_state_none(result->con))
670  {
671  result->column= column;
672 
673  drizzle_state_push(result->con, drizzle_state_column_read);
674  drizzle_state_push(result->con, drizzle_state_packet_read);
675  }
676 
677  *ret_ptr= drizzle_state_loop(result->con);
678 
679  return result->column;
680 }
681 
682 drizzle_return_t drizzle_column_buffer(drizzle_result_st *result)
683 {
684  if (result == NULL)
685  {
686  return DRIZZLE_RETURN_INVALID_ARGUMENT;
687  }
688 
689  drizzle_return_t ret;
690 
691  if (result->column_buffer == NULL)
692  {
693  if (result->column_count == 0)
694  {
695  result->options|= int(DRIZZLE_RESULT_BUFFER_COLUMN);
696  return DRIZZLE_RETURN_OK;
697  }
698 
699  result->column_buffer= new (std::nothrow) drizzle_column_st[result->column_count];
700  if (result->column_buffer == NULL)
701  {
702  drizzle_set_error(result->con->drizzle, __func__, "Failed to allocate.");
703 
704  return DRIZZLE_RETURN_MEMORY;
705  }
706  }
707 
708  /* No while body, just keep calling to buffer columns. */
709  while (drizzle_column_read(result,
710  &(result->column_buffer[result->column_current]),
711  &ret) != NULL && ret == DRIZZLE_RETURN_OK);
712  if (ret == DRIZZLE_RETURN_OK)
713  {
714  result->column_current= 0;
715  result->options|= DRIZZLE_RESULT_BUFFER_COLUMN;
716  }
717 
718  return ret;
719 }
720 
721 drizzle_column_st *drizzle_column_next(drizzle_result_st *result)
722 {
723  if (result == NULL)
724  {
725  return NULL;
726  }
727 
728  if (result->column_current == result->column_count)
729  {
730  return NULL;
731  }
732 
733  result->column_current++;
734  return &(result->column_buffer[result->column_current - 1]);
735 }
736 
737 drizzle_column_st *drizzle_column_prev(drizzle_result_st *result)
738 {
739  if (result == NULL)
740  {
741  return NULL;
742  }
743 
744  if (result->column_current == 0)
745  {
746  return NULL;
747  }
748 
749  result->column_current--;
750  return &(result->column_buffer[result->column_current]);
751 }
752 
753 void drizzle_column_seek(drizzle_result_st *result, uint16_t column)
754 {
755  if (result == NULL)
756  {
757  return;
758  }
759 
760  if (column <= result->column_count)
761  {
762  result->column_current= column;
763  }
764 }
765 
766 drizzle_column_st *drizzle_column_index(drizzle_result_st *result,
767  uint16_t column)
768 {
769  if (result == NULL)
770  {
771  return NULL;
772  }
773 
774  if (column >= result->column_count)
775  {
776  return NULL;
777  }
778 
779  return &(result->column_buffer[column]);
780 }
781 
782 uint16_t drizzle_column_current(drizzle_result_st *result)
783 {
784  if (result == NULL)
785  {
786  return 0;
787  }
788 
789  return result->column_current;
790 }
791 
792 /*
793  * Server definitions
794  */
795 
796 drizzle_return_t drizzle_column_write(drizzle_result_st *result,
797  drizzle_column_st *column)
798 {
799  if (result == NULL)
800  {
801  return DRIZZLE_RETURN_INVALID_ARGUMENT;
802  }
803 
804  if (drizzle_state_none(result->con))
805  {
806  result->column= column;
807 
808  drizzle_state_push(result->con, drizzle_state_column_write);
809  }
810 
811  return drizzle_state_loop(result->con);
812 }
813 
814 void drizzle_column_set_catalog(drizzle_column_st *column, const char *catalog)
815 {
816  if (column == NULL)
817  {
818  return;
819  }
820 
821  if (catalog == NULL)
822  {
823  column->catalog[0]= 0;
824  }
825  else
826  {
827  strncpy(column->catalog, catalog, DRIZZLE_MAX_CATALOG_SIZE);
828  column->catalog[DRIZZLE_MAX_CATALOG_SIZE - 1]= 0;
829  }
830 }
831 
832 void drizzle_column_set_db(drizzle_column_st *column, const char *db)
833 {
834  if (column == NULL)
835  {
836  return;
837  }
838 
839  if (db == NULL)
840  {
841  column->db[0]= 0;
842  }
843  else
844  {
845  strncpy(column->db, db, DRIZZLE_MAX_DB_SIZE);
846  column->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
847  }
848 }
849 
850 void drizzle_column_set_table(drizzle_column_st *column, const char *table)
851 {
852  if (column == NULL)
853  {
854  return;
855  }
856 
857  if (table == NULL)
858  {
859  column->table[0]= 0;
860  }
861  else
862  {
863  strncpy(column->table, table, DRIZZLE_MAX_TABLE_SIZE);
864  column->table[DRIZZLE_MAX_TABLE_SIZE - 1]= 0;
865  }
866 }
867 
868 void drizzle_column_set_orig_table(drizzle_column_st *column,
869  const char *orig_table)
870 {
871  if (column == NULL)
872  {
873  return;
874  }
875 
876  if (orig_table == NULL)
877  {
878  column->orig_table[0]= 0;
879  }
880  else
881  {
882  strncpy(column->orig_table, orig_table, DRIZZLE_MAX_TABLE_SIZE);
883  column->orig_table[DRIZZLE_MAX_TABLE_SIZE - 1]= 0;
884  }
885 }
886 
887 void drizzle_column_set_name(drizzle_column_st *column, const char *name)
888 {
889  if (column == NULL)
890  {
891  return;
892  }
893 
894  if (name == NULL)
895  {
896  column->name[0]= 0;
897  }
898  else
899  {
900  strncpy(column->name, name, DRIZZLE_MAX_COLUMN_NAME_SIZE);
901  column->name[DRIZZLE_MAX_COLUMN_NAME_SIZE - 1]= 0;
902  }
903 }
904 
905 void drizzle_column_set_orig_name(drizzle_column_st *column,
906  const char *orig_name)
907 {
908  if (orig_name == NULL)
909  column->orig_name[0]= 0;
910  else
911  {
912  strncpy(column->orig_name, orig_name, DRIZZLE_MAX_COLUMN_NAME_SIZE);
913  column->orig_name[DRIZZLE_MAX_COLUMN_NAME_SIZE - 1]= 0;
914  }
915 }
916 
917 void drizzle_column_set_charset(drizzle_column_st *column,
918  drizzle_charset_t charset)
919 {
920  if (column == NULL)
921  {
922  return;
923  }
924 
925  column->charset= charset;
926 }
927 
928 void drizzle_column_set_size(drizzle_column_st *column, uint32_t size)
929 {
930  if (column == NULL)
931  {
932  return;
933  }
934 
935  column->size= size;
936 }
937 
938 void drizzle_column_set_type(drizzle_column_st *column,
939  drizzle_column_type_t type)
940 {
941  if (column == NULL)
942  {
943  return;
944  }
945 
946  column->type= type;
947 }
948 
949 void drizzle_column_set_flags(drizzle_column_st *column,
950  drizzle_column_flags_t flags)
951 {
952  if (column == NULL)
953  {
954  return;
955  }
956 
957  column->flags= flags;
958 }
959 
960 void drizzle_column_set_decimals(drizzle_column_st *column, uint8_t decimals)
961 {
962  if (column == NULL)
963  {
964  return;
965  }
966 
967  column->decimals= decimals;
968 }
969 
970 void drizzle_column_set_default_value(drizzle_column_st *column,
971  const uint8_t *default_value,
972  size_t size)
973 {
974  if (column == NULL)
975  {
976  return;
977  }
978 
979  if (default_value == NULL)
980  {
981  column->default_value[0]= 0;
982  }
983  else
984  {
985  if (size < DRIZZLE_MAX_DEFAULT_VALUE_SIZE)
986  {
987  memcpy(column->default_value, default_value, size);
988  column->default_value[size]= 0;
989  column->default_value_size= size;
990  }
991  else
992  {
993  memcpy(column->default_value, default_value,
994  DRIZZLE_MAX_DEFAULT_VALUE_SIZE - 1);
995  column->default_value[DRIZZLE_MAX_DEFAULT_VALUE_SIZE - 1]= 0;
996  column->default_value_size= DRIZZLE_MAX_DEFAULT_VALUE_SIZE;
997  }
998  }
999 }
1000 
1001 /*
1002  * Internal state functions.
1003  */
1004 
1005 drizzle_return_t drizzle_state_column_read(drizzle_con_st *con)
1006 {
1007  if (con == NULL)
1008  {
1009  return DRIZZLE_RETURN_INVALID_ARGUMENT;
1010  }
1011 
1012  drizzle_column_st *column;
1013  drizzle_column_type_drizzle_t drizzle_type;
1014 
1015  drizzle_log_debug(con->drizzle, "drizzle_state_column_read");
1016 
1017  /* Assume the entire column packet will fit in the buffer. */
1018  if (con->buffer_size < con->packet_size)
1019  {
1020  drizzle_state_push(con, drizzle_state_read);
1021  return DRIZZLE_RETURN_OK;
1022  }
1023 
1024  if (con->packet_size == 5 && con->buffer_ptr[0] == 254)
1025  {
1026  /* EOF packet marking end of columns. */
1027  con->result->column= NULL;
1028  con->result->warning_count= drizzle_get_byte2(con->buffer_ptr + 1);
1029  con->status= drizzle_con_status_t(drizzle_get_byte2(con->buffer_ptr + 3));
1030  con->buffer_ptr+= 5;
1031  con->buffer_size-= 5;
1032 
1033  drizzle_state_pop(con);
1034  }
1035  else if (con->result->options & DRIZZLE_RESULT_SKIP_COLUMN)
1036  {
1037  con->buffer_ptr+= con->packet_size;
1038  con->buffer_size-= con->packet_size;
1039  con->packet_size= 0;
1040  con->result->column_current++;
1041 
1042  drizzle_state_pop(con);
1043  }
1044  else
1045  {
1046  column= drizzle_column_create(con->result, con->result->column);
1047  if (column == NULL)
1048  return DRIZZLE_RETURN_MEMORY;
1049 
1050  con->result->column= column;
1051 
1052  /* These functions can only fail if they need to read data, but we know we
1053  buffered the entire packet, so ignore returns. */
1054  (void)drizzle_unpack_string(con, column->catalog, DRIZZLE_MAX_CATALOG_SIZE);
1055  (void)drizzle_unpack_string(con, column->db, DRIZZLE_MAX_DB_SIZE);
1056  (void)drizzle_unpack_string(con, column->table, DRIZZLE_MAX_TABLE_SIZE);
1057  (void)drizzle_unpack_string(con, column->orig_table,
1058  DRIZZLE_MAX_TABLE_SIZE);
1059  (void)drizzle_unpack_string(con, column->name,
1060  DRIZZLE_MAX_COLUMN_NAME_SIZE);
1061  (void)drizzle_unpack_string(con, column->orig_name,
1062  DRIZZLE_MAX_COLUMN_NAME_SIZE);
1063 
1064  /* Skip one filler byte. */
1065  column->charset= (drizzle_charset_t)drizzle_get_byte2(con->buffer_ptr + 1);
1066  column->size= drizzle_get_byte4(con->buffer_ptr + 3);
1067 
1068  if (con->options & DRIZZLE_CON_MYSQL)
1069  {
1070  column->type= drizzle_column_type_t(con->buffer_ptr[7]);
1071  }
1072  else
1073  {
1074  drizzle_type= drizzle_column_type_drizzle_t(con->buffer_ptr[7]);
1075  if (drizzle_type >= DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX)
1076  drizzle_type= DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX;
1077  column->type= _column_type_drizzle_map_to[drizzle_type];
1078  }
1079 
1080  column->flags= drizzle_column_flags_t(drizzle_get_byte2(con->buffer_ptr + 8));
1081  if (column->type <= DRIZZLE_COLUMN_TYPE_INT24 &&
1082  column->type != DRIZZLE_COLUMN_TYPE_TIMESTAMP)
1083  {
1084  column->flags|= int(DRIZZLE_COLUMN_FLAGS_NUM);
1085  }
1086 
1087  column->decimals= con->buffer_ptr[10];
1088  /* Skip two reserved bytes. */
1089 
1090  con->buffer_ptr+= 13;
1091  con->buffer_size-= 13;
1092  con->packet_size-= 13;
1093 
1094  if (con->packet_size > 0)
1095  {
1096  drizzle_column_set_default_value(column, con->buffer_ptr,
1097  con->packet_size);
1098 
1099  con->buffer_ptr+= con->packet_size;
1100  con->buffer_size-= con->packet_size;
1101  }
1102  else
1103  column->default_value[0]= 0;
1104 
1105  con->result->column_current++;
1106 
1107  drizzle_state_pop(con);
1108  }
1109 
1110  return DRIZZLE_RETURN_OK;
1111 }
1112 
1113 drizzle_return_t drizzle_state_column_write(drizzle_con_st *con)
1114 {
1115  if (con == NULL)
1116  {
1117  return DRIZZLE_RETURN_INVALID_ARGUMENT;
1118  }
1119 
1120  uint8_t *start= con->buffer_ptr + con->buffer_size;
1121  uint8_t *ptr;
1122  drizzle_column_st *column= con->result->column;
1123 
1124  drizzle_log_debug(con->drizzle, "drizzle_state_column_write");
1125 
1126  /* Calculate max packet size. */
1127  con->packet_size= 9 + strlen(column->catalog)
1128  + 9 + strlen(column->db)
1129  + 9 + strlen(column->table)
1130  + 9 + strlen(column->orig_table)
1131  + 9 + strlen(column->name)
1132  + 9 + strlen(column->orig_name)
1133  + 1 /* Unused */
1134  + 2 /* Charset */
1135  + 4 /* Size */
1136  + 1 /* Type */
1137  + 2 /* Flags */
1138  + 1 /* Decimals */
1139  + 2 /* Unused */
1140  + column->default_value_size;
1141 
1142  /* Assume the entire column packet will fit in the buffer. */
1143  if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
1144  {
1145  drizzle_set_error(con->drizzle, "drizzle_state_column_write",
1146  "buffer too small:%zu", con->packet_size + 4);
1147  return DRIZZLE_RETURN_INTERNAL_ERROR;
1148  }
1149 
1150  /* Flush buffer if there is not enough room. */
1151  if (((size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer)) <
1152  con->packet_size)
1153  {
1154  drizzle_state_push(con, drizzle_state_write);
1155  return DRIZZLE_RETURN_OK;
1156  }
1157 
1158  /* Store packet size at the end since it may change. */
1159  ptr= start;
1160  ptr[3]= con->packet_number;
1161  con->packet_number++;
1162  ptr+= 4;
1163 
1164  ptr= drizzle_pack_string(column->catalog, ptr);
1165  ptr= drizzle_pack_string(column->db, ptr);
1166  ptr= drizzle_pack_string(column->table, ptr);
1167  ptr= drizzle_pack_string(column->orig_table, ptr);
1168  ptr= drizzle_pack_string(column->name, ptr);
1169  ptr= drizzle_pack_string(column->orig_name, ptr);
1170 
1171  /* This unused byte is set to 12 for some reason. */
1172  ptr[0]= 12;
1173  ptr++;
1174 
1175  drizzle_set_byte2(ptr, column->charset);
1176  ptr+= 2;
1177 
1178  drizzle_set_byte4(ptr, column->size);
1179  ptr+= 4;
1180 
1181  if (con->options & DRIZZLE_CON_MYSQL)
1182  {
1183  ptr[0]= column->type;
1184  }
1185  else
1186  {
1187  ptr[0]= _column_type_drizzle_map_from[column->type];
1188  }
1189  ptr++;
1190 
1191  drizzle_set_byte2(ptr, column->flags);
1192  ptr+= 2;
1193 
1194  ptr[0]= column->decimals;
1195  ptr++;
1196 
1197  memset(ptr, 0, 2);
1198  ptr+= 2;
1199 
1200  if (column->default_value_size > 0)
1201  {
1202  memcpy(ptr, column->default_value, column->default_value_size);
1203  ptr+= column->default_value_size;
1204  }
1205 
1206  con->packet_size= ((size_t)(ptr - start) - 4);
1207  con->buffer_size+= (4 + con->packet_size);
1208 
1209  /* Store packet size now. */
1210  drizzle_set_byte3(start, con->packet_size);
1211 
1212  con->result->column_current++;
1213 
1214  drizzle_state_pop(con);
1215 
1216  return DRIZZLE_RETURN_OK;
1217 }
static void drizzle_state_pop(drizzle_con_st *con)
Definition: conn_local.h:104
static bool drizzle_state_none(drizzle_con_st *con)
Definition: conn_local.h:71
static void drizzle_state_push(drizzle_con_st *con, drizzle_state_fn *function)
Definition: conn_local.h:88
void drizzle_set_error(drizzle_st *drizzle, const char *function, const char *format,...)
Definition: drizzle.cc:881
drizzle_return_t drizzle_state_loop(drizzle_con_st *con)
Definition: state.cc:45
static void drizzle_log_debug(drizzle_st *drizzle, const char *format,...)
drizzle_return_t drizzle_unpack_string(drizzle_con_st *con, char *buffer, uint64_t max_length)
Definition: pack.cc:178
uint8_t * drizzle_pack_string(char *string, uint8_t *ptr)
Definition: pack.cc:159
System Include Files.