← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/field.cc

  • Committer: Mark Atwood
  • Date: 2012-01-04 16:59:32 UTC
  • mfrom: (2478.2.3 real-key-use-catalog)
  • Revision ID: me@mark.atwood.name-20120104165932-cm0xqs4by0u3p4cy
merge lp:~stewart/drizzle/key-use-catalog

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/field.cc
1
 
/*
 
1
/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
2
 *
2
3
 * Drizzle Client & Protocol Library
3
4
 *
4
5
 * Copyright (C) 2008 Eric Day (eday@oddments.org)
39
40
 * @brief Field definitions
40
41
 */
41
42
 
42
 
#include "common.h"
 
43
#include <libdrizzle/common.h>
43
44
 
44
45
/*
45
46
 * Client definitions
49
50
                                   size_t *size, size_t *total,
50
51
                                   drizzle_return_t *ret_ptr)
51
52
{
 
53
  drizzle_return_t unused_ret;
 
54
  if (ret_ptr == NULL)
 
55
  {
 
56
    ret_ptr= &unused_ret;
 
57
  }
 
58
 
 
59
  if (result == NULL)
 
60
  {
 
61
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
62
    return drizzle_field_t();
 
63
  }
 
64
 
52
65
  if (drizzle_state_none(result->con))
53
66
  {
54
67
    if (result->field_current == result->column_count)
61
74
  }
62
75
 
63
76
  *ret_ptr= drizzle_state_loop(result->con);
64
 
  if (*ret_ptr == DRIZZLE_RETURN_OK &&
 
77
  if (*ret_ptr == DRIZZLE_RETURN_OK and
65
78
      result->options & DRIZZLE_RESULT_ROW_BREAK)
66
79
  {
67
80
    *ret_ptr= DRIZZLE_RETURN_ROW_BREAK;
68
81
  }
69
82
 
70
 
  *offset= result->field_offset;
71
 
  *size= result->field_size;
72
 
  *total= result->field_total;
 
83
  if (offset)
 
84
  {
 
85
    *offset= result->field_offset;
 
86
  }
 
87
 
 
88
  if (size)
 
89
  {
 
90
    *size= result->field_size;
 
91
  }
 
92
 
 
93
  if (total)
 
94
  {
 
95
    *total= result->field_total;
 
96
  }
73
97
 
74
98
  return result->field;
75
99
}
77
101
drizzle_field_t drizzle_field_buffer(drizzle_result_st *result, size_t *total,
78
102
                                     drizzle_return_t *ret_ptr)
79
103
{
80
 
  drizzle_field_t field;
81
104
  size_t offset= 0;
82
105
  size_t size= 0;
83
106
 
84
 
  field= drizzle_field_read(result, &offset, &size, total, ret_ptr);
 
107
  drizzle_return_t unused_ret;
 
108
  if (ret_ptr == NULL)
 
109
  {
 
110
    ret_ptr= &unused_ret;
 
111
  }
 
112
 
 
113
  if (result == NULL)
 
114
  {
 
115
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
116
    return drizzle_field_t();
 
117
  }
 
118
 
 
119
  drizzle_field_t field= drizzle_field_read(result, &offset, &size, total, ret_ptr);
 
120
 
85
121
  if (*ret_ptr != DRIZZLE_RETURN_OK)
 
122
  {
86
123
    return NULL;
 
124
  }
87
125
 
88
126
  if (field == NULL)
89
127
  {
93
131
 
94
132
  if (result->field_buffer == NULL)
95
133
  {
96
 
    result->field_buffer= malloc((*total) + 1);
 
134
    result->field_buffer= (drizzle_field_t)realloc(NULL, (*total) +1);
97
135
    if (result->field_buffer == NULL)
98
136
    {
99
 
      drizzle_set_error(result->con->drizzle, "drizzle_field_buffer", "malloc");
 
137
      drizzle_set_error(result->con->drizzle, __func__, "Failed to allocate.");
100
138
      *ret_ptr= DRIZZLE_RETURN_MEMORY;
101
139
      return NULL;
102
140
    }
108
146
  {
109
147
    field= drizzle_field_read(result, &offset, &size, total, ret_ptr);
110
148
    if (*ret_ptr != DRIZZLE_RETURN_OK)
 
149
    {
111
150
      return NULL;
 
151
    }
112
152
 
113
153
    memcpy(result->field_buffer + offset, field, size);
114
154
  }
122
162
 
123
163
void drizzle_field_free(drizzle_field_t field)
124
164
{
125
 
  free(field);
 
165
  if (field)
 
166
  {
 
167
    free(field);
 
168
  }
126
169
}
127
170
 
128
171
/*
133
176
                                     const drizzle_field_t field, size_t size,
134
177
                                     size_t total)
135
178
{
 
179
  if (result == NULL)
 
180
  {
 
181
    return  DRIZZLE_RETURN_INVALID_ARGUMENT;
 
182
  }
 
183
 
136
184
  drizzle_return_t ret;
137
185
 
138
186
  if (drizzle_state_none(result->con))
139
187
  {
140
188
    if (result->options & DRIZZLE_RESULT_ROW_BREAK)
141
189
    {
142
 
      result->options&= (drizzle_result_options_t)~DRIZZLE_RESULT_ROW_BREAK;
 
190
      result->options&= int(~DRIZZLE_RESULT_ROW_BREAK);
143
191
      result->field= field;
144
192
      result->field_size= size;
145
193
    }
172
220
 
173
221
drizzle_return_t drizzle_state_field_read(drizzle_con_st *con)
174
222
{
175
 
  drizzle_return_t ret;
176
 
 
 
223
  if (con == NULL)
 
224
  {
 
225
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
226
  }
177
227
  drizzle_log_debug(con->drizzle, "drizzle_state_field_read");
178
228
 
179
229
  if (con->buffer_size == 0)
188
238
    con->result->field_offset= 0;
189
239
    con->result->field_size= 0;
190
240
 
 
241
    drizzle_return_t ret;
191
242
    con->result->field_total= (size_t)drizzle_unpack_length(con, &ret);
192
243
    if (ret == DRIZZLE_RETURN_NULL_SIZE)
193
244
    {
213
264
                      con->result->field_total);
214
265
 
215
266
    if ((size_t)(con->buffer_size) >= con->result->field_total)
 
267
    {
216
268
      con->result->field_size= con->result->field_total;
 
269
    }
217
270
    else
 
271
    {
218
272
      con->result->field_size= con->buffer_size;
 
273
    }
219
274
  }
220
275
  else
221
276
  {
226
281
                                con->result->field_offset);
227
282
    }
228
283
    else
 
284
    {
229
285
      con->result->field_size= con->buffer_size;
 
286
    }
230
287
  }
231
288
 
232
289
  /* This is a special case when a row is larger than the packet size. */
