← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/row.cc

  • Committer: Mark Atwood
  • Date: 2011-12-22 04:39:00 UTC
  • mfrom: (2472.1.2 drizzle-build)
  • Revision ID: me@mark.atwood.name-20111222043900-utca466m80z3gj61
merge lp:~brianaker/drizzle/null-safety-fix-libdrizzle

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/row.cc
48
48
 
49
49
uint64_t drizzle_row_read(drizzle_result_st *result, drizzle_return_t *ret_ptr)
50
50
{
 
51
  drizzle_return_t unused_ret;
 
52
  if (ret_ptr == NULL)
 
53
  {
 
54
    ret_ptr= &unused_ret;
 
55
  }
 
56
 
 
57
  if (result == NULL)
 
58
  {
 
59
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
60
    return 0;
 
61
  }
 
62
 
51
63
  if ((result->column_current != result->column_count) && (!(result->options & DRIZZLE_RESULT_BUFFER_COLUMN)))
52
64
  {
53
65
    drizzle_set_error(result->con->drizzle, "drizzle_row_read", "cannot retrieve rows until all columns are retrieved");
69
81
drizzle_row_t drizzle_row_buffer(drizzle_result_st *result,
70
82
                                 drizzle_return_t *ret_ptr)
71
83
{
 
84
  drizzle_return_t unused_ret;
 
85
  if (ret_ptr == NULL)
 
86
  {
 
87
    ret_ptr= &unused_ret;
 
88
  }
 
89
 
 
90
  if (result == NULL)
 
91
  {
 
92
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
93
    return 0;
 
94
  }
 
95
 
72
96
  size_t total;
73
97
  drizzle_field_t field;
74
98
  drizzle_row_t row;
122
146
 
123
147
void drizzle_row_free(drizzle_result_st *result, drizzle_row_t row)
124
148
{
 
149
  if (result == NULL)
 
150
  {
 
151
    return;
 
152
  }
 
153
 
125
154
  for (uint16_t x= 0; x < result->column_count; x++)
126
155
  {
127
156
    drizzle_field_free(row[x]);
132
161
 
133
162
size_t *drizzle_row_field_sizes(drizzle_result_st *result)
134
163
{
 
164
  if (result == NULL)
 
165
  {
 
166
    return NULL;
 
167
  }
 
168
 
135
169
  return result->field_sizes;
136
170
}
137
171
 
138
172
drizzle_row_t drizzle_row_next(drizzle_result_st *result)
139
173
{
 
174
  if (result == NULL)
 
175
  {
 
176
    return drizzle_row_t();
 
177
  }
 
178
 
140
179
  if (result->row_current == result->row_count)
 
180
  {
141
181
    return NULL;
 
182
  }
142
183
 
143
184
  result->field_sizes= result->field_sizes_list[result->row_current];
144
185
  result->row_current++;
147
188
 
148
189
drizzle_row_t drizzle_row_prev(drizzle_result_st *result)
149
190
{
 
191
  if (result == NULL)
 
192
  {
 
193
    return drizzle_row_t();
 
194
  }
 
195
 
150
196
  if (result->row_current == 0)
151
197
    return NULL;
152
198
 
157
203
 
158
204
void drizzle_row_seek(drizzle_result_st *result, uint64_t row)
159
205
{
 
206
  if (result == NULL)
 
207
  {
 
208
    return;
 
209
  }
 
210
 
160
211
  if (row <= result->row_count)
161
212
    result->row_current= row;
162
213
}
163
214
 
164
215
drizzle_row_t drizzle_row_index(drizzle_result_st *result, uint64_t row)
165
216
{
 
217
  if (result == NULL)
 
218
  {
 
219
    return drizzle_row_t();
 
220
  }
 
221
 
166
222
  if (row >= result->row_count)
167
223
    return NULL;
168
224
 
171
227
 
172
228
uint64_t drizzle_row_current(drizzle_result_st *result)
173
229
{
 
230
  if (result == NULL)
 
231
  {
 
232
    return 0;
 
233
  }
 
234
 
174
235
  return result->row_current;
175
236
}
176
237
 
180
241
 
181
242
drizzle_return_t drizzle_row_write(drizzle_result_st *result)
182
243
{
 
244
  if (result == NULL)
 
245
  {
 
246
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
247
  }
 
248
 
183
249
  if (drizzle_state_none(result->con))
 
250
  {
184
251
    drizzle_state_push(result->con, drizzle_state_row_write);
 
252
  }
185
253
 
186
254
  return drizzle_state_loop(result->con);
187
255
}
192
260
 
193
261
drizzle_return_t drizzle_state_row_read(drizzle_con_st *con)
194
262
{
 
263
  if (con == NULL)
 
264
  {
 
265
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
266
  }
 
267
 
195
268
  drizzle_log_debug(con->drizzle, "drizzle_state_row_read");
196
269
 
197
270
  if (con->packet_size != 0 && con->buffer_size < con->packet_size && 
233
306
 
234
307
drizzle_return_t drizzle_state_row_write(drizzle_con_st *con)
235
308
{
 
309
  if (con == NULL)
 
310
  {
 
311
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
312
  }
 
313
 
236
314
  uint8_t *start= con->buffer_ptr + con->buffer_size;
237
315
 
238
316
  drizzle_log_debug(con->drizzle, "drizzle_state_row_write");