← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/query.cc

  • Committer: Mark Atwood
  • Date: 2011-11-20 08:50:16 UTC
  • mfrom: (2461.1.2 drizzle-build)
  • Revision ID: me@mark.atwood.name-20111120085016-2o4no5btx18x2gws
merge lp:~brianaker/drizzle/libdrizzle-refactor

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/query.cc
54
54
                                     const char *query, 
55
55
                                     drizzle_return_t *ret_ptr)
56
56
{
57
 
  size_t size;
58
 
 
59
 
  size= strlen(query);
60
 
 
61
 
  return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_QUERY,
62
 
                                   (uint8_t *)query, size, size, ret_ptr);
 
57
  size_t size= strlen(query);
 
58
 
 
59
  return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_QUERY, (uint8_t *)query, size, size, ret_ptr);
63
60
}
64
61
 
65
62
drizzle_result_st *drizzle_query_inc(drizzle_con_st *con,
67
64
                                     const char *query, size_t size,
68
65
                                     size_t total, drizzle_return_t *ret_ptr)
69
66
{
70
 
  return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_QUERY,
71
 
                                   (uint8_t *)query, size, total, ret_ptr);
 
67
  return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_QUERY, (uint8_t *)query, size, total, ret_ptr);
72
68
}
73
69
 
74
70
drizzle_query_st *drizzle_query_add(drizzle_st *drizzle,
79
75
                                    drizzle_query_options_t options,
80
76
                                    void *context)