235
292
    con->result->field_size= con->packet_size;
236
293
 
237
294
    if (con->options & DRIZZLE_CON_RAW_PACKET)
 
295
    {
238
296
      con->result->options|= DRIZZLE_RESULT_ROW_BREAK;
 
297
    }
239
298
    else
240
299
    {
241
300
      drizzle_state_pop(con);
279
338
 
280
339
drizzle_return_t drizzle_state_field_write(drizzle_con_st *con)
281
340
{
 
341
  if (con == NULL)
 
342
  {
 
343
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
344
  }
 
345
 
282
346
  uint8_t *start= con->buffer_ptr + con->buffer_size;
283
347
  uint8_t *ptr;
284
348
  size_t free_size;
287
351
  drizzle_log_debug(con->drizzle, "drizzle_state_field_write");
288
352
 
289
353
  if (result->field == NULL && result->field_total != 0)
 
354
  {
290
355
    return DRIZZLE_RETURN_PAUSE;
 
356
  }
291
357
 
292
358
  free_size= (size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer);
293
359
  ptr= start;
335
401
    result->field= NULL;
336
402
 
337
403
    if (result->field_offset == result->field_total)
 
404
    {
338
405
      drizzle_state_pop(con);
 
406
    }
339
407
    else if (con->packet_size == 0)
340
408
    {
341
409
      con->result->options|= DRIZZLE_RESULT_ROW_BREAK;
343
411
    }
344
412
 
345
413
    drizzle_state_push(con, drizzle_state_write);
 
414
 
346
415
    return DRIZZLE_RETURN_OK;
347
416
  }
348
417
 
349
418
  if (result->field_size == 0)
 
419
  {
350
420
    drizzle_state_pop(con);
 
421
  }
351
422
  else
352
423
  {
353
424
    if (result->field_size < free_size)
372
443
      }
373
444
 
374
445
      if (result->field_size == free_size)
 
446
      {
375
447
        result->field= NULL;
 
448
      }
376
449
      else
377
450
      {
378
451
        result->field+= free_size;