libdrizzle Developer Documentation

libdrizzle/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  * Use and distribution licensed under the BSD license.  See
00008  * the COPYING file in this directory for full text.
00009  */
00010 
00016 #include "common.h"
00017 
00018 /*
00019  * Private variables.
00020  */
00021 
00022 static drizzle_column_type_t _column_type_drizzle_map_to[]=
00023 {
00024  DRIZZLE_COLUMN_TYPE_TINY,
00025  DRIZZLE_COLUMN_TYPE_LONG,
00026  DRIZZLE_COLUMN_TYPE_DOUBLE,
00027  DRIZZLE_COLUMN_TYPE_NULL,
00028  DRIZZLE_COLUMN_TYPE_TIMESTAMP,
00029  DRIZZLE_COLUMN_TYPE_LONGLONG,
00030  DRIZZLE_COLUMN_TYPE_DATETIME,
00031  DRIZZLE_COLUMN_TYPE_NEWDATE,
00032  DRIZZLE_COLUMN_TYPE_VARCHAR,
00033  DRIZZLE_COLUMN_TYPE_NEWDECIMAL,
00034  DRIZZLE_COLUMN_TYPE_ENUM,
00035  DRIZZLE_COLUMN_TYPE_BLOB
00036 };
00037 
00038 static drizzle_column_type_drizzle_t _column_type_drizzle_map_from[]=
00039 {
00040  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 0 */
00041  DRIZZLE_COLUMN_TYPE_DRIZZLE_TINY,
00042  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00043  DRIZZLE_COLUMN_TYPE_DRIZZLE_LONG,
00044  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00045  DRIZZLE_COLUMN_TYPE_DRIZZLE_DOUBLE,
00046  DRIZZLE_COLUMN_TYPE_DRIZZLE_NULL,
00047  DRIZZLE_COLUMN_TYPE_DRIZZLE_TIMESTAMP,
00048  DRIZZLE_COLUMN_TYPE_DRIZZLE_LONGLONG,
00049  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00050 
00051  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 10 */
00052  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00053  DRIZZLE_COLUMN_TYPE_DRIZZLE_DATETIME,
00054  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00055  DRIZZLE_COLUMN_TYPE_DRIZZLE_DATE,
00056  DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR,
00057  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00058  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00059  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00060  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00061 
00062  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 20 */
00063  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00064  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00065  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00066  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00067  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00068  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00069  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00070  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00071  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00072 
00073  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 30 */
00074  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00075  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00076  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00077  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00078  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00079  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00080  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00081  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00082  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00083 
00084  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 40 */
00085  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00086  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00087  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00088  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00089  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00095  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 50 */
00096  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00097  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00098  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00099  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00100  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00106  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 60 */
00107  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00108  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00109  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00110  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00111  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00117  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 70 */
00118  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00119  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00120  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00121  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00122  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00128  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 80 */
00129  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00130  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00131  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00132  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00133  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00139  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 90 */
00140  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00141  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00142  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00143  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00144  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00150  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 100 */
00151  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00152  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00153  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00154  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00155  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00161  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 110 */
00162  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00163  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00164  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00165  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00166  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00172  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 120 */
00173  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00174  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00175  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00176  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00177  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00183  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 130 */
00184  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00185  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00186  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00187  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00188  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00194  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 140 */
00195  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00196  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00197  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00198  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00199  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00205  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 150 */
00206  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00207  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00208  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00209  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00210  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00216  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 160 */
00217  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00218  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00219  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00220  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00221  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00227  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 170 */
00228  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00229  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00230  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00231  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00232  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00238  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 180 */
00239  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00240  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00241  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00242  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00243  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00249  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 190 */
00250  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00251  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00252  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00253  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00254  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00260  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 200 */
00261  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00262  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00263  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00264  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00265  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00271  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 210 */
00272  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00273  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00274  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00275  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00276  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00282  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 220 */
00283  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00284  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00285  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00286  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00287  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00293  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 230 */
00294  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00295  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00296  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00297  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00298  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
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 
00304  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 240 */
00305  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00306  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00307  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00308  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00309  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00310  DRIZZLE_COLUMN_TYPE_DRIZZLE_NEWDECIMAL,
00311  DRIZZLE_COLUMN_TYPE_DRIZZLE_ENUM,
00312  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00313  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00314 
00315  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX, /* 250 */
00316  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00317  DRIZZLE_COLUMN_TYPE_DRIZZLE_BLOB,
00318  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00319  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX,
00320  DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX
00321 };
00322 
00323 /*
00324  * Common definitions
00325  */
00326 
00327 drizzle_column_st *drizzle_column_create(drizzle_result_st *result,
00328                                          drizzle_column_st *column)
00329 {
00330   if (column == NULL)
00331   {
00332     column= malloc(sizeof(drizzle_column_st));
00333     if (column == NULL)
00334     {
00335       drizzle_set_error(result->con->drizzle, "drizzle_column_create",
00336                         "malloc");
00337       return NULL;
00338     }
00339 
00340     memset(column, 0, sizeof(drizzle_column_st));
00341     column->options|= DRIZZLE_COLUMN_ALLOCATED;
00342   }
00343   else
00344     memset(column, 0, sizeof(drizzle_column_st));
00345 
00346   column->result= result;
00347 
00348   if (result->column_list)
00349     result->column_list->prev= column;
00350   column->next= result->column_list;
00351   result->column_list= column;
00352 
00353   return column;
00354 }
00355 
00356 void drizzle_column_free(drizzle_column_st *column)
00357 {
00358   if (column->result->column_list == column)
00359     column->result->column_list= column->next;
00360   if (column->prev)
00361     column->prev->next= column->next;
00362   if (column->next)
00363     column->next->prev= column->prev;
00364 
00365   if (column->options & DRIZZLE_COLUMN_ALLOCATED)
00366     free(column);
00367 }
00368 
00369 drizzle_result_st *drizzle_column_drizzle_result(drizzle_column_st *column)
00370 {
00371   return column->result;
00372 }
00373 
00374 const char *drizzle_column_catalog(drizzle_column_st *column)
00375 {
00376   return column->catalog;
00377 }
00378 
00379 const char *drizzle_column_db(drizzle_column_st *column)
00380 {
00381   return column->db;
00382 }
00383 
00384 const char *drizzle_column_table(drizzle_column_st *column)
00385 {
00386   return column->table;
00387 }
00388 
00389 const char *drizzle_column_orig_table(drizzle_column_st *column)
00390 {
00391   return column->orig_table;
00392 }
00393 
00394 const char *drizzle_column_name(drizzle_column_st *column)
00395 {
00396   return column->name;
00397 }
00398 
00399 const char *drizzle_column_orig_name(drizzle_column_st *column)
00400 {
00401   return column->orig_name;
00402 }
00403 
00404 drizzle_charset_t drizzle_column_charset(drizzle_column_st *column)
00405 {
00406   return column->charset;
00407 }
00408 
00409 uint32_t drizzle_column_size(drizzle_column_st *column)
00410 {
00411   return column->size;
00412 }
00413 
00414 size_t drizzle_column_max_size(drizzle_column_st *column)
00415 {
00416   return column->max_size;
00417 }
00418 
00419 void drizzle_column_set_max_size(drizzle_column_st *column, size_t size)
00420 {
00421   column->max_size= size;
00422 }
00423 
00424 drizzle_column_type_t drizzle_column_type(drizzle_column_st *column)
00425 {
00426   return column->type;
00427 }
00428 
00429 drizzle_column_type_drizzle_t
00430 drizzle_column_type_drizzle(drizzle_column_st *column)
00431 {
00432   return _column_type_drizzle_map_from[column->type];
00433 }
00434 
00435 drizzle_column_flags_t drizzle_column_flags(drizzle_column_st *column)
00436 {
00437   return column->flags;
00438 }
00439 
00440 uint8_t drizzle_column_decimals(drizzle_column_st *column)
00441 {
00442   return column->decimals;
00443 }
00444 
00445 const uint8_t *drizzle_column_default_value(drizzle_column_st *column,
00446                                             size_t *size)
00447 {
00448   *size= column->default_value_size;
00449   return column->default_value;
00450 }
00451 
00452 /*
00453  * Client definitions
00454  */
00455 
00456 drizzle_return_t drizzle_column_skip(drizzle_result_st *result)
00457 {
00458   if (drizzle_state_none(result->con))
00459   {
00460     result->options|= DRIZZLE_RESULT_SKIP_COLUMN;
00461 
00462     drizzle_state_push(result->con, drizzle_state_column_read);
00463     drizzle_state_push(result->con, drizzle_state_packet_read);
00464   }
00465 
00466   return drizzle_state_loop(result->con);
00467 }
00468 
00469 drizzle_column_st *drizzle_column_read(drizzle_result_st *result,
00470                                        drizzle_column_st *column,
00471                                        drizzle_return_t *ret_ptr)
00472 {
00473   if (drizzle_state_none(result->con))
00474   {
00475     result->column= column;
00476 
00477     drizzle_state_push(result->con, drizzle_state_column_read);
00478     drizzle_state_push(result->con, drizzle_state_packet_read);
00479   }
00480 
00481   *ret_ptr= drizzle_state_loop(result->con);
00482   return result->column;
00483 }
00484 
00485 drizzle_return_t drizzle_column_buffer(drizzle_result_st *result)
00486 {
00487   drizzle_return_t ret;
00488 
00489   if (result->column_buffer == NULL)
00490   {
00491     if (result->column_count == 0)
00492     {
00493       result->options|= DRIZZLE_RESULT_BUFFER_COLUMN;
00494       return DRIZZLE_RETURN_OK;
00495     }
00496 
00497     result->column_buffer= malloc(sizeof(drizzle_column_st) *
00498                                   result->column_count);
00499     if (result->column_buffer == NULL)
00500     {
00501       drizzle_set_error(result->con->drizzle, "drizzle_column_buffer",
00502                         "malloc");
00503       return DRIZZLE_RETURN_MEMORY;
00504     }
00505   }
00506 
00507   /* No while body, just keep calling to buffer columns. */
00508   while (drizzle_column_read(result,
00509                              &(result->column_buffer[result->column_current]),
00510                              &ret) != NULL && ret == DRIZZLE_RETURN_OK);
00511   if (ret == DRIZZLE_RETURN_OK)
00512   {
00513     result->column_current= 0;
00514     result->options|= DRIZZLE_RESULT_BUFFER_COLUMN;
00515   }
00516 
00517   return ret;
00518 }
00519 
00520 drizzle_column_st *drizzle_column_next(drizzle_result_st *result)
00521 {
00522   if (result->column_current == result->column_count)
00523     return NULL;
00524 
00525   result->column_current++;
00526   return &(result->column_buffer[result->column_current - 1]);
00527 }
00528 
00529 drizzle_column_st *drizzle_column_prev(drizzle_result_st *result)
00530 {
00531   if (result->column_current == 0)
00532     return NULL;
00533 
00534   result->column_current--;
00535   return &(result->column_buffer[result->column_current]);
00536 }
00537 
00538 void drizzle_column_seek(drizzle_result_st *result, uint16_t column)
00539 {
00540   if (column <= result->column_count)
00541     result->column_current= column;
00542 }
00543 
00544 drizzle_column_st *drizzle_column_index(drizzle_result_st *result,
00545                                         uint16_t column)
00546 {
00547   if (column >= result->column_count)
00548     return NULL;
00549 
00550   return &(result->column_buffer[column]);
00551 }
00552 
00553 uint16_t drizzle_column_current(drizzle_result_st *result)
00554 {
00555   return result->column_current;
00556 }
00557 
00558 /*
00559  * Server definitions
00560  */
00561 
00562 drizzle_return_t drizzle_column_write(drizzle_result_st *result,
00563                                       drizzle_column_st *column)
00564 {
00565   if (drizzle_state_none(result->con))
00566   {
00567     result->column= column;
00568 
00569     drizzle_state_push(result->con, drizzle_state_column_write);
00570   }
00571 
00572   return drizzle_state_loop(result->con);
00573 }
00574 
00575 void drizzle_column_set_catalog(drizzle_column_st *column, const char *catalog)
00576 {
00577   if (catalog == NULL)
00578     column->catalog[0]= 0;
00579   else
00580   {
00581     strncpy(column->catalog, catalog, DRIZZLE_MAX_CATALOG_SIZE);
00582     column->catalog[DRIZZLE_MAX_CATALOG_SIZE - 1]= 0;
00583   }
00584 }
00585 
00586 void drizzle_column_set_db(drizzle_column_st *column, const char *db)
00587 {
00588   if (db == NULL)
00589     column->db[0]= 0;
00590   else
00591   {
00592     strncpy(column->db, db, DRIZZLE_MAX_DB_SIZE);
00593     column->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
00594   }
00595 }
00596 
00597 void drizzle_column_set_table(drizzle_column_st *column, const char *table)
00598 {
00599   if (table == NULL)
00600     column->table[0]= 0;
00601   else
00602   {
00603     strncpy(column->table, table, DRIZZLE_MAX_TABLE_SIZE);
00604     column->table[DRIZZLE_MAX_TABLE_SIZE - 1]= 0;
00605   }
00606 }
00607 
00608 void drizzle_column_set_orig_table(drizzle_column_st *column,
00609                                    const char *orig_table)
00610 {
00611   if (orig_table == NULL)
00612     column->orig_table[0]= 0;
00613   else
00614   {
00615     strncpy(column->orig_table, orig_table, DRIZZLE_MAX_TABLE_SIZE);
00616     column->orig_table[DRIZZLE_MAX_TABLE_SIZE - 1]= 0;
00617   }
00618 }
00619 
00620 void drizzle_column_set_name(drizzle_column_st *column, const char *name)
00621 {
00622   if (name == NULL)
00623     column->name[0]= 0;
00624   else
00625   {
00626     strncpy(column->name, name, DRIZZLE_MAX_COLUMN_NAME_SIZE);
00627     column->name[DRIZZLE_MAX_COLUMN_NAME_SIZE - 1]= 0;
00628   }
00629 }
00630 
00631 void drizzle_column_set_orig_name(drizzle_column_st *column,
00632                                   const char *orig_name)
00633 {
00634   if (orig_name == NULL)
00635     column->orig_name[0]= 0;
00636   else
00637   {
00638     strncpy(column->orig_name, orig_name, DRIZZLE_MAX_COLUMN_NAME_SIZE);
00639     column->orig_name[DRIZZLE_MAX_COLUMN_NAME_SIZE - 1]= 0;
00640   }
00641 }
00642 
00643 void drizzle_column_set_charset(drizzle_column_st *column,
00644                                 drizzle_charset_t charset)
00645 {
00646   column->charset= charset;
00647 }
00648 
00649 void drizzle_column_set_size(drizzle_column_st *column, uint32_t size)
00650 {
00651   column->size= size;
00652 }
00653 
00654 void drizzle_column_set_type(drizzle_column_st *column,
00655                              drizzle_column_type_t type)
00656 {
00657   column->type= type;
00658 }
00659 
00660 void drizzle_column_set_flags(drizzle_column_st *column,
00661                               drizzle_column_flags_t flags)
00662 {
00663   column->flags= flags;
00664 }
00665 
00666 void drizzle_column_set_decimals(drizzle_column_st *column, uint8_t decimals)
00667 {
00668   column->decimals= decimals;
00669 }
00670 
00671 void drizzle_column_set_default_value(drizzle_column_st *column,
00672                                       const uint8_t *default_value,
00673                                       size_t size)
00674 {
00675   if (default_value == NULL)
00676     column->default_value[0]= 0;
00677   else
00678   {
00679     if (size < DRIZZLE_MAX_DEFAULT_VALUE_SIZE)
00680     {
00681       memcpy(column->default_value, default_value, size);
00682       column->default_value[size]= 0;
00683       column->default_value_size= size;
00684     }
00685     else
00686     {
00687       memcpy(column->default_value, default_value,
00688              DRIZZLE_MAX_DEFAULT_VALUE_SIZE - 1);
00689       column->default_value[DRIZZLE_MAX_DEFAULT_VALUE_SIZE - 1]= 0;
00690       column->default_value_size= DRIZZLE_MAX_DEFAULT_VALUE_SIZE;
00691     }
00692   }
00693 }
00694 
00695 /*
00696  * Internal state functions.
00697  */
00698 
00699 drizzle_return_t drizzle_state_column_read(drizzle_con_st *con)
00700 {
00701   drizzle_column_st *column;
00702   drizzle_column_type_drizzle_t drizzle_type;
00703 
00704   drizzle_log_debug(con->drizzle, "drizzle_state_column_read");
00705 
00706   /* Assume the entire column packet will fit in the buffer. */
00707   if (con->buffer_size < con->packet_size)
00708   {
00709     drizzle_state_push(con, drizzle_state_read);
00710     return DRIZZLE_RETURN_OK;
00711   }
00712 
00713   if (con->packet_size == 5 && con->buffer_ptr[0] == 254)
00714   {
00715     /* EOF packet marking end of columns. */
00716     con->result->column= NULL;
00717     con->result->warning_count= drizzle_get_byte2(con->buffer_ptr + 1);
00718     con->status= drizzle_get_byte2(con->buffer_ptr + 3);
00719     con->buffer_ptr+= 5;
00720     con->buffer_size-= 5;
00721 
00722     drizzle_state_pop(con);
00723   }
00724   else if (con->result->options & DRIZZLE_RESULT_SKIP_COLUMN)
00725   {
00726     con->buffer_ptr+= con->packet_size;
00727     con->buffer_size-= con->packet_size;
00728     con->packet_size= 0;
00729 
00730     drizzle_state_push(con, drizzle_state_packet_read);
00731   }
00732   else
00733   {
00734     column= drizzle_column_create(con->result, con->result->column);
00735     if (column == NULL)
00736       return DRIZZLE_RETURN_MEMORY;
00737 
00738     con->result->column= column;
00739 
00740     /* These functions can only fail if they need to read data, but we know we
00741        buffered the entire packet, so ignore returns. */
00742     (void)drizzle_unpack_string(con, column->catalog, DRIZZLE_MAX_CATALOG_SIZE);
00743     (void)drizzle_unpack_string(con, column->db, DRIZZLE_MAX_DB_SIZE);
00744     (void)drizzle_unpack_string(con, column->table, DRIZZLE_MAX_TABLE_SIZE);
00745     (void)drizzle_unpack_string(con, column->orig_table,
00746                                 DRIZZLE_MAX_TABLE_SIZE);
00747     (void)drizzle_unpack_string(con, column->name,
00748                                 DRIZZLE_MAX_COLUMN_NAME_SIZE);
00749     (void)drizzle_unpack_string(con, column->orig_name,
00750                                 DRIZZLE_MAX_COLUMN_NAME_SIZE);
00751 
00752     /* Skip one filler byte. */
00753     column->charset= (drizzle_charset_t)drizzle_get_byte2(con->buffer_ptr + 1);
00754     column->size= drizzle_get_byte4(con->buffer_ptr + 3);
00755 
00756     if (con->options & DRIZZLE_CON_MYSQL)
00757       column->type= con->buffer_ptr[7];
00758     else
00759     {
00760       drizzle_type= con->buffer_ptr[7];
00761       if (drizzle_type >= DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX)
00762         drizzle_type= DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX;
00763       column->type= _column_type_drizzle_map_to[drizzle_type];
00764     }
00765 
00766     column->flags= drizzle_get_byte2(con->buffer_ptr + 8);
00767     if (column->type <= DRIZZLE_COLUMN_TYPE_INT24 &&
00768         column->type != DRIZZLE_COLUMN_TYPE_TIMESTAMP)
00769     {
00770       column->flags|= DRIZZLE_COLUMN_FLAGS_NUM;
00771     }
00772 
00773     column->decimals= con->buffer_ptr[10];
00774     /* Skip two reserved bytes. */
00775 
00776     con->buffer_ptr+= 13;
00777     con->buffer_size-= 13;
00778     con->packet_size-= 13;
00779 
00780     if (con->packet_size > 0)
00781     {
00782       drizzle_column_set_default_value(column, con->buffer_ptr,
00783                                        con->packet_size);
00784 
00785       con->buffer_ptr+= con->packet_size;
00786       con->buffer_size-= con->packet_size;
00787     }
00788     else
00789       column->default_value[0]= 0;
00790 
00791     con->result->column_current++;
00792 
00793     drizzle_state_pop(con);
00794   }
00795 
00796   return DRIZZLE_RETURN_OK;
00797 }
00798 
00799 drizzle_return_t drizzle_state_column_write(drizzle_con_st *con)
00800 {
00801   uint8_t *start= con->buffer_ptr + con->buffer_size;
00802   uint8_t *ptr;
00803   drizzle_column_st *column= con->result->column;
00804 
00805   drizzle_log_debug(con->drizzle, "drizzle_state_column_write");
00806 
00807   /* Calculate max packet size. */
00808   con->packet_size= 9 + strlen(column->catalog)
00809                   + 9 + strlen(column->db)
00810                   + 9 + strlen(column->table)
00811                   + 9 + strlen(column->orig_table)
00812                   + 9 + strlen(column->name)
00813                   + 9 + strlen(column->orig_name)
00814                   + 1   /* Unused */
00815                   + 2   /* Charset */
00816                   + 4   /* Size */
00817                   + 1   /* Type */
00818                   + 2   /* Flags */
00819                   + 1   /* Decimals */
00820                   + 2   /* Unused */
00821                   + column->default_value_size;
00822 
00823   /* Assume the entire column packet will fit in the buffer. */
00824   if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
00825   {
00826     drizzle_set_error(con->drizzle, "drizzle_state_column_write",
00827                       "buffer too small:%zu", con->packet_size + 4);
00828     return DRIZZLE_RETURN_INTERNAL_ERROR;
00829   }
00830 
00831   /* Flush buffer if there is not enough room. */
00832   if (((size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer)) <
00833       con->packet_size)
00834   {
00835     drizzle_state_push(con, drizzle_state_write);
00836     return DRIZZLE_RETURN_OK;
00837   }
00838 
00839   /* Store packet size at the end since it may change. */
00840   ptr= start;
00841   ptr[3]= con->packet_number;
00842   con->packet_number++;
00843   ptr+= 4;
00844 
00845   ptr= drizzle_pack_string(column->catalog, ptr);
00846   ptr= drizzle_pack_string(column->db, ptr);
00847   ptr= drizzle_pack_string(column->table, ptr);
00848   ptr= drizzle_pack_string(column->orig_table, ptr);
00849   ptr= drizzle_pack_string(column->name, ptr);
00850   ptr= drizzle_pack_string(column->orig_name, ptr);
00851 
00852   /* This unused byte is set to 12 for some reason. */
00853   ptr[0]= 12;
00854   ptr++;
00855 
00856   drizzle_set_byte2(ptr, column->charset);
00857   ptr+= 2;
00858 
00859   drizzle_set_byte4(ptr, column->size);
00860   ptr+= 4;
00861 
00862   if (con->options & DRIZZLE_CON_MYSQL)
00863     ptr[0]= column->type;
00864   else
00865     ptr[0]= _column_type_drizzle_map_from[column->type];
00866   ptr++;
00867 
00868   drizzle_set_byte2(ptr, column->flags);
00869   ptr+= 2;
00870 
00871   ptr[0]= column->decimals;
00872   ptr++;
00873 
00874   memset(ptr, 0, 2);
00875   ptr+= 2;
00876 
00877   if (column->default_value_size > 0)
00878   {
00879     memcpy(ptr, column->default_value, column->default_value_size);
00880     ptr+= column->default_value_size;
00881   }
00882 
00883   con->packet_size= ((size_t)(ptr - start) - 4);
00884   con->buffer_size+= (4 + con->packet_size);
00885 
00886   /* Store packet size now. */
00887   drizzle_set_byte3(start, con->packet_size);
00888 
00889   con->result->column_current++;
00890 
00891   drizzle_state_pop(con);
00892 
00893   return DRIZZLE_RETURN_OK;
00894 }