Drizzled Public API Documentation

column.c
Go to the documentation of this file.
00001 /*
00002  * Drizzle Client & Protocol Library
00003  *
00004  * Copyright (C) 2008 Eric Day (eday@oddments.org)
00005  * All rights reserved.
00006  *
00007  * Redistribution and use in source and binary forms, with or without
00008  * modification, are permitted provided that the following conditions are
00009  * met:
00010  *
00011  *     * Redistributions of source code must retain the above copyright
00012  * notice, this list of conditions and the following disclaimer.
00013  *
00014  *     * Redistributions in binary form must reproduce the above
00015  * copyright notice, this list of conditions and the following disclaimer
00016  * in the documentation and/or other materials provided with the
00017  * distribution.
00018  *
00019  *     * The names of its contributors may not be used to endorse or
00020  * promote products derived from this software without specific prior
00021  * written permission.
00022  *
00023  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00024  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00025  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00026  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00027  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00028  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00029  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00030  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00031  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00032  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00033  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00034  *
00035  */
00036 
00037 
00043 #include "common.h"
00044 
00045 /*
00046  * Private variables.
00047  */
00048 
00049 static drizzle_column_type_t _column_type_drizzle_map_to[]=
00050 {
00051  DRIZZLE_COLUMN_TYPE_TINY,
00052  DRIZZLE_COLUMN_TYPE_LONG,
00053  DRIZZLE_COLUMN_TYPE_DOUBLE,
00054  DRIZZLE_COLUMN_TYPE_NULL,
00055  DRIZZLE_COLUMN_TYPE_TIMESTAMP,
00056  DRIZZLE_COLUMN_TYPE_LONGLONG,
00057  DRIZZLE_COLUMN_TYPE_DATETIME,
00058  DRIZZLE_COLUMN_TYPE_NEWDATE,
00059  DRIZZLE_COLUMN_TYPE_VARCHAR,
00060  DRIZZLE_COLUMN_TYPE_NEWDECIMAL,
00061  DRIZZLE_COLUMN_TYPE_ENUM,
00062  DRIZZLE_COLUMN_TYPE_BLOB
00063 };
00064 
00065 static drizzle_column_type_drizzle_t _column_type_drizzle_map_from[]=
00066 {
00067  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 0 */
00068  DRIZZLE_COLUMN_TYPE_DRIZZLE_BOOLEAN,
00069  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00070  DRIZZLE_COLUMN_TYPE_DRIZZLE_LONG,
00071  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00072  DRIZZLE_COLUMN_TYPE_DRIZZLE_DOUBLE,
00073  DRIZZLE_COLUMN_TYPE_DRIZZLE_NULL,
00074  DRIZZLE_COLUMN_TYPE_DRIZZLE_TIMESTAMP,
00075  DRIZZLE_COLUMN_TYPE_DRIZZLE_LONGLONG,
00076  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00077 
00078  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 10 */
00079  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00080  DRIZZLE_COLUMN_TYPE_DRIZZLE_DATETIME,
00081  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00082  DRIZZLE_COLUMN_TYPE_DRIZZLE_DATE,
00083  DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR,
00084  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00085  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00086  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00087  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00088 
00089  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 20 */
00090  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00091  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00092  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00093  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00094  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00095  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00096  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00097  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00098  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00099 
00100  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 30 */
00101  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00102  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00103  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00104  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00105  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00106  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00107  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00108  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00109  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00110 
00111  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 40 */
00112  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00113  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00114  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00115  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00116  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00117  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00118  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00119  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00120  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00121 
00122  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 50 */
00123  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00124  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00125  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00126  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00127  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00128  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00129  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00130  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00131  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00132 
00133  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 60 */
00134  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00135  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00136  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00137  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00138  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00139  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00140  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00141  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00142  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00143 
00144  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 70 */
00145  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00146  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00147  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00148  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00149  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00150  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00151  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00152  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00153  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00154 
00155  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 80 */
00156  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00157  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00158  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00159  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00160  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00161  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00162  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00163  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00164  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00165 
00166  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 90 */
00167  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00168  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00169  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00170  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00171  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00172  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00173  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00174  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00175  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00176 
00177  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 100 */
00178  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00179  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00180  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00181  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00182  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00183  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00184  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00185  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00186  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00187 
00188  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 110 */
00189  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00190  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00191  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00192  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00193  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00194  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00195  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00196  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00197  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00198 
00199  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 120 */
00200  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00201  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00202  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00203  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00204  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00205  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00206  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00207  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00208  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00209 
00210  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 130 */
00211  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00212  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00213  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00214  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00215  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00216  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00217  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00218  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00219  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00220 
00221  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 140 */
00222  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00223  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00224  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00225  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00226  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00227  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00228  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00229  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00230  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00231 
00232  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 150 */
00233  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00234  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00235  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00236  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00237  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00238  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00239  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00240  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00241  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00242 
00243  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 160 */
00244  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00245  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00246  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00247  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00248  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00249  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00250  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00251  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00252  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00253 
00254  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 170 */
00255  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00256  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00257  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00258  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00259  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00260  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00261  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00262  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00263  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00264 
00265  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 180 */
00266  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00267  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00268  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00269  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00270  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00271  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00272  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00273  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00274  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00275 
00276  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 190 */
00277  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00278  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00279  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00280  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00281  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00282  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00283  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00284  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00285  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00286 
00287  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 200 */
00288  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00289  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00290  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00291  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00292  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00293  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00294  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00295  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00296  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00297 
00298  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 210 */
00299  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00300  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00301  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00302  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00303  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00304  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00305  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00306  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00307  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00308 
00309  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 220 */
00310  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00311  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00312  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00313  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00314  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00315  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00316  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00317  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00318  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00319 
00320  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 230 */
00321  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00322  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00323  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00324  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00325  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00326  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00327  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00328  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00329  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00330 
00331  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 240 */
00332  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00333  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00334  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00335  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00336  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00337  DRIZZLE_COLUMN_TYPE_DRIZZLE_NEWDECIMAL,
00338  DRIZZLE_COLUMN_TYPE_DRIZZLE_ENUM,
00339  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00340  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00341 
00342  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 250 */
00343  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00344  DRIZZLE_COLUMN_TYPE_DRIZZLE_BLOB,
00345  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00346  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00347  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX
00348 };
00349 
00350 /*
00351  * Common definitions
00352  */
00353 
00354 drizzle_column_st *drizzle_column_create(drizzle_result_st *result,
00355                                          drizzle_column_st *column)
00356 {
00357   if (column == NULL)
00358   {
00359     column= malloc(sizeof(drizzle_column_st));
00360     if (column == NULL)
00361     {
00362       drizzle_set_error(result->con->drizzle, "drizzle_column_create",
00363                         "malloc");
00364       return NULL;
00365     }
00366 
00367     column->result = result;
00368     /* SET BELOW: column->next */
00369     column->prev = NULL;
00370     column->options= DRIZZLE_COLUMN_ALLOCATED;
00371     column->catalog[0] = '\0';
00372     column->db[0] = '\0';
00373     column->table[0] = '\0';
00374     column->orig_table[0] = '\0';
00375     column->name[0] = '\0';
00376     column->orig_name[0] = '\0';
00377     column->charset = 0;
00378     column->size = 0;
00379     column->max_size = 0;
00380     column->type = 0;
00381     column->flags = 0;
00382     column->decimals = 0;
00383     /* UNSET: column->default_value */
00384     column->default_value_size = 0;
00385 
00386   }
00387   else
00388   {
00389     column->result = result;
00390     /* SET BELOW: column->next */
00391     column->prev = NULL;
00392     column->options= 0;
00393     column->catalog[0] = '\0';
00394     column->db[0] = '\0';
00395     column->table[0] = '\0';
00396     column->orig_table[0] = '\0';
00397     column->name[0] = '\0';
00398     column->orig_name[0] = '\0';
00399     column->charset = 0;
00400     column->size = 0;
00401     column->max_size = 0;
00402     column->type = 0;
00403     column->flags = 0;
00404     column->decimals = 0;
00405     /* UNSET: column->default_value */
00406     column->default_value_size = 0;
00407   }
00408 
00409   column->result= result;
00410 
00411   if (result->column_list)
00412     result->column_list->prev= column;
00413   column->next= result->column_list;
00414   result->column_list= column;
00415 
00416   return column;
00417 }
00418 
00419 void drizzle_column_free(drizzle_column_st *column)
00420 {
00421   if (column->result->column_list == column)
00422     column->result->column_list= column->next;
00423   if (column->prev)
00424     column->prev->next= column->next;
00425   if (column->next)
00426     column->next->prev= column->prev;
00427 
00428   if (column->options & DRIZZLE_COLUMN_ALLOCATED)
00429     free(column);
00430 }
00431 
00432 drizzle_result_st *drizzle_column_drizzle_result(drizzle_column_st *column)
00433 {
00434   return column->result;
00435 }
00436 
00437 const char *drizzle_column_catalog(drizzle_column_st *column)
00438 {
00439   return column->catalog;
00440 }
00441 
00442 const char *drizzle_column_db(drizzle_column_st *column)
00443 {
00444   return column->db;
00445 }
00446 
00447 const char *drizzle_column_table(drizzle_column_st *column)
00448 {
00449   return column->table;
00450 }
00451 
00452 const char *drizzle_column_orig_table(drizzle_column_st *column)
00453 {
00454   return column->orig_table;
00455 }
00456 
00457 const char *drizzle_column_name(drizzle_column_st *column)
00458 {
00459   return column->name;
00460 }
00461 
00462 const char *drizzle_column_orig_name(drizzle_column_st *column)
00463 {
00464   return column->orig_name;
00465 }
00466 
00467 drizzle_charset_t drizzle_column_charset(drizzle_column_st *column)
00468 {
00469   return column->charset;
00470 }
00471 
00472 uint32_t drizzle_column_size(drizzle_column_st *column)
00473 {
00474   return column->size;
00475 }
00476 
00477 size_t drizzle_column_max_size(drizzle_column_st *column)
00478 {
00479   return column->max_size;
00480 }
00481 
00482 void drizzle_column_set_max_size(drizzle_column_st *column, size_t size)
00483 {
00484   column->max_size= size;
00485 }
00486 
00487 drizzle_column_type_t drizzle_column_type(drizzle_column_st *column)
00488 {
00489   return column->type;
00490 }
00491 
00492 drizzle_column_type_drizzle_t
00493 drizzle_column_type_drizzle(drizzle_column_st *column)
00494 {
00495   return _column_type_drizzle_map_from[column->type];
00496 }
00497 
00498 drizzle_column_flags_t drizzle_column_flags(drizzle_column_st *column)
00499 {
00500   return column->flags;
00501 }
00502 
00503 uint8_t drizzle_column_decimals(drizzle_column_st *column)
00504 {
00505   return column->decimals;
00506 }
00507 
00508 const uint8_t *drizzle_column_default_value(drizzle_column_st *column,
00509                                             size_t *size)
00510 {
00511   *size= column->default_value_size;
00512   return column->default_value;
00513 }
00514 
00515 /*
00516  * Client definitions
00517  */
00518 
00519 drizzle_return_t drizzle_column_skip(drizzle_result_st *result)
00520 {
00521   if (drizzle_state_none(result->con))
00522   {
00523     result->options|= DRIZZLE_RESULT_SKIP_COLUMN;
00524 
00525     drizzle_state_push(result->con, drizzle_state_column_read);
00526     drizzle_state_push(result->con, drizzle_state_packet_read);
00527   }
00528 
00529   return drizzle_state_loop(result->con);
00530 }
00531 
00532 drizzle_column_st *drizzle_column_read(drizzle_result_st *result,
00533                                        drizzle_column_st *column,
00534                                        drizzle_return_t *ret_ptr)
00535 {
00536   if (drizzle_state_none(result->con))
00537   {
00538     result->column= column;
00539 
00540     drizzle_state_push(result->con, drizzle_state_column_read);
00541     drizzle_state_push(result->con, drizzle_state_packet_read);
00542   }
00543 
00544   *ret_ptr= drizzle_state_loop(result->con);
00545   return result->column;
00546 }
00547 
00548 drizzle_return_t drizzle_column_buffer(drizzle_result_st *result)
00549 {
00550   drizzle_return_t ret;
00551 
00552   if (result->column_buffer == NULL)
00553   {
00554     if (result->column_count == 0)
00555     {
00556       result->options|= DRIZZLE_RESULT_BUFFER_COLUMN;
00557       return DRIZZLE_RETURN_OK;
00558     }
00559 
00560     result->column_buffer= malloc(sizeof(drizzle_column_st) *
00561                                   result->column_count);
00562     if (result->column_buffer == NULL)
00563     {
00564       drizzle_set_error(result->con->drizzle, "drizzle_column_buffer",
00565                         "malloc");
00566       return DRIZZLE_RETURN_MEMORY;
00567     }
00568   }
00569 
00570   /* No while body, just keep calling to buffer columns. */
00571   while (drizzle_column_read(result,
00572                              &(result->column_buffer[result->column_current]),
00573                              &ret) != NULL && ret == DRIZZLE_RETURN_OK);
00574   if (ret == DRIZZLE_RETURN_OK)
00575   {
00576     result->column_current= 0;
00577     result->options|= DRIZZLE_RESULT_BUFFER_COLUMN;
00578   }
00579 
00580   return ret;
00581 }
00582 
00583 drizzle_column_st *drizzle_column_next(drizzle_result_st *result)
00584 {
00585   if (result->column_current == result->column_count)
00586     return NULL;
00587 
00588   result->column_current++;
00589   return &(result->column_buffer[result->column_current - 1]);
00590 }
00591 
00592 drizzle_column_st *drizzle_column_prev(drizzle_result_st *result)
00593 {
00594   if (result->column_current == 0)
00595     return NULL;
00596 
00597   result->column_current--;
00598   return &(result->column_buffer[result->column_current]);
00599 }
00600 
00601 void drizzle_column_seek(drizzle_result_st *result, uint16_t column)
00602 {
00603   if (column <= result->column_count)
00604     result->column_current= column;
00605 }
00606 
00607 drizzle_column_st *drizzle_column_index(drizzle_result_st *result,
00608                                         uint16_t column)
00609 {
00610   if (column >= result->column_count)
00611     return NULL;
00612 
00613   return &(result->column_buffer[column]);
00614 }
00615 
00616 uint16_t drizzle_column_current(drizzle_result_st *result)
00617 {
00618   return result->column_current;
00619 }
00620 
00621 /*
00622  * Server definitions
00623  */
00624 
00625 drizzle_return_t drizzle_column_write(drizzle_result_st *result,
00626                                       drizzle_column_st *column)
00627 {
00628   if (drizzle_state_none(result->con))
00629   {
00630     result->column= column;
00631 
00632     drizzle_state_push(result->con, drizzle_state_column_write);
00633   }
00634 
00635   return drizzle_state_loop(result->con);
00636 }
00637 
00638 void drizzle_column_set_catalog(drizzle_column_st *column, const char *catalog)
00639 {
00640   if (catalog == NULL)
00641     column->catalog[0]= 0;
00642   else
00643   {
00644     strncpy(column->catalog, catalog, DRIZZLE_MAX_CATALOG_SIZE);
00645     column->catalog[DRIZZLE_MAX_CATALOG_SIZE - 1]= 0;
00646   }
00647 }
00648 
00649 void drizzle_column_set_db(drizzle_column_st *column, const char *db)
00650 {
00651   if (db == NULL)
00652     column->db[0]= 0;
00653   else
00654   {
00655     strncpy(column->db, db, DRIZZLE_MAX_DB_SIZE);
00656     column->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
00657   }
00658 }
00659 
00660 void drizzle_column_set_table(drizzle_column_st *column, const char *table)
00661 {
00662   if (table == NULL)
00663     column->table[0]= 0;
00664   else
00665   {
00666     strncpy(column->table, table, DRIZZLE_MAX_TABLE_SIZE);
00667     column->table[DRIZZLE_MAX_TABLE_SIZE - 1]= 0;
00668   }
00669 }
00670 
00671 void drizzle_column_set_orig_table(drizzle_column_st *column,
00672                                    const char *orig_table)
00673 {
00674   if (orig_table == NULL)
00675     column->orig_table[0]= 0;
00676   else
00677   {
00678     strncpy(column->orig_table, orig_table, DRIZZLE_MAX_TABLE_SIZE);
00679     column->orig_table[DRIZZLE_MAX_TABLE_SIZE - 1]= 0;
00680   }
00681 }
00682 
00683 void drizzle_column_set_name(drizzle_column_st *column, const char *name)
00684 {
00685   if (name == NULL)
00686     column->name[0]= 0;
00687   else
00688   {
00689     strncpy(column->name, name, DRIZZLE_MAX_COLUMN_NAME_SIZE);
00690     column->name[DRIZZLE_MAX_COLUMN_NAME_SIZE - 1]= 0;
00691   }
00692 }
00693 
00694 void drizzle_column_set_orig_name(drizzle_column_st *column,
00695                                   const char *orig_name)
00696 {
00697   if (orig_name == NULL)
00698     column->orig_name[0]= 0;
00699   else
00700   {
00701     strncpy(column->orig_name, orig_name, DRIZZLE_MAX_COLUMN_NAME_SIZE);
00702     column->orig_name[DRIZZLE_MAX_COLUMN_NAME_SIZE - 1]= 0;
00703   }
00704 }
00705 
00706 void drizzle_column_set_charset(drizzle_column_st *column,
00707                                 drizzle_charset_t charset)
00708 {
00709   column->charset= charset;
00710 }
00711 
00712 void drizzle_column_set_size(drizzle_column_st *column, uint32_t size)
00713 {
00714   column->size= size;
00715 }
00716 
00717 void drizzle_column_set_type(drizzle_column_st *column,
00718                              drizzle_column_type_t type)
00719 {
00720   column->type= type;
00721 }
00722 
00723 void drizzle_column_set_flags(drizzle_column_st *column,
00724                               drizzle_column_flags_t flags)
00725 {
00726   column->flags= flags;
00727 }
00728 
00729 void drizzle_column_set_decimals(drizzle_column_st *column, uint8_t decimals)
00730 {
00731   column->decimals= decimals;
00732 }
00733 
00734 void drizzle_column_set_default_value(drizzle_column_st *column,
00735                                       const uint8_t *default_value,
00736                                       size_t size)
00737 {
00738   if (default_value == NULL)
00739     column->default_value[0]= 0;
00740   else
00741   {
00742     if (size < DRIZZLE_MAX_DEFAULT_VALUE_SIZE)
00743     {
00744       memcpy(column->default_value, default_value, size);
00745       column->default_value[size]= 0;
00746       column->default_value_size= size;
00747     }
00748     else
00749     {
00750       memcpy(column->default_value, default_value,
00751              DRIZZLE_MAX_DEFAULT_VALUE_SIZE - 1);
00752       column->default_value[DRIZZLE_MAX_DEFAULT_VALUE_SIZE - 1]= 0;
00753       column->default_value_size= DRIZZLE_MAX_DEFAULT_VALUE_SIZE;
00754     }
00755   }
00756 }
00757 
00758 /*
00759  * Internal state functions.
00760  */
00761 
00762 drizzle_return_t drizzle_state_column_read(drizzle_con_st *con)
00763 {
00764   drizzle_column_st *column;
00765   drizzle_column_type_drizzle_t drizzle_type;
00766 
00767   drizzle_log_debug(con->drizzle, "drizzle_state_column_read");
00768 
00769   /* Assume the entire column packet will fit in the buffer. */
00770   if (con->buffer_size < con->packet_size)
00771   {
00772     drizzle_state_push(con, drizzle_state_read);
00773     return DRIZZLE_RETURN_OK;
00774   }
00775 
00776   if (con->packet_size == 5 && con->buffer_ptr[0] == 254)
00777   {
00778     /* EOF packet marking end of columns. */
00779     con->result->column= NULL;
00780     con->result->warning_count= drizzle_get_byte2(con->buffer_ptr + 1);
00781     con->status= drizzle_get_byte2(con->buffer_ptr + 3);
00782     con->buffer_ptr+= 5;
00783     con->buffer_size-= 5;
00784 
00785     drizzle_state_pop(con);
00786   }
00787   else if (con->result->options & DRIZZLE_RESULT_SKIP_COLUMN)
00788   {
00789     con->buffer_ptr+= con->packet_size;
00790     con->buffer_size-= con->packet_size;
00791     con->packet_size= 0;
00792 
00793     drizzle_state_push(con, drizzle_state_packet_read);
00794   }
00795   else
00796   {
00797     column= drizzle_column_create(con->result, con->result->column);
00798     if (column == NULL)
00799       return DRIZZLE_RETURN_MEMORY;
00800 
00801     con->result->column= column;
00802 
00803     /* These functions can only fail if they need to read data, but we know we
00804        buffered the entire packet, so ignore returns. */
00805     (void)drizzle_unpack_string(con, column->catalog, DRIZZLE_MAX_CATALOG_SIZE);
00806     (void)drizzle_unpack_string(con, column->db, DRIZZLE_MAX_DB_SIZE);
00807     (void)drizzle_unpack_string(con, column->table, DRIZZLE_MAX_TABLE_SIZE);
00808     (void)drizzle_unpack_string(con, column->orig_table,
00809                                 DRIZZLE_MAX_TABLE_SIZE);
00810     (void)drizzle_unpack_string(con, column->name,
00811                                 DRIZZLE_MAX_COLUMN_NAME_SIZE);
00812     (void)drizzle_unpack_string(con, column->orig_name,
00813                                 DRIZZLE_MAX_COLUMN_NAME_SIZE);
00814 
00815     /* Skip one filler byte. */
00816     column->charset= (drizzle_charset_t)drizzle_get_byte2(con->buffer_ptr + 1);
00817     column->size= drizzle_get_byte4(con->buffer_ptr + 3);
00818 
00819     if (con->options & DRIZZLE_CON_MYSQL)
00820       column->type= con->buffer_ptr[7];
00821     else
00822     {
00823       drizzle_type= con->buffer_ptr[7];
00824       if (drizzle_type >= DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX)
00825         drizzle_type= DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX;
00826       column->type= _column_type_drizzle_map_to[drizzle_type];
00827     }
00828 
00829     column->flags= drizzle_get_byte2(con->buffer_ptr + 8);
00830     if (column->type <= DRIZZLE_COLUMN_TYPE_INT24 &&
00831         column->type != DRIZZLE_COLUMN_TYPE_TIMESTAMP)
00832     {
00833       column->flags|= DRIZZLE_COLUMN_FLAGS_NUM;
00834     }
00835 
00836     column->decimals= con->buffer_ptr[10];
00837     /* Skip two reserved bytes. */
00838 
00839     con->buffer_ptr+= 13;
00840     con->buffer_size-= 13;
00841     con->packet_size-= 13;
00842 
00843     if (con->packet_size > 0)
00844     {
00845       drizzle_column_set_default_value(column, con->buffer_ptr,
00846                                        con->packet_size);
00847 
00848       con->buffer_ptr+= con->packet_size;
00849       con->buffer_size-= con->packet_size;
00850     }
00851     else
00852       column->default_value[0]= 0;
00853 
00854     con->result->column_current++;
00855 
00856     drizzle_state_pop(con);
00857   }
00858 
00859   return DRIZZLE_RETURN_OK;
00860 }
00861 
00862 drizzle_return_t drizzle_state_column_write(drizzle_con_st *con)
00863 {
00864   uint8_t *start= con->buffer_ptr + con->buffer_size;
00865   uint8_t *ptr;
00866   drizzle_column_st *column= con->result->column;
00867 
00868   drizzle_log_debug(con->drizzle, "drizzle_state_column_write");
00869 
00870   /* Calculate max packet size. */
00871   con->packet_size= 9 + strlen(column->catalog)
00872                   + 9 + strlen(column->db)
00873                   + 9 + strlen(column->table)
00874                   + 9 + strlen(column->orig_table)
00875                   + 9 + strlen(column->name)
00876                   + 9 + strlen(column->orig_name)
00877                   + 1   /* Unused */
00878                   + 2   /* Charset */
00879                   + 4   /* Size */
00880                   + 1   /* Type */
00881                   + 2   /* Flags */
00882                   + 1   /* Decimals */
00883                   + 2   /* Unused */
00884                   + column->default_value_size;
00885 
00886   /* Assume the entire column packet will fit in the buffer. */
00887   if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
00888   {
00889     drizzle_set_error(con->drizzle, "drizzle_state_column_write",
00890                       "buffer too small:%zu", con->packet_size + 4);
00891     return DRIZZLE_RETURN_INTERNAL_ERROR;
00892   }
00893 
00894   /* Flush buffer if there is not enough room. */
00895   if (((size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer)) <
00896       con->packet_size)
00897   {
00898     drizzle_state_push(con, drizzle_state_write);
00899     return DRIZZLE_RETURN_OK;
00900   }
00901 
00902   /* Store packet size at the end since it may change. */
00903   ptr= start;
00904   ptr[3]= con->packet_number;
00905   con->packet_number++;
00906   ptr+= 4;
00907 
00908   ptr= drizzle_pack_string(column->catalog, ptr);
00909   ptr= drizzle_pack_string(column->db, ptr);
00910   ptr= drizzle_pack_string(column->table, ptr);
00911   ptr= drizzle_pack_string(column->orig_table, ptr);
00912   ptr= drizzle_pack_string(column->name, ptr);
00913   ptr= drizzle_pack_string(column->orig_name, ptr);
00914 
00915   /* This unused byte is set to 12 for some reason. */
00916   ptr[0]= 12;
00917   ptr++;
00918 
00919   drizzle_set_byte2(ptr, column->charset);
00920   ptr+= 2;
00921 
00922   drizzle_set_byte4(ptr, column->size);
00923   ptr+= 4;
00924 
00925   if (con->options & DRIZZLE_CON_MYSQL)
00926     ptr[0]= column->type;
00927   else
00928     ptr[0]= _column_type_drizzle_map_from[column->type];
00929   ptr++;
00930 
00931   drizzle_set_byte2(ptr, column->flags);
00932   ptr+= 2;
00933 
00934   ptr[0]= column->decimals;
00935   ptr++;
00936 
00937   memset(ptr, 0, 2);
00938   ptr+= 2;
00939 
00940   if (column->default_value_size > 0)
00941   {
00942     memcpy(ptr, column->default_value, column->default_value_size);
00943     ptr+= column->default_value_size;
00944   }
00945 
00946   con->packet_size= ((size_t)(ptr - start) - 4);
00947   con->buffer_size+= (4 + con->packet_size);
00948 
00949   /* Store packet size now. */
00950   drizzle_set_byte3(start, con->packet_size);
00951 
00952   con->result->column_current++;
00953 
00954   drizzle_state_pop(con);
00955 
00956   return DRIZZLE_RETURN_OK;
00957 }