← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-1.0/result.c

  • Committer: Brian Aker
  • Date: 2011-11-07 15:04:16 UTC
  • mto: This revision was merged to the branch mainline in revision 2453.
  • Revision ID: brian@tangent.org-20111107150416-awbp1nq3cekdcjma
Complete update of libdrizzle

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-1.0/result.c
39
39
 * @brief Result definitions
40
40
 */
41
41
 
42
 
#include "common.h"
 
42
#include <libdrizzle-1.0/common.h>
43
43
 
44
44
/*
45
45
 * Common definitions
48
48
drizzle_result_st *drizzle_result_create(drizzle_con_st *con,
49
49
                                         drizzle_result_st *result)
50
50
{
 
51
  if (con == NULL)
 
52
  {
 
53
    return NULL;
 
54
  }
 
55
 
51
56
  if (result == NULL)
52
57
  {
53
58
    result= malloc(sizeof(drizzle_result_st));
61
66
    result->options|= DRIZZLE_RESULT_ALLOCATED;
62
67
  }
63
68
  else
 
69
  {
64
70
    memset(result, 0, sizeof(drizzle_result_st));
 
71
  }
65
72
 
66
73
  result->con= con;
67
74
  con->result= result;
79
86
                                        drizzle_result_st *result,
80
87
                                        drizzle_result_st *from)
81
88
{
 
89
  // A NULL con will return a NULL result
82
90
  result= drizzle_result_create(con, result);
83
91
  if (result == NULL)
 
92
  {
84
93
    return NULL;
 
94
  }
85
95
 
86
96
  result->options|= (from->options &
87
97
                     (drizzle_result_options_t)~DRIZZLE_RESULT_ALLOCATED);
100
110
 
101
111
void drizzle_result_free(drizzle_result_st *result)
102
112
{
 
113
  if (result == NULL)
 
114
  {
 
115
    return;
 
116
  }
 
117
 
103
118
  drizzle_column_st *column;
104
119
  uint64_t x;
105
120
 
106
121
  for (column= result->column_list; column != NULL; column= result->column_list)
 
122
  {
107
123
    drizzle_column_free(column);
 
124
  }
108
125
 
109
126
  free(result->column_buffer);
110
127
 
123
140
    if (result->con->result_list == result)
124
141
      result->con->result_list= result->next;
125
142
  }
 
143
 
126
144
  if (result->prev)
 
145
  {
127
146
    result->prev->next= result->next;
 
147
  }
128
148
  if (result->next)
 
149
  {
129
150
    result->next->prev= result->prev;
 
151
  }
130
152
 
131
153
  if (result->options & DRIZZLE_RESULT_ALLOCATED)
 
154
  {
132
155
    free(result);
 
156
  }
133
157
}
134
158
 
135
159
void drizzle_result_free_all(drizzle_con_st *con)
136
160
{
 
161
  if (con == NULL)
 
162
  {
 
163
    return;
 
164
  }
 
165
 
137
166
  while (con->result_list != NULL)
 
167
  {
138
168
    drizzle_result_free(con->result_list);
 
169
  }
139
170
}
140
171
 
141
172
drizzle_con_st *drizzle_result_drizzle_con(drizzle_result_st *result)
142
173
{
 
174
  if (result == NULL)
 
175
  {
 
176
    return NULL;
 
177
  }
 
178
 
143
179
  return result->con;
144
180
}
145
181
 
146
182
bool drizzle_result_eof(drizzle_result_st *result)
147
183
{
 
184
  if (result == NULL)
 
185
  {
 
186
    return false;
 
187
  }
 
188
 
148
189
  return result->options & DRIZZLE_RESULT_EOF_PACKET;
149
190
}
150
191
 
151
192
const char *drizzle_result_info(drizzle_result_st *result)
152
193
{
 
194
  if (result == NULL)
 
195
  {
 
196
    return NULL;
 
197
  }
 
198
 
153
199
  return result->info;
154
200
}
155
201
 
156
202
const char *drizzle_result_error(drizzle_result_st *result)
157
203
{
 
204
  if (result == NULL)
 
205
  {
 
206
    return NULL;
 
207
  }
 
208
 
158
209
  return result->info;
159
210
}
160
211
 
161
212
uint16_t drizzle_result_error_code(drizzle_result_st *result)
162
213
{
 
214
  if (result == NULL)
 
215
  {
 
216
    return 0;
 
217
  }
 
218
 
163
219
  return result->error_code;
164
220
}
165
221
 
166
222
const char *drizzle_result_sqlstate(drizzle_result_st *result)
167
223
{
 
224
  if (result == NULL)
 
225
  {
 
226
    return NULL;
 
227
  }
 
228
 
168
229
  return result->sqlstate;
169
230
}
170
231
 
171
232
uint16_t drizzle_result_warning_count(drizzle_result_st *result)
172
233
{
 
234
  if (result == NULL)
 
235
  {
 
236
    return 0;
 
237
  }
 
238
 
173
239
  return result->warning_count;
174
240
}
175
241
 
176
242
uint64_t drizzle_result_insert_id(drizzle_result_st *result)
177
243
{
 
244
  if (result == NULL)
 
245
  {
 
246
    return 0;
 
247
  }
 
248
 
178
249
  return result->insert_id;
179
250
}
180
251
 
181
252
uint64_t drizzle_result_affected_rows(drizzle_result_st *result)
182
253
{
 
254
  if (result == NULL)
 
255
  {
 
256
    return 0;
 
257
  }
 
258
 
183
259
  return result->affected_rows;
184
260
}
185
261
 
186
262
uint16_t drizzle_result_column_count(drizzle_result_st *result)
187
263
{
 
264
  if (result == NULL)
 
265
  {
 
266
    return 0;
 
267
  }
 
268
 
188
269
  return result->column_count;
189
270
}
190
271
 
191
272
uint64_t drizzle_result_row_count(drizzle_result_st *result)
192
273
{
 
274
  if (result == NULL)
 
275
  {
 
276
    return 0;
 
277
  }
 
278
 
193
279
  return result->row_count;
194
280
}
195
281
 
201
287
                                       drizzle_result_st *result,
202
288
                                       drizzle_return_t *ret_ptr)
203
289
{
 
290
  drizzle_return_t unused;
 
291
  if (ret_ptr == NULL)
 
292
  {
 
293
    ret_ptr= &unused;
 
294
  }
 
295
 
 
296
  if (con == NULL)
 
297
  {
 
298
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
299
    return NULL;
 
300
  }
 
301
 
204
302
  if (drizzle_state_none(con))
205
303
  {
206
304
    con->result= drizzle_result_create(con, result);
220
318
 
221
319
drizzle_return_t drizzle_result_buffer(drizzle_result_st *result)
222
320
{
 
321
  if (result == NULL)
 
322
  {
 
323
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
324
  }
 
325
 
223
326
  drizzle_return_t ret;
224
327
  drizzle_row_t row;
225
328
  drizzle_row_t *row_list;
288
391
 
289
392
size_t drizzle_result_row_size(drizzle_result_st *result)
290
393
{
 
394
  if (result == NULL)
 
395
  {
 
396
    return 0;
 
397
  }
 
398
 
291
399
  return result->con->packet_size;
292
400
}
293
401
 
298
406
drizzle_return_t drizzle_result_write(drizzle_con_st *con,
299
407
                                      drizzle_result_st *result, bool flush)
300
408
{
 
409
  if (con == NULL)
 
410
  {
 
411
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
412
  }
 
413
 
301
414
  if (drizzle_state_none(con))
302
415
  {
303
416
    con->result= result;
313
426
 
314
427
void drizzle_result_set_row_size(drizzle_result_st *result, size_t size)
315
428
{
 
429
  if (result == NULL)
 
430
  {
 
431
    return;
 
432
  }
 
433
 
316
434
  result->con->packet_size= size;
317
435
}
318
436
 
320
438
                                  const drizzle_field_t *field,
321
439
                                  const size_t *size)
322
440
{
323
 
  uint16_t x;
 
441
  if (result == NULL)
 
442
  {
 
443
    return;
 
444
  }
324
445
 
325
446
  result->con->packet_size= 0;
326
447
 
327
 
  for (x= 0; x < result->column_count; x++)
 
448
  for (uint16_t x= 0; x < result->column_count; x++)
328
449
  {
329
450
    if (field[x] == NULL)
330
451
      result->con->packet_size++;
341
462
 
342
463
void drizzle_result_set_eof(drizzle_result_st *result, bool is_eof)
343
464
{
 
465
  if (result == NULL)
 
466
  {
 
467
    return;
 
468
  }
 
469
 
344
470
  if (is_eof)
345
471
    result->options|= DRIZZLE_RESULT_EOF_PACKET;
346
472
  else
349
475
 
350
476
void drizzle_result_set_info(drizzle_result_st *result, const char *info)
351
477
{
 
478
  if (result == NULL)
 
479
  {
 
480
    return;
 
481
  }
 
482
 
352
483
  if (info == NULL)
 
484
  {
353
485
    result->info[0]= 0;
 
486
  }
354
487
  else
355
488
  {
356
489
    strncpy(result->info, info, DRIZZLE_MAX_INFO_SIZE);
360
493
 
361
494
void drizzle_result_set_error(drizzle_result_st *result, const char *error)
362
495
{
 
496
  if (result == NULL)
 
497
  {
 
498
    return;
 
499
  }
 
500
 
363
501
  drizzle_result_set_info(result, error);
364
502
}
365
503
 
366
504
void drizzle_result_set_error_code(drizzle_result_st *result,
367
505
                                   uint16_t error_code)
368
506
{
 
507
  if (result == NULL)
 
508
  {
 
509
    return;
 
510
  }
 
511
 
369
512
  result->error_code= error_code;
370
513
}
371
514
 
372
515
void drizzle_result_set_sqlstate(drizzle_result_st *result,
373
516
                                 const char *sqlstate)
374
517
{
 
518
  if (result == NULL)
 
519
  {
 
520
    return;
 
521
  }
 
522
 
375
523
  if (sqlstate == NULL)
 
524
  {
376
525
    result->sqlstate[0]= 0;
 
526
  }
377
527
  else
378
528
  {
379
529
    strncpy(result->sqlstate, sqlstate, DRIZZLE_MAX_SQLSTATE_SIZE + 1);
384
534
void drizzle_result_set_warning_count(drizzle_result_st *result,
385
535
                                      uint16_t warning_count)
386
536
{
 
537
  if (result == NULL)
 
538
  {
 
539
    return;
 
540
  }
 
541
 
387
542
  result->warning_count= warning_count;
388
543
}
389
544
 
390
545
void drizzle_result_set_insert_id(drizzle_result_st *result,
391
546
                                  uint64_t insert_id)
392
547
{
 
548
  if (result == NULL)
 
549
  {
 
550
    return;
 
551
  }
 
552
 
393
553
  result->insert_id= insert_id;
394
554
}
395
555
 
396
556
void drizzle_result_set_affected_rows(drizzle_result_st *result,
397
557
                                      uint64_t affected_rows)
398
558
{
 
559
  if (result == NULL)
 
560
  {
 
561
    return;
 
562
  }
 
563
 
399
564
  result->affected_rows= affected_rows;
400
565
}
401
566
 
402
567
void drizzle_result_set_column_count(drizzle_result_st *result,
403
568
                                     uint16_t column_count)
404
569
{
 
570
  if (result == NULL)
 
571
  {
 
572
    return;
 
573
  }
 
574
 
405
575
  result->column_count= column_count;
406
576
}
407
577
 
413
583
{
414
584
  drizzle_return_t ret;
415
585
 
 
586
  if (con == NULL)
 
587
  {
 
588
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
589
  }
 
590
 
416
591
  drizzle_log_debug(con->drizzle, "drizzle_state_result_read");
417
592
 
418
593
  /* Assume the entire result packet will fit in the buffer. */
493
668
 
494
669
drizzle_return_t drizzle_state_result_write(drizzle_con_st *con)
495
670
{
 
671
  if (con == NULL)
 
672
  {
 
673
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
674
  }
 
675
 
496
676
  uint8_t *start= con->buffer_ptr + con->buffer_size;
497
677
  uint8_t *ptr;
498
678
  drizzle_result_st *result= con->result;