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