49 drizzle_result_st *drizzle_result_create(drizzle_con_st *con,
50 drizzle_result_st *result)
59 result=
new (std::nothrow) drizzle_result_st;
66 result->options|= DRIZZLE_RESULT_ALLOCATED;
70 memset(result, 0,
sizeof(drizzle_result_st));
77 con->result_list->prev= result;
78 result->next= con->result_list;
79 con->result_list= result;
85 drizzle_result_st *drizzle_result_clone(drizzle_con_st *con,
86 drizzle_result_st *result,
87 drizzle_result_st *from)
90 result= drizzle_result_create(con, result);
96 result->options|= (from->options & ~int(DRIZZLE_RESULT_ALLOCATED));
98 drizzle_result_set_info(result, from->info);
99 result->error_code= from->error_code;
100 drizzle_result_set_sqlstate(result, from->sqlstate);
101 result->warning_count= from->warning_count;
102 result->insert_id= from->insert_id;
103 result->affected_rows= from->affected_rows;
104 result->column_count= from->column_count;
105 result->row_count= from->row_count;
110 void drizzle_result_free(drizzle_result_st *result)
117 for (drizzle_column_st* column= result->column_list; column != NULL; column= result->column_list)
119 drizzle_column_free(column);
122 delete [] result->column_buffer;
124 if (result->options & DRIZZLE_RESULT_BUFFER_ROW)
126 for (uint64_t x= 0; x < result->row_count; x++)
128 drizzle_row_free(result, result->row_list[x]);
131 free(result->row_list);
132 free(result->field_sizes_list);
137 result->con->result_count--;
138 if (result->con->result_list == result)
139 result->con->result_list= result->next;
144 result->prev->next= result->next;
148 result->next->prev= result->prev;
151 if (result->options & DRIZZLE_RESULT_ALLOCATED)
157 void drizzle_result_free_all(drizzle_con_st *con)
164 while (con->result_list != NULL)
166 drizzle_result_free(con->result_list);
170 drizzle_con_st *drizzle_result_drizzle_con(drizzle_result_st *result)
180 bool drizzle_result_eof(drizzle_result_st *result)
187 return result->options & DRIZZLE_RESULT_EOF_PACKET;
190 const char *drizzle_result_info(drizzle_result_st *result)
200 const char *drizzle_result_error(drizzle_result_st *result)
210 uint16_t drizzle_result_error_code(drizzle_result_st *result)
217 return result->error_code;
220 const char *drizzle_result_sqlstate(drizzle_result_st *result)
227 return result->sqlstate;
230 uint16_t drizzle_result_warning_count(drizzle_result_st *result)
237 return result->warning_count;
240 uint64_t drizzle_result_insert_id(drizzle_result_st *result)
247 return result->insert_id;
250 uint64_t drizzle_result_affected_rows(drizzle_result_st *result)
257 return result->affected_rows;
260 uint16_t drizzle_result_column_count(drizzle_result_st *result)
267 return result->column_count;
270 uint64_t drizzle_result_row_count(drizzle_result_st *result)
277 return result->row_count;
284 drizzle_result_st *drizzle_result_read(drizzle_con_st *con,
285 drizzle_result_st *result,
286 drizzle_return_t *ret_ptr)
288 drizzle_return_t unused;
296 *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
302 con->result= drizzle_result_create(con, result);
303 if (con->result == NULL)
305 *ret_ptr= DRIZZLE_RETURN_MEMORY;
317 drizzle_return_t drizzle_result_buffer(drizzle_result_st *result)
321 return DRIZZLE_RETURN_INVALID_ARGUMENT;
324 drizzle_return_t ret;
326 drizzle_row_t *row_list;
327 size_t **field_sizes_list;
329 if (!(result->options & DRIZZLE_RESULT_BUFFER_COLUMN))
331 ret= drizzle_column_buffer(result);
332 if (ret != DRIZZLE_RETURN_OK)
336 if (result->column_count == 0)
338 result->options|= DRIZZLE_RESULT_BUFFER_ROW;
339 return DRIZZLE_RETURN_OK;
344 row= drizzle_row_buffer(result, &ret);
345 if (ret != DRIZZLE_RETURN_OK)
351 if (result->row_list_size < result->row_count)
353 row_list= (drizzle_row_t *)realloc(result->row_list,
sizeof(drizzle_row_t) * ((size_t)(result->row_list_size) + DRIZZLE_ROW_GROW_SIZE));
354 if (row_list == NULL)
356 drizzle_row_free(result, row);
357 drizzle_set_error(result->con->drizzle, __func__,
"Failed to realloc row_list.");
358 return DRIZZLE_RETURN_MEMORY;
361 result->row_list= row_list;
363 field_sizes_list= (
size_t **)realloc(result->field_sizes_list,
sizeof(
size_t *) * ((size_t)(result->row_list_size) + DRIZZLE_ROW_GROW_SIZE));
364 if (field_sizes_list == NULL)
366 drizzle_row_free(result, row);
367 drizzle_set_error(result->con->drizzle,
"drizzle_result_buffer",
"Failed to realloc field list.");
368 return DRIZZLE_RETURN_MEMORY;
371 result->field_sizes_list= field_sizes_list;
373 result->row_list_size+= DRIZZLE_ROW_GROW_SIZE;
376 result->row_list[result->row_current - 1]= row;
377 result->field_sizes_list[result->row_current - 1]= result->field_sizes;
380 result->options|= DRIZZLE_RESULT_BUFFER_ROW;
381 return DRIZZLE_RETURN_OK;
384 size_t drizzle_result_row_size(drizzle_result_st *result)
391 return result->con->packet_size;
398 drizzle_return_t drizzle_result_write(drizzle_con_st *con,
399 drizzle_result_st *result,
bool flush)
403 return DRIZZLE_RETURN_INVALID_ARGUMENT;
419 void drizzle_result_set_row_size(drizzle_result_st *result,
size_t size)
426 result->con->packet_size= size;
429 void drizzle_result_calc_row_size(drizzle_result_st *result,
430 const drizzle_field_t *field,
438 result->con->packet_size= 0;
440 for (uint16_t x= 0; x < result->column_count; x++)
442 if (field[x] == NULL)
444 result->con->packet_size++;
446 else if (size[x] < 251)
448 result->con->packet_size+= (1 + size[x]);
450 else if (size[x] < 65536)
452 result->con->packet_size+= (3 + size[x]);
454 else if (size[x] < 16777216)
456 result->con->packet_size+= (4 + size[x]);
460 result->con->packet_size+= (9 + size[x]);
465 void drizzle_result_set_eof(drizzle_result_st *result,
bool is_eof)
473 result->options|= DRIZZLE_RESULT_EOF_PACKET;
475 result->options&= ~int(DRIZZLE_RESULT_EOF_PACKET);
478 void drizzle_result_set_info(drizzle_result_st *result,
const char *info)
491 strncpy(result->info, info, DRIZZLE_MAX_INFO_SIZE);
492 result->info[DRIZZLE_MAX_INFO_SIZE - 1]= 0;
496 void drizzle_result_set_error(drizzle_result_st *result,
const char *error)
503 drizzle_result_set_info(result, error);
506 void drizzle_result_set_error_code(drizzle_result_st *result,
514 result->error_code= error_code;
517 void drizzle_result_set_sqlstate(drizzle_result_st *result,
518 const char *sqlstate)
525 if (sqlstate == NULL)
527 result->sqlstate[0]= 0;
531 strncpy(result->sqlstate, sqlstate, DRIZZLE_MAX_SQLSTATE_SIZE + 1);
532 result->sqlstate[DRIZZLE_MAX_SQLSTATE_SIZE]= 0;
536 void drizzle_result_set_warning_count(drizzle_result_st *result,
537 uint16_t warning_count)
544 result->warning_count= warning_count;
547 void drizzle_result_set_insert_id(drizzle_result_st *result,
555 result->insert_id= insert_id;
558 void drizzle_result_set_affected_rows(drizzle_result_st *result,
559 uint64_t affected_rows)
566 result->affected_rows= affected_rows;
569 void drizzle_result_set_column_count(drizzle_result_st *result,
570 uint16_t column_count)
577 result->column_count= column_count;
584 drizzle_return_t drizzle_state_result_read(drizzle_con_st *con)
586 drizzle_return_t ret;
590 return DRIZZLE_RETURN_INVALID_ARGUMENT;
596 if (con->buffer_size < con->packet_size)
599 return DRIZZLE_RETURN_OK;
602 if (con->buffer_ptr[0] == 0)
608 con->status= drizzle_con_status_t(drizzle_get_byte2(con->buffer_ptr));
609 con->result->warning_count= drizzle_get_byte2(con->buffer_ptr + 2);
611 con->buffer_size-= 5;
612 con->packet_size-= 5;
613 if (con->packet_size > 0)
617 con->buffer_size-= 1;
618 con->packet_size-= 1;
620 ret= DRIZZLE_RETURN_OK;
622 else if (con->buffer_ptr[0] == 254)
624 con->result->options= DRIZZLE_RESULT_EOF_PACKET;
625 con->result->warning_count= drizzle_get_byte2(con->buffer_ptr + 1);
626 con->status= drizzle_con_status_t(drizzle_get_byte2(con->buffer_ptr + 3));
628 con->buffer_size-= 5;
629 con->packet_size-= 5;
630 ret= DRIZZLE_RETURN_OK;
632 else if (con->buffer_ptr[0] == 255)
634 con->result->error_code= drizzle_get_byte2(con->buffer_ptr + 1);
635 con->drizzle->error_code= con->result->error_code;
637 memcpy(con->result->sqlstate, con->buffer_ptr + 4,
638 DRIZZLE_MAX_SQLSTATE_SIZE);
639 con->result->sqlstate[DRIZZLE_MAX_SQLSTATE_SIZE]= 0;
640 memcpy(con->drizzle->sqlstate, con->result->sqlstate,
641 DRIZZLE_MAX_SQLSTATE_SIZE + 1);
643 con->buffer_size-= 9;
644 con->packet_size-= 9;
645 ret= DRIZZLE_RETURN_ERROR_CODE;
651 ret= DRIZZLE_RETURN_OK;
654 if (con->packet_size > 0)
656 snprintf(con->drizzle->last_error, DRIZZLE_MAX_ERROR_SIZE,
"%.*s",
657 (int32_t)con->packet_size, con->buffer_ptr);
658 con->drizzle->last_error[DRIZZLE_MAX_ERROR_SIZE-1]= 0;
659 snprintf(con->result->info, DRIZZLE_MAX_INFO_SIZE,
"%.*s",
660 (int32_t)con->packet_size, con->buffer_ptr);
661 con->result->info[DRIZZLE_MAX_INFO_SIZE-1]= 0;
662 con->buffer_ptr+= con->packet_size;
663 con->buffer_size-= con->packet_size;
671 drizzle_return_t drizzle_state_result_write(drizzle_con_st *con)
675 return DRIZZLE_RETURN_INVALID_ARGUMENT;
678 uint8_t *start= con->buffer_ptr + con->buffer_size;
680 drizzle_result_st *result= con->result;
690 + strlen(result->info);
693 if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
696 "buffer too small:%zu", con->packet_size + 4);
697 return DRIZZLE_RETURN_INTERNAL_ERROR;
701 if (((
size_t)DRIZZLE_MAX_BUFFER_SIZE - (
size_t)(start - con->buffer)) <
705 return DRIZZLE_RETURN_OK;
710 ptr[3]= con->packet_number;
711 con->packet_number++;
714 if (result->options & DRIZZLE_RESULT_EOF_PACKET)
719 drizzle_set_byte2(ptr, result->warning_count);
722 drizzle_set_byte2(ptr, con->status);
725 else if (result->error_code != 0)
730 drizzle_set_byte2(ptr, result->error_code);
736 memcpy(ptr, result->sqlstate, DRIZZLE_MAX_SQLSTATE_SIZE);
737 ptr+= DRIZZLE_MAX_SQLSTATE_SIZE;
739 memcpy(ptr, result->info, strlen(result->info));
740 ptr+= strlen(result->info);
742 else if (result->column_count == 0)
750 drizzle_set_byte2(ptr, con->status);
753 drizzle_set_byte2(ptr, result->warning_count);
756 memcpy(ptr, result->info, strlen(result->info));
757 ptr+= strlen(result->info);
762 con->packet_size= ((size_t)(ptr - start) - 4);
763 con->buffer_size+= (4 + con->packet_size);
766 drizzle_set_byte3(start, con->packet_size);
769 return DRIZZLE_RETURN_OK;
static void drizzle_state_pop(drizzle_con_st *con)
static bool drizzle_state_none(drizzle_con_st *con)
static void drizzle_state_push(drizzle_con_st *con, drizzle_state_fn *function)
void drizzle_set_error(drizzle_st *drizzle, const char *function, const char *format,...)
drizzle_return_t drizzle_state_loop(drizzle_con_st *con)
static void drizzle_log_debug(drizzle_st *drizzle, const char *format,...)
uint8_t * drizzle_pack_length(uint64_t number, uint8_t *ptr)
uint64_t drizzle_unpack_length(drizzle_con_st *con, drizzle_return_t *ret_ptr)