libdrizzle/column.c Source 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_ERROR_SET(result->con->drizzle, "drizzle_column_create", "malloc")
00336       return NULL;
00337     }
00338 
00339     memset(column, 0, sizeof(drizzle_column_st));
00340     column->options|= DRIZZLE_COLUMN_ALLOCATED;
00341   }
00342   else
00343     memset(column, 0, sizeof(drizzle_column_st));
00344 
00345   column->result= result;
00346 
00347   if (result->column_list)
00348     result->column_list->prev= column;
00349   column->next= result->column_list;
00350   result->column_list= column;
00351 
00352   return column;
00353 }
00354 
00355 void drizzle_column_free(drizzle_column_st *column)
00356 {
00357   if (column->result->column_list == column)
00358     column->result->column_list= column->next;
00359   if (column->prev)
00360     column->prev->next= column->next;
00361   if (column->next)
00362     column->next->prev= column->prev;
00363 
00364   if (column->options & DRIZZLE_COLUMN_ALLOCATED)
00365     free(column);
00366 }
00367 
00368 drizzle_result_st *drizzle_column_drizzle_result(drizzle_column_st *column)
00369 {
00370   return column->result;
00371 }
00372 
00373 const char *drizzle_column_catalog(drizzle_column_st *column)
00374 {
00375   return column->catalog;
00376 }
00377 
00378 const char *drizzle_column_db(drizzle_column_st *column)
00379 {
00380   return column->db;
00381 }
00382 
00383 const char *drizzle_column_table(drizzle_column_st *column)
00384 {
00385   return column->table;
00386 }
00387 
00388 const char *drizzle_column_orig_table(drizzle_column_st *column)
00389 {
00390   return column->orig_table;
00391 }
00392 
00393 const char *drizzle_column_name(drizzle_column_st *column)
00394 {
00395   return column->name;
00396 }
00397 
00398 const char *drizzle_column_orig_name(drizzle_column_st *column)
00399 {
00400   return column->orig_name;
00401 }
00402 
00403 drizzle_charset_t drizzle_column_charset(drizzle_column_st *column)
00404 {
00405   return column->charset;
00406 }
00407 
00408 uint32_t drizzle_column_size(drizzle_column_st *column)
00409 {
00410   return column->size;
00411 }
00412 
00413 size_t drizzle_column_max_size(drizzle_column_st *column)
00414 {
00415   return column->max_size;
00416 }
00417 
00418 void drizzle_column_set_max_size(drizzle_column_st *column, size_t size)
00419 {
00420   column->max_size= size;
00421 }
00422 
00423 drizzle_column_type_t drizzle_column_type(drizzle_column_st *column)
00424 {
00425   return column->type;
00426 }
00427 
00428 drizzle_column_type_drizzle_t
00429 drizzle_column_type_drizzle(drizzle_column_st *column)
00430 {
00431   return _column_type_drizzle_map_from[column->type];
00432 }
00433 
00434 drizzle_column_flags_t drizzle_column_flags(drizzle_column_st *column)
00435 {
00436   return column->flags;
00437 }
00438 
00439 uint8_t drizzle_column_decimals(drizzle_column_st *column)
00440 {
00441   return column->decimals;
00442 }
00443 
00444 const uint8_t *drizzle_column_default_value(drizzle_column_st *column,
00445                                             size_t *size)
00446 {
00447   *size= column->default_value_size;
00448   return column->default_value;
00449 }
00450 
00451 /*
00452  * Client definitions
00453  */
00454 
00455 drizzle_return_t drizzle_column_skip(drizzle_result_st *result)
00456 {
00457   if (DRIZZLE_STATE_NONE(result->con))
00458   {
00459     result->options|= DRIZZLE_RESULT_SKIP_COLUMN;
00460 
00461     DRIZZLE_STATE_PUSH(result->con, drizzle_state_column_read)
00462     DRIZZLE_STATE_PUSH(result->con, drizzle_state_packet_read)
00463   }
00464 
00465   return drizzle_state_loop(result->con);
00466 }
00467 
00468 drizzle_column_st *drizzle_column_read(drizzle_result_st *result,
00469                                        drizzle_column_st *column,
00470                                        drizzle_return_t *ret_ptr)
00471 {
00472   if (DRIZZLE_STATE_NONE(result->con))
00473   {
00474     result->column= column;
00475 
00476     DRIZZLE_STATE_PUSH(result->con, drizzle_state_column_read)
00477     DRIZZLE_STATE_PUSH(result->con, drizzle_state_packet_read)
00478   }
00479 
00480   *ret_ptr= drizzle_state_loop(result->con);
00481   return result->column;
00482 }
00483 
00484 drizzle_return_t drizzle_column_buffer(drizzle_result_st *result)
00485 {
00486   drizzle_return_t ret;
00487 
00488   if (result->column_buffer == NULL)
00489   {
00490     if (result->column_count == 0)
00491     {
00492       result->options|= DRIZZLE_RESULT_BUFFER_COLUMN;
00493       return DRIZZLE_RETURN_OK;
00494     }
00495 
00496     result->column_buffer= malloc(sizeof(drizzle_column_st) *
00497                                   result->column_count);
00498     if (result->column_buffer == NULL)
00499     {
00500       DRIZZLE_ERROR_SET(result->con->drizzle, "drizzle_column_buffer", "malloc")
00501       return DRIZZLE_RETURN_MEMORY;
00502     }
00503   }
00504 
00505   /* No while body, just keep calling to buffer columns. */
00506   while (drizzle_column_read(result,
00507                              &(result->column_buffer[result->column_current]),
00508                              &ret) != NULL && ret == DRIZZLE_RETURN_OK);
00509   if (ret == DRIZZLE_RETURN_OK)
00510   {
00511     result->column_current= 0;
00512     result->options|= DRIZZLE_RESULT_BUFFER_COLUMN;
00513   }
00514 
00515   return ret;
00516 }
00517 
00518 drizzle_column_st *drizzle_column_next(drizzle_result_st *result)
00519 {
00520   if (result->column_current == result->column_count)
00521     return NULL;
00522 
00523   result->column_current++;
00524   return &(result->column_buffer[result->column_current - 1]);
00525 }
00526 
00527 drizzle_column_st *drizzle_column_prev(drizzle_result_st *result)
00528 {
00529   if (result->column_current == 0)
00530     return NULL;
00531 
00532   result->column_current--;
00533   return &(result->column_buffer[result->column_current]);
00534 }
00535 
00536 void drizzle_column_seek(drizzle_result_st *result, uint16_t column)
00537 {
00538   if (column <= result->column_count)
00539     result->column_current= column;
00540 }
00541 
00542 drizzle_column_st *drizzle_column_index(drizzle_result_st *result,
00543                                         uint16_t column)
00544 {
00545   if (column >= result->column_count)
00546     return NULL;
00547 
00548   return &(result->column_buffer[column]);
00549 }
00550 
00551 uint16_t drizzle_column_current(drizzle_result_st *result)
00552 {
00553   return result->column_current;
00554 }
00555 
00556 /*
00557  * Server definitions
00558  */
00559 
00560 drizzle_return_t drizzle_column_write(drizzle_result_st *result,
00561                                       drizzle_column_st *column)
00562 {
00563   if (DRIZZLE_STATE_NONE(result->con))
00564   {
00565     result->column= column;
00566 
00567     DRIZZLE_STATE_PUSH(result->con, drizzle_state_column_write)
00568   }
00569 
00570   return drizzle_state_loop(result->con);
00571 }
00572 
00573 void drizzle_column_set_catalog(drizzle_column_st *column, const char *catalog)
00574 {
00575   if (catalog == NULL)
00576     column->catalog[0]= 0;
00577   else
00578   {
00579     strncpy(column->catalog, catalog, DRIZZLE_MAX_CATALOG_SIZE);
00580     column->catalog[DRIZZLE_MAX_CATALOG_SIZE - 1]= 0;
00581   }
00582 }
00583 
00584 void drizzle_column_set_db(drizzle_column_st *column, const char *db)
00585 {
00586   if (db == NULL)
00587     column->db[0]= 0;
00588   else
00589   {
00590     strncpy(column->db, db, DRIZZLE_MAX_DB_SIZE);
00591     column->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
00592   }
00593 }
00594 
00595 void drizzle_column_set_table(drizzle_column_st *column, const char *table)
00596 {
00597   if (table == NULL)
00598     column->table[0]= 0;
00599   else
00600   {
00601     strncpy(column->table, table, DRIZZLE_MAX_TABLE_SIZE);
00602     column->table[DRIZZLE_MAX_TABLE_SIZE - 1]= 0;
00603   }
00604 }
00605 
00606 void drizzle_column_set_orig_table(drizzle_column_st *column,
00607                                    const char *orig_table)
00608 {
00609   if (orig_table == NULL)
00610     column->orig_table[0]= 0;
00611   else
00612   {
00613     strncpy(column->orig_table, orig_table, DRIZZLE_MAX_TABLE_SIZE);
00614     column->orig_table[DRIZZLE_MAX_TABLE_SIZE - 1]= 0;
00615   }
00616 }
00617 
00618 void drizzle_column_set_name(drizzle_column_st *column, const char *name)
00619 {
00620   if (name == NULL)
00621     column->name[0]= 0;
00622   else
00623   {
00624     strncpy(column->name, name, DRIZZLE_MAX_COLUMN_NAME_SIZE);
00625     column->name[DRIZZLE_MAX_COLUMN_NAME_SIZE - 1]= 0;
00626   }
00627 }
00628 
00629 void drizzle_column_set_orig_name(drizzle_column_st *column,
00630                                   const char *orig_name)
00631 {
00632   if (orig_name == NULL)
00633     column->orig_name[0]= 0;
00634   else
00635   {
00636     strncpy(column->orig_name, orig_name, DRIZZLE_MAX_COLUMN_NAME_SIZE);
00637     column->orig_name[DRIZZLE_MAX_COLUMN_NAME_SIZE - 1]= 0;
00638   }
00639 }
00640 
00641 void drizzle_column_set_charset(drizzle_column_st *column,
00642                                 drizzle_charset_t charset)
00643 {
00644   column->charset= charset;
00645 }
00646 
00647 void drizzle_column_set_size(drizzle_column_st *column, uint32_t size)
00648 {
00649   column->size= size;
00650 }
00651 
00652 void drizzle_column_set_type(drizzle_column_st *column,
00653                              drizzle_column_type_t type)
00654 {
00655   column->type= type;
00656 }
00657 
00658 void drizzle_column_set_flags(drizzle_column_st *column,
00659                               drizzle_column_flags_t flags)
00660 {
00661   column->flags= flags;
00662 }
00663 
00664 void drizzle_column_set_decimals(drizzle_column_st *column, uint8_t decimals)
00665 {
00666   column->decimals= decimals;
00667 }
00668 
00669 void drizzle_column_set_default_value(drizzle_column_st *column,
00670                                       const uint8_t *default_value,
00671                                       size_t size)
00672 {
00673   if (default_value == NULL)
00674     column->default_value[0]= 0;
00675   else
00676   {
00677     if (size < DRIZZLE_MAX_DEFAULT_VALUE_SIZE)
00678     {
00679       memcpy(column->default_value, default_value, size);
00680       column->default_value[size]= 0;
00681       column->default_value_size= size;
00682     }
00683     else
00684     {
00685       memcpy(column->default_value, default_value,
00686              DRIZZLE_MAX_DEFAULT_VALUE_SIZE - 1);
00687       column->default_value[DRIZZLE_MAX_DEFAULT_VALUE_SIZE - 1]= 0;
00688       column->default_value_size= DRIZZLE_MAX_DEFAULT_VALUE_SIZE;
00689     }
00690   }
00691 }
00692 
00693 /*
00694  * Internal state functions.
00695  */
00696 
00697 drizzle_return_t drizzle_state_column_read(drizzle_con_st *con)
00698 {
00699   drizzle_column_st *column;
00700   drizzle_column_type_drizzle_t drizzle_type;
00701 
00702   PDEBUG("drizzle_state_column_read", "%5zu %5zu", con->buffer_size,
00703          con->packet_size)
00704 
00705   /* Assume the entire column packet will fit in the buffer. */
00706   if (con->buffer_size < con->packet_size)
00707   {
00708     DRIZZLE_STATE_PUSH(con, drizzle_state_read)
00709     return DRIZZLE_RETURN_OK;
00710   }
00711 
00712   if (con->packet_size == 5 && con->buffer_ptr[0] == 254)
00713   {
00714     /* EOF packet marking end of columns. */
00715     con->result->column= NULL;
00716     con->result->warning_count= DRIZZLE_GET_BYTE2(con->buffer_ptr + 1);
00717     con->status= DRIZZLE_GET_BYTE2(con->buffer_ptr + 3);
00718     con->buffer_ptr+= 5;
00719     con->buffer_size-= 5;
00720 
00721     DRIZZLE_STATE_POP(con)
00722   }
00723   else if (con->result->options & DRIZZLE_RESULT_SKIP_COLUMN)
00724   {
00725     con->buffer_ptr+= con->packet_size;
00726     con->buffer_size-= con->packet_size;
00727     con->packet_size= 0;
00728 
00729     DRIZZLE_STATE_PUSH(con, drizzle_state_packet_read)
00730   }
00731   else
00732   {
00733     column= drizzle_column_create(con->result, con->result->column);
00734     if (column == NULL)
00735       return DRIZZLE_RETURN_MEMORY;
00736 
00737     con->result->column= column;
00738 
00739     /* These functions can only fail if they need to read data, but we know we
00740        buffered the entire packet, so ignore returns. */
00741     (void)drizzle_unpack_string(con, column->catalog, DRIZZLE_MAX_CATALOG_SIZE);
00742     (void)drizzle_unpack_string(con, column->db, DRIZZLE_MAX_DB_SIZE);
00743     (void)drizzle_unpack_string(con, column->table, DRIZZLE_MAX_TABLE_SIZE);
00744     (void)drizzle_unpack_string(con, column->orig_table,
00745                                 DRIZZLE_MAX_TABLE_SIZE);
00746     (void)drizzle_unpack_string(con, column->name,
00747                                 DRIZZLE_MAX_COLUMN_NAME_SIZE);
00748     (void)drizzle_unpack_string(con, column->orig_name,
00749                                 DRIZZLE_MAX_COLUMN_NAME_SIZE);
00750 
00751     /* Skip one filler byte. */
00752     column->charset= (drizzle_charset_t)DRIZZLE_GET_BYTE2(con->buffer_ptr + 1);
00753     column->size= DRIZZLE_GET_BYTE4(con->buffer_ptr + 3);
00754 
00755     if (con->options & DRIZZLE_CON_MYSQL)
00756       column->type= con->buffer_ptr[7];
00757     else
00758     {
00759       drizzle_type= con->buffer_ptr[7];
00760       if (drizzle_type >= DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX)
00761         drizzle_type= DRIZZLE_COLUMN_TYPE_DRIZZLE_MAX;
00762       column->type= _column_type_drizzle_map_to[drizzle_type];
00763     }
00764 
00765     column->flags= DRIZZLE_GET_BYTE2(con->buffer_ptr + 8);
00766     if (column->type <= DRIZZLE_COLUMN_TYPE_INT24 &&
00767         column->type != DRIZZLE_COLUMN_TYPE_TIMESTAMP)
00768     {
00769       column->flags|= DRIZZLE_COLUMN_FLAGS_NUM;
00770     }
00771 
00772     column->decimals= con->buffer_ptr[10];
00773     /* Skip two reserved bytes. */
00774 
00775     con->buffer_ptr+= 13;
00776     con->buffer_size-= 13;
00777     con->packet_size-= 13;
00778 
00779     if (con->packet_size > 0)
00780     {
00781       drizzle_column_set_default_value(column, con->buffer_ptr,
00782                                        con->packet_size);
00783 
00784       con->buffer_ptr+= con->packet_size;
00785       con->buffer_size-= con->packet_size;
00786     }
00787     else
00788       column->default_value[0]= 0;
00789 
00790     con->result->column_current++;
00791 
00792     DRIZZLE_STATE_POP(con)
00793   }
00794 
00795   return DRIZZLE_RETURN_OK;
00796 }
00797 
00798 drizzle_return_t drizzle_state_column_write(drizzle_con_st *con)
00799 {
00800   uint8_t *start= con->buffer_ptr + con->buffer_size;
00801   uint8_t *ptr;
00802   drizzle_column_st *column= con->result->column;
00803 
00804   /* Calculate max packet size. */
00805   con->packet_size= 9 + strlen(column->catalog)
00806                   + 9 + strlen(column->db)
00807                   + 9 + strlen(column->table)
00808                   + 9 + strlen(column->orig_table)
00809                   + 9 + strlen(column->name)
00810                   + 9 + strlen(column->orig_name)
00811                   + 1   /* Unused */
00812                   + 2   /* Charset */
00813                   + 4   /* Size */
00814                   + 1   /* Type */
00815                   + 2   /* Flags */
00816                   + 1   /* Decimals */
00817                   + 2   /* Unused */
00818                   + column->default_value_size;
00819 
00820   /* Assume the entire column packet will fit in the buffer. */
00821   if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
00822   {
00823     DRIZZLE_ERROR_SET(con->drizzle, "drizzle_state_column_write",
00824                       "buffer too small:%zu", con->packet_size + 4)
00825     return DRIZZLE_RETURN_INTERNAL_ERROR;
00826   }
00827 
00828   /* Flush buffer if there is not enough room. */
00829   if (((size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer)) <
00830       con->packet_size)
00831   {
00832     DRIZZLE_STATE_PUSH(con, drizzle_state_write)
00833     return DRIZZLE_RETURN_OK;
00834   }
00835 
00836   /* Store packet size at the end since it may change. */
00837   ptr= start;
00838   ptr[3]= con->packet_number;
00839   con->packet_number++;
00840   ptr+= 4;
00841 
00842   ptr= drizzle_pack_string(column->catalog, ptr);
00843   ptr= drizzle_pack_string(column->db, ptr);
00844   ptr= drizzle_pack_string(column->table, ptr);
00845   ptr= drizzle_pack_string(column->orig_table, ptr);
00846   ptr= drizzle_pack_string(column->name, ptr);
00847   ptr= drizzle_pack_string(column->orig_name, ptr);
00848 
00849   /* This unused byte is set to 12 for some reason. */
00850   ptr[0]= 12;
00851   ptr++;
00852 
00853   DRIZZLE_SET_BYTE2(ptr, column->charset)
00854   ptr+= 2;
00855 
00856   DRIZZLE_SET_BYTE4(ptr, column->size)
00857   ptr+= 4;
00858 
00859   ptr[0]= column->type;
00860   ptr++;
00861 
00862   DRIZZLE_SET_BYTE2(ptr, column->flags)
00863   ptr+= 2;
00864 
00865   ptr[0]= column->decimals;
00866   ptr++;
00867 
00868   memset(ptr, 0, 2);
00869   ptr+= 2;
00870 
00871   if (column->default_value_size > 0)
00872   {
00873     memcpy(ptr, column->default_value, column->default_value_size);
00874     ptr+= column->default_value_size;
00875   }
00876 
00877   con->packet_size= ((size_t)(ptr - start) - 4);
00878   con->buffer_size+= (4 + con->packet_size);
00879 
00880   /* Store packet size now. */
00881   DRIZZLE_SET_BYTE3(start, con->packet_size)
00882 
00883   con->result->column_current++;
00884 
00885   DRIZZLE_STATE_POP(con)
00886 
00887   return DRIZZLE_RETURN_OK;
00888 }
libdrizzle Developer Documentation

libdrizzle/column.c
