← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/result.cc

  • Committer: Mark Atwood
  • Date: 2011-11-07 22:27:02 UTC
  • mfrom: (2449.1.4 drizzle-build)
  • Revision ID: me@mark.atwood.name-20111107222702-crj09kujv9awkylo
merge lp:~brianaker/drizzle/libdrizzle-update

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/result.cc
107
107
{
108
108
  result= drizzle_result_create(con, result);
109
109
  if (result == NULL)
 
110
  {
110
111
    return NULL;
 
112
  }
111
113
 
112
114
  result->options|= from->options & ~DRIZZLE_RESULT_ALLOCATED;
113
115
 
128
130
  drizzle_column_st *column;
129
131
  uint64_t x;
130
132
 
 
133
  if (result == NULL)
 
134
  {
 
135
    return;
 
136
  }
 
137
 
131
138
  for (column= result->column_list; column != NULL; column= result->column_list)
 
139
  {
132
140
    drizzle_column_free(column);
 
141
  }
133
142
 
134
143
  delete[] result->column_buffer;
135
144
 
160
169
void drizzle_result_free_all(drizzle_con_st *con)
161
170
{
162
171
  while (con->result_list != NULL)
 
172
  {
163
173
    drizzle_result_free(con->result_list);
 
174
  }
164
175
}
165
176
 
166
177
drizzle_con_st *drizzle_result_drizzle_con(drizzle_result_st *result)
167
178
{
 
179
  if (result == NULL)
 
180
  {
 
181
    return NULL;
 
182
  }
 
183
 
168
184
  return result->con;
169
185
}
170
186
 
171
187
bool drizzle_result_eof(drizzle_result_st *result)
172
188
{
 
189
  if (result == NULL)
 
190
  {
 
191
    return false;
 
192
  }
 
193
 
173
194
  return (result->options & DRIZZLE_RESULT_EOF_PACKET) ? true : false;
174
195
}
175
196
 
176
197
const char *drizzle_result_info(drizzle_result_st *result)
177
198
{
 
199
  if (result == NULL)
 
200
  {
 
201
    return NULL;
 
202
  }
 
203
 
178
204
  return result->info;
179
205
}
180
206
 
181
207
const char *drizzle_result_error(drizzle_result_st *result)
182
208
{
 
209
  if (result == NULL)
 
210
  {
 
211
    return NULL;
 
212
  }
 
213
 
183
214
  return result->info;
184
215
}
185
216
 
186
217
uint16_t drizzle_result_error_code(drizzle_result_st *result)
187
218
{
 
219
  if (result == NULL)
 
220
  {
 
221
    return 0;
 
222
  }
 
223
 
188
224
  return result->error_code;
189
225
}
190
226
 
191
227
const char *drizzle_result_sqlstate(drizzle_result_st *result)
192
228
{
 
229
  if (result == NULL)
 
230
  {
 
231
    return NULL;
 
232
  }
 
233
 
193
234
  return result->sqlstate;
194
235
}
195
236
 
196
237
uint16_t drizzle_result_warning_count(drizzle_result_st *result)
197
238
{
 
239
  if (result == NULL)
 
240
  {
 
241
    return 0;
 
242
  }
 
243
 
198
244
  return result->warning_count;
199
245
}
200
246
 
201
247
uint64_t drizzle_result_insert_id(drizzle_result_st *result)
202
248
{
 
249
  if (result == NULL)
 
250
  {
 
251
    return 0;
 
252
  }
 
253
 
203
254
  return result->insert_id;
204
255
}
205
256
 
206
257
uint64_t drizzle_result_affected_rows(drizzle_result_st *result)
207
258
{
 
259
  if (result == NULL)
 
260
  {
 
261
    return 0;
 
262
  }
 
263
 
208
264
  return result->affected_rows;
209
265
}
210
266
 
211
267
uint16_t drizzle_result_column_count(drizzle_result_st *result)
212
268
{
 
269
  if (result == NULL)
 
270
  {
 
271
    return 0;
 
272
  }
 
273
 
213
274
  return result->column_count;
214
275
}
215
276
 
216
277
uint64_t drizzle_result_row_count(drizzle_result_st *result)
217
278
{
 
279
  if (result == NULL)
 
280
  {
 
281
    return 0;
 
282
  }
 
283
 
218
284
  return result->row_count;
219
285
}
220
286
 
226
292
                                       drizzle_result_st *result,
227
293
                                       drizzle_return_t *ret_ptr)