81
77
{
 
78
  // @note drizzle_query_st handle the null drizzle case
82
79
  query= drizzle_query_create(drizzle, query);
83
80
  if (query == NULL)
 
81
  {
84
82
    return NULL;
 
83
  }
85
84
 
86
85
  drizzle_query_set_con(query, con);
87
86
  drizzle_query_set_result(query, result);
95
94
drizzle_query_st *drizzle_query_create(drizzle_st *drizzle,
96
95
                                       drizzle_query_st *query)
97
96
{
 
97
  if (drizzle == NULL)
 
98
  {
 
99
    return NULL;
 
100
  }
 
101
 
98
102
  if (query == NULL)
99
103
  {
100
 
    query= new drizzle_query_st;
 
104
    query= new (std::nothrow) drizzle_query_st;
 
105
 
 
106
    if (query == NULL)
 
107
    {
 
108
      return NULL;
 
109
    }
101
110
    query->options|= DRIZZLE_CON_ALLOCATED;
102
111
  }
103
112
  else
116
125
  query->drizzle= drizzle;
117
126
 
118
127
  if (drizzle->query_list)
 
128
  {
119
129
    drizzle->query_list->prev= query;
 
130
  }
120
131
  query->next= drizzle->query_list;
121
132
  drizzle->query_list= query;
122
133
  drizzle->query_count++;
127
138
 
128
139
void drizzle_query_free(drizzle_query_st *query)
129
140
{
 
141
  if (query == NULL)
 
142
  {
 
143
    return;
 
144
  }
 
145
 
130
146
  if (query->context != NULL && query->context_free_fn != NULL)
131
147
    query->context_free_fn(query, query->context);
132
148
 
133
149
  if (query->drizzle->query_list == query)
134
150
    query->drizzle->query_list= query->next;
 
151
 
135
152
  if (query->prev)
136
153
    query->prev->next= query->next;
 
154
 
137
155
  if (query->next)
138
156
    query->next->prev= query->prev;
 
157
 
139
158
  query->drizzle->query_count--;
140
159
 
141
160
  if (query->options & DRIZZLE_QUERY_ALLOCATED)
145
164
void drizzle_query_free_all(drizzle_st *drizzle)
146
165
{
147
166
  while (drizzle->query_list != NULL)
 
167
  {
148
168
    drizzle_query_free(drizzle->query_list);
 
169
  }
149
170
}
150
171
 
151
172
drizzle_con_st *drizzle_query_con(drizzle_query_st *query)
152
173
{
 
174
  if (query == NULL)
 
175
  {
 
176
    return NULL;
 
177
  }
 
178
 
153
179
  return query->con;
154
180
}
155
181
 
156
182
void drizzle_query_set_con(drizzle_query_st *query, drizzle_con_st *con)
157
183
{
 
184
  if (query == NULL)
 
185
  {
 
186
    return;
 
187
  }
 
188
 
158
189
  query->con= con;
159
190
}
160
191
 
161
192
drizzle_result_st *drizzle_query_result(drizzle_query_st *query)
162
193
{
 
194
  if (query == NULL)
 
195
  {
 
196
    return NULL;
 
197
  }
 
198
 
163
199
  return query->result;
164
200
}
165
201
 
166
202
void drizzle_query_set_result(drizzle_query_st *query,
167
203
                              drizzle_result_st *result)
168
204
{
 
205
  if (query == NULL)
 
206
  {
 
207
    return;
 
208
  }
 
209
 
169
210
  query->result= result;
170
211
}
171
212
 
172
213
char *drizzle_query_string(drizzle_query_st *query, size_t *size)
173
214
{
 
215
  if (query == NULL)
 
216
  {
 
217
    return NULL;
 
218
  }
 
219
 
174
220
  *size= query->size;
175
221
  return (char *)(query->string);
176
222
}
178
224
void drizzle_query_set_string(drizzle_query_st *query, const char *string,
179
225
                              size_t size)
180
226
{
 
227
  if (query == NULL)
 
228
  {
 
229
    return;
 
230
  }
 
231
 
181
232
  query->string= string;
182
233
  query->size= size;
183
234
}
184
235
 
185
236
int drizzle_query_options(drizzle_query_st *query)
186
237
{
 
238
  if (query == NULL)
 
239
  {
 
240
    return 0;
 
241
  }
 
242
 
187
243
  return query->options;
188
244
}
189
245
 
190
246
void drizzle_query_set_options(drizzle_query_st *query,
191
247
                               int options)
192
248
{
 
249
  if (query == NULL)
 
250
  {
 
251
    return;
 
252
  }
 
253
 
193
254
  query->options= options;
194
255
}
195
256
 
196
257
void drizzle_query_add_options(drizzle_query_st *query,
197
258
                               int options)
198
259
{
 
260
  if (query == NULL)
 
261
  {
 
262
    return;
 
263
  }
 
264
 
199
265
  query->options|= options;
200
266
}
201
267
 
202
268
void drizzle_query_remove_options(drizzle_query_st *query,
203
269
                                  int options)
204
270
{
 
271
  if (query == NULL)
 
272
  {
 
273
    return;
 
274
  }
 
275
 
205
276
  query->options&= ~options;
206
277
}
207
278
 
208
279
void *drizzle_query_context(drizzle_query_st *query)
209
280
{
 
281
  if (query == NULL)
 
282
  {
 
283
    return NULL;
 
284
  }
 
285
 
210
286
  return query->context;
211
287
}
212
288
 
213
289
void drizzle_query_set_context(drizzle_query_st *query, void *context)
214
290
{
 
291
  if (query == NULL)
 
292
  {
 
293
    return;
 
294
  }
 
295
 
215
296
  query->context= context;
216
297
}
217
298
 
218
299
void drizzle_query_set_context_free_fn(drizzle_query_st *query,
219
300
                                       drizzle_query_context_free_fn *function)
220
301
{
 
302
  if (query == NULL)
 
303
  {
 
304
    return;
 
305
  }
 
306
 
221
307
  query->context_free_fn= function;
222
308
}
223
309
 
224
310
static void drizzle_query_run_state(drizzle_query_st* query,
225
311
                                    drizzle_return_t* ret_ptr)
226
312
{
 
313
  if (query == NULL)
 
314
  {
 
315
    return;
 
316
  }
 
317
 
227
318
  switch (query->state)
228
319
  {
229
320
  case DRIZZLE_QUERY_STATE_INIT:
230
321
    query->state= DRIZZLE_QUERY_STATE_QUERY;
 
322
 
231
323
  case DRIZZLE_QUERY_STATE_QUERY:
232
324
    query->result= drizzle_query(query->con, query->result, query->string,
233
325
                                 query->size, ret_ptr);
262
354
drizzle_query_st *drizzle_query_run(drizzle_st *drizzle,
263
355
                                    drizzle_return_t *ret_ptr)
264
356
{
265
 
  int options;
266
 
  drizzle_query_st *query;
267
 
  drizzle_con_st *con;
 
357
  drizzle_return_t unused;
 
358
  if (ret_ptr == NULL)
 
359
  {
 
360
    ret_ptr= &unused;
 
361
  }
 
362
 
 
363
  if (drizzle == NULL)
 
364
  {
 
365
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
366
    return NULL;
 
367
  }
268
368
 
269
369
  if (drizzle->query_new == 0 && drizzle->query_running == 0)
270
370
  {
272
372
    return NULL;
273
373
  }
274
374
 
275
 
  options= drizzle->options;
276
 
  drizzle->options|= DRIZZLE_NON_BLOCKING;
 
375
  drizzle_st::options_t options= drizzle->options;
 
376
  drizzle->options.is_non_blocking= false;
277
377
 
278
378
  /* Check to see if any queries need to be started. */
279
379
  if (drizzle->query_new > 0)
280
380
  {
281
 
    for (query= drizzle->query_list; query != NULL; query= query->next)
 
381
    for (drizzle_query_st *query= drizzle->query_list; query != NULL; query= query->next)
282
382
    {
283
383
      if (query->state != DRIZZLE_QUERY_STATE_INIT)
 
384
      {
284
385
        continue;
 
386
      }
285
387
 
286
388
      drizzle->query_new--;
287
389
      drizzle->query_running++;
307
409
 
308
410
  while (1)
309
411
  {
 
412
    drizzle_con_st *con;
 
413
 
310
414
    /* Loop through each active connection. */
311
415
    while ((con= drizzle_con_ready(drizzle)) != NULL)
312
416
    {
313
 
      query= con->query;
 
417
      drizzle_query_st *query= con->query;
314
418
      drizzle_query_run_state(query, ret_ptr);
315
419
      if (query->state == DRIZZLE_QUERY_STATE_DONE)
316
420
      {
322
426
      assert(*ret_ptr == DRIZZLE_RETURN_IO_WAIT);
323
427
    }
324
428
 
325
 
    if (options & DRIZZLE_NON_BLOCKING)
 
429
    if (options.is_non_blocking)
326
430
    {
327
431
      *ret_ptr= DRIZZLE_RETURN_IO_WAIT;
328
432
      return NULL;
339
443
 
340
444
drizzle_return_t drizzle_query_run_all(drizzle_st *drizzle)
341
445
{
342
 
  drizzle_return_t ret;
 
446
  if (drizzle == NULL)
 
447
  {
 
448
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
449
  }
343
450
 
344
451
  while (drizzle->query_new > 0 || drizzle->query_running > 0)
345
452
  {
 
453
    drizzle_return_t ret;
 
454
 
346
455
    (void)drizzle_query_run(drizzle, &ret);
347
456
    if (ret != DRIZZLE_RETURN_OK && ret != DRIZZLE_RETURN_ERROR_CODE)
 
457
    {
348
458
      return ret;
 
459
    }
349
460
  }
350
461
 
351
462
  return DRIZZLE_RETURN_OK;
352
463
}
353
464
 
354
 
ssize_t drizzle_safe_escape_string(char *to, size_t max_to_size, const char *from, size_t from_size)
 
465
ssize_t drizzle_escape_string(char *to, size_t max_to_size, const char *from, size_t from_size)
355
466
{
356
467
  ssize_t to_size= 0;
357
468
  char newchar;
393
504
    if (newchar != '\0')
394
505
    {
395
506
      if ((size_t)to_size + 2 > max_to_size)
 
507
      {
396
508
        return -1;
 
509
      }
397
510
 
398
511
      *to++= '\\';
399
512
      *to++= newchar;
402
515
    else
403
516
    {
404
517
      if ((size_t)to_size + 1 > max_to_size)
 
518
      {
405
519
        return -1;
 
520
      }
406
521
 
407
522
      *to++= *from;
408
523
    }
414
529
  return to_size;
415
530
}
416
531
 
417
 
size_t drizzle_escape_string(char *to, const char *from, size_t from_size)
418
 
{
419
 
  return (size_t) drizzle_safe_escape_string(to, (from_size * 2), from, from_size);
420
 
}
421
 
 
422
532
size_t drizzle_hex_string(char *to, const char *from, size_t from_size)
423
533
{
424
534
  static const char hex_map[]= "0123456789ABCDEF";