← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/result.cc

  • Committer: Brian Aker
  • Date: 2011-11-05 03:32:21 UTC
  • mto: This revision was merged to the branch mainline in revision 2453.
  • Revision ID: brian@tangent.org-20111105033221-a3d0wmmzddcmdt81
Fix libdrizzle pc support (and restore older .pc file to fix older compiles).

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