228
294
{
 
295
  drizzle_return_t unused;
 
296
  if (ret_ptr == NULL)
 
297
  {
 
298
    ret_ptr= &unused;
 
299
  }
 
300
 
 
301
  if (con == NULL)
 
302
  {
 
303
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
304
    return NULL;
 
305
  }
 
306
 
229
307
  if (drizzle_state_none(con))
230
308
  {
231
309
    con->result= drizzle_result_create(con, result);
245
323
 
246
324
drizzle_return_t drizzle_result_buffer(drizzle_result_st *result)
247
325
{
 
326
  if (result == NULL)
 
327
  {
 
328
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
329
  }
 
330
 
248
331
  drizzle_return_t ret;
249
332
  drizzle_row_t row;
250
333
 
291
374
 
292
375
size_t drizzle_result_row_size(drizzle_result_st *result)
293
376
{
 
377
  if (result == NULL)
 
378
  {
 
379
    return 0;
 
380
  }
 
381
 
294
382
  return result->con->packet_size;
295
383
}
296
384
 
301
389
drizzle_return_t drizzle_result_write(drizzle_con_st *con,
302
390
                                      drizzle_result_st *result, bool flush)
303
391
{
 
392
  if (con == NULL)
 
393
  {
 
394
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
395
  }
 
396
 
304
397
  if (drizzle_state_none(con))
305
398
  {
306
399
    con->result= result;
316
409
 
317
410
void drizzle_result_set_row_size(drizzle_result_st *result, size_t size)
318
411
{
 
412
  if (result == NULL)
 
413
  {
 
414
    return;
 
415
  }
 
416
 
319
417
  result->con->packet_size= size;
320
418
}
321
419
 
323
421
                                  const drizzle_field_t *field,
324
422
                                  const size_t *size)
325
423
{
 
424
  if (result == NULL)
 
425
  {
 
426
    return;
 
427
  }
 
428
 
326
429
  uint16_t x;
327
430
 
328
431
  result->con->packet_size= 0;
344
447
 
345
448
void drizzle_result_set_eof(drizzle_result_st *result, bool is_eof)
346
449
{
 
450
  if (result == NULL)
 
451
  {
 
452
    return;
 
453
  }
 
454
 
347
455
  if (is_eof)
348
456
    result->options|= DRIZZLE_RESULT_EOF_PACKET;
349
457
  else
352
460
 
353
461
void drizzle_result_set_info(drizzle_result_st *result, const char *info)
354
462
{
 
463
  if (result == NULL)
 
464
  {
 
465
    return;
 
466
  }
 
467
 
355
468
  if (info == NULL)
 
469
  {
356
470
    result->info[0]= 0;
 
471
  }
357
472
  else
358
473
  {
359
474
    strncpy(result->info, info, DRIZZLE_MAX_INFO_SIZE);
363
478
 
364
479
void drizzle_result_set_error(drizzle_result_st *result, const char *error)
365
480
{
 
481
  if (result == NULL)
 
482
  {
 
483
    return;
 
484
  }
 
485
 
366
486
  drizzle_result_set_info(result, error);
367
487
}
368
488
 
369
489
void drizzle_result_set_error_code(drizzle_result_st *result,
370
490
                                   uint16_t error_code)
371
491
{
 
492
  if (result == NULL)
 
493
  {
 
494
    return;
 
495
  }
 
496
 
372
497
  result->error_code= error_code;
373
498
}
374
499
 
375
500
void drizzle_result_set_sqlstate(drizzle_result_st *result,
376
501
                                 const char *sqlstate)
377
502
{
 
503
  if (result == NULL)
 
504
  {
 
505
    return;
 
506
  }
 
507
 
378
508
  if (sqlstate == NULL)
 
509
  {
379
510
    result->sqlstate[0]= 0;
 
511
  }
380
512
  else
381
513
  {
382
514
    strncpy(result->sqlstate, sqlstate, DRIZZLE_MAX_SQLSTATE_SIZE + 1);
387
519
void drizzle_result_set_warning_count(drizzle_result_st *result,
388
520
                                      uint16_t warning_count)
389
521
{
 
522
  if (result == NULL)
 
523
  {
 
524
    return;
 
525
  }
 
526
 
390
527
  result->warning_count= warning_count;
391
528
}
392
529
 
393
530
void drizzle_result_set_insert_id(drizzle_result_st *result,
394
531
                                  uint64_t insert_id)
395
532
{
 
533
  if (result == NULL)
 
534
  {
 
535
    return;
 
536
  }
 
537
 
396
538
  result->insert_id= insert_id;
397
539
}
398
540
 
399
541
void drizzle_result_set_affected_rows(drizzle_result_st *result,
400
542
                                      uint64_t affected_rows)
401
543
{
 
544
  if (result == NULL)
 
545
  {
 
546
    return;
 
547
  }
 
548
 
402
549
  result->affected_rows= affected_rows;
403
550
}
404
551
 
405
552
void drizzle_result_set_column_count(drizzle_result_st *result,
406
553
                                     uint16_t column_count)
407
554
{
 
555
  if (result == NULL)
 
556
  {
 
557
    return;
 
558
  }
 
559
 
408
560
  result->column_count= column_count;
409
561
}
410
562
 
416
568
{
417
569
  drizzle_return_t ret;
418
570
 
 
571
  if (con == NULL)
 
572
  {
 
573
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
574
  }
 
575
 
 
576
 
419
577
  drizzle_log_debug(con->drizzle, "drizzle_state_result_read");
420
578
 
421
579
  /* Assume the entire result packet will fit in the buffer. */
496
654
 
497
655
drizzle_return_t drizzle_state_result_write(drizzle_con_st *con)
498
656
{
 
657
  if (con == NULL)
 
658
  {
 
659
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
660
  }
 
661
 
499
662
  uint8_t *start= con->buffer_ptr + con->buffer_size;
500
663
  uint8_t *ptr;
501
664
  drizzle_result_st *result= con->result;