← 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-12-15 23:13:18 UTC
  • mfrom: (2465.3.1 rf3)
  • Revision ID: me@mark.atwood.name-20111215231318-mt2y2q4s5ydp79q3
merge lp:~olafvdspek/drizzle/refactor14

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/query.cc
39
39
 * @brief Query definitions
40
40
 */
41
41
 
42
 
#include "common.h"
 
42
#include <libdrizzle-2.0/common.h>
43
43
 
44
44
drizzle_result_st *drizzle_query(drizzle_con_st *con, drizzle_result_st *result,
45
45
                                 const char *query, size_t size,
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,
76
72
                                    drizzle_con_st *con,
77
73
                                    drizzle_result_st *result,
78
74
                                    const char *query_string, size_t size,
79
 
                                    drizzle_query_options_t options,
 
75
                                    drizzle_query_options_t,
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);
88
87
  drizzle_query_set_string(query, query_string, size);
89
 
  drizzle_query_add_options(query, options);
90
88
  drizzle_query_set_context(query, context);
91
89
 
92
90
  return query;
93
91
}
94
92
 
95
 
drizzle_query_st *drizzle_query_create(drizzle_st *drizzle,
96
 
                                       drizzle_query_st *query)
 
93
drizzle_query_st *drizzle_query_create(drizzle_st *drizzle, drizzle_query_st *query)
97
94
{
 
95
  if (drizzle == NULL)
 
96
  {
 
97
    return NULL;
 
98
  }
 
99
 
98
100
  if (query == NULL)
99
101
  {
100
 
    query= new drizzle_query_st;
101
 
    query->options|= DRIZZLE_CON_ALLOCATED;
 
102
    query= new (std::nothrow) drizzle_query_st;
 
103
 
 
104
    if (query == NULL)
 
105
    {
 
106
      return NULL;
 
107
    }
 
108
    query->options.is_allocated= true;
102
109
  }
103
110
  else
104
111
  {
105
112
    query->prev= NULL;
106
 
    query->options= 0;
107
113
    query->state= DRIZZLE_QUERY_STATE_INIT;
108
114
    query->con= NULL;
109
115
    query->result= NULL;
111
117
    query->size= 0;
112
118
    query->context= NULL;
113
119
    query->context_free_fn= NULL;
 
120
    query->options.is_allocated= false;
114
121
  }
115
122
 
116
123
  query->drizzle= drizzle;
117
124
 
118
125
  if (drizzle->query_list)
 
126
  {
119
127
    drizzle->query_list->prev= query;
 
128
  }
120
129
  query->next= drizzle->query_list;
121
130
  drizzle->query_list= query;
122
131
  drizzle->query_count++;
127
136
 
128
137
void drizzle_query_free(drizzle_query_st *query)
129
138
{
 
139
  if (query == NULL)
 
140
  {
 
141
    return;
 
142
  }
 
143
 
130
144
  if (query->context != NULL && query->context_free_fn != NULL)
 
145
  {
131
146
    query->context_free_fn(query, query->context);
 
147
  }
132
148
 
133
149
  if (query->drizzle->query_list == query)
 
150
  {
134
151
    query->drizzle->query_list= query->next;
 
152
  }
 
153
 
135
154
  if (query->prev)
 
155
  {
136
156
    query->prev->next= query->next;
 
157
  }
 
158
 
137
159
  if (query->next)
 
160
  {
138
161
    query->next->prev= query->prev;
 
162
  }
 
163
 
139
164
  query->drizzle->query_count--;
140
165
 
141
 
  if (query->options & DRIZZLE_QUERY_ALLOCATED)
 
166
  if (query->options.is_allocated)
 
167
  {
142
168
    delete query;
 
169
  }
143
170
}
144
171
 
145
172
void drizzle_query_free_all(drizzle_st *drizzle)
146
173
{
147
174
  while (drizzle->query_list != NULL)
 
175
  {
148
176
    drizzle_query_free(drizzle->query_list);
 
177
  }
149
178
}
150
179
 
151
180
drizzle_con_st *drizzle_query_con(drizzle_query_st *query)
152
181
{
 
182
  if (query == NULL)
 
183
  {
 
184
    return NULL;
 
185
  }
 
186
 
153
187
  return query->con;
154
188
}
155
189
 
156
190
void drizzle_query_set_con(drizzle_query_st *query, drizzle_con_st *con)
157
191
{
 
192
  if (query == NULL)
 
193
  {
 
194
    return;
 
195
  }
 
196
 
158
197
  query->con= con;
159
198
}
160
199
 
161
200
drizzle_result_st *drizzle_query_result(drizzle_query_st *query)
162
201
{
 
202
  if (query == NULL)
 
203
  {
 
204
    return NULL;
 
205
  }
 
206
 
163
207
  return query->result;
164
208
}
165
209
 
166
210
void drizzle_query_set_result(drizzle_query_st *query,
167
211
                              drizzle_result_st *result)
168
212
{
 
213
  if (query == NULL)
 
214
  {
 
215
    return;
 
216
  }
 
217
 
169
218
  query->result= result;
170
219
}
171
220
 
172
221
char *drizzle_query_string(drizzle_query_st *query, size_t *size)
173
222
{
 
223
  if (query == NULL)
 
224
  {
 
225
    return NULL;
 
226
  }
 
227
 
174
228
  *size= query->size;
175
229
  return (char *)(query->string);
176
230
}
178
232
void drizzle_query_set_string(drizzle_query_st *query, const char *string,
179
233
                              size_t size)
180
234
{
 
235
  if (query == NULL)
 
236
  {
 
237
    return;
 
238
  }
 
239
 
181
240
  query->string= string;
182
241
  query->size= size;
183
242
}
184
243
 
185
 
int drizzle_query_options(drizzle_query_st *query)
186
 
{
187
 
  return query->options;
188
 
}
189
 
 
190
 
void drizzle_query_set_options(drizzle_query_st *query,
191
 
                               int options)
192
 
{
193
 
  query->options= options;
194
 
}
195
 
 
196
 
void drizzle_query_add_options(drizzle_query_st *query,
197
 
                               int options)
198
 
{
199
 
  query->options|= options;
200
 
}
201
 
 
202
 
void drizzle_query_remove_options(drizzle_query_st *query,
203
 
                                  int options)
204
 
{
205
 
  query->options&= ~options;
 
244
int drizzle_query_options(drizzle_query_st *)
 
245
{
 
246
  return 0;
 
247
}
 
248
 
 
249
void drizzle_query_set_options(drizzle_query_st *, int)
 
250
{
 
251
}
 
252
 
 
253
void drizzle_query_add_options(drizzle_query_st *, int)
 
254
{
 
255
}
 
256
 
 
257
void drizzle_query_remove_options(drizzle_query_st *, int)
 
258
{
206
259
}
207
260
 
208
261
void *drizzle_query_context(drizzle_query_st *query)
209
262
{
 
263
  if (query == NULL)
 
264
  {
 
265
    return NULL;
 
266
  }
 
267
 
210
268
  return query->context;
211
269
}
212
270
 
213
271
void drizzle_query_set_context(drizzle_query_st *query, void *context)
214
272
{
 
273
  if (query == NULL)
 
274
  {
 
275
    return;
 
276
  }
 
277
 
215
278
  query->context= context;
216
279
}
217
280
 
218
281
void drizzle_query_set_context_free_fn(drizzle_query_st *query,
219
282
                                       drizzle_query_context_free_fn *function)
220
283
{
 
284
  if (query == NULL)
 
285
  {
 
286
    return;
 
287
  }
 
288
 
221
289
  query->context_free_fn= function;
222
290
}
223
291
 
224
292
static void drizzle_query_run_state(drizzle_query_st* query,
225
293
                                    drizzle_return_t* ret_ptr)
226
294
{
 
295
  if (query == NULL)
 
296
  {
 
297
    return;
 
298
  }
 
299
 
227
300
  switch (query->state)
228
301
  {
229
302
  case DRIZZLE_QUERY_STATE_INIT:
230
303
    query->state= DRIZZLE_QUERY_STATE_QUERY;
 
304
 
231
305
  case DRIZZLE_QUERY_STATE_QUERY:
232
306
    query->result= drizzle_query(query->con, query->result, query->string,
233
307
                                 query->size, ret_ptr);
262
336
drizzle_query_st *drizzle_query_run(drizzle_st *drizzle,
263
337
                                    drizzle_return_t *ret_ptr)
264
338
{
265
 
  int options;
266
 
  drizzle_query_st *query;
267
 
  drizzle_con_st *con;
 
339
  drizzle_return_t unused;
 
340
  if (ret_ptr == NULL)
 
341
  {
 
342
    ret_ptr= &unused;
 
343
  }
 
344
 
 
345
  if (drizzle == NULL)
 
346
  {
 
347
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
348
    return NULL;
 
349
  }
268
350
 
269
351
  if (drizzle->query_new == 0 && drizzle->query_running == 0)
270
352
  {
272
354
    return NULL;
273
355
  }
274
356
 
275
 
  options= drizzle->options;
276
 
  drizzle->options|= DRIZZLE_NON_BLOCKING;
 
357
  drizzle_st::options_t options= drizzle->options;
 
358
  drizzle->options.is_non_blocking= false;
277
359
 
278
360
  /* Check to see if any queries need to be started. */
279
361
  if (drizzle->query_new > 0)
280
362
  {
281
 
    for (query= drizzle->query_list; query != NULL; query= query->next)
 
363
    for (drizzle_query_st *query= drizzle->query_list; query != NULL; query= query->next)
282
364
    {
283
365
      if (query->state != DRIZZLE_QUERY_STATE_INIT)
 
366
      {
284
367
        continue;
 
368
      }
285
369
 
286
370
      drizzle->query_new--;
287
371
      drizzle->query_running++;
307
391
 
308
392
  while (1)
309
393
  {
 
394
    drizzle_con_st *con;
 
395
 
310
396
    /* Loop through each active connection. */
311
397
    while ((con= drizzle_con_ready(drizzle)) != NULL)
312
398
    {
313
 
      query= con->query;
 
399
      drizzle_query_st *query= con->query;
314
400
      drizzle_query_run_state(query, ret_ptr);
315
401
      if (query->state == DRIZZLE_QUERY_STATE_DONE)
316
402
      {
322
408
      assert(*ret_ptr == DRIZZLE_RETURN_IO_WAIT);
323
409
    }
324
410
 
325
 
    if (options & DRIZZLE_NON_BLOCKING)
 
411
    if (options.is_non_blocking)
326
412
    {
327
413
      *ret_ptr= DRIZZLE_RETURN_IO_WAIT;
328
414
      return NULL;
339
425
 
340
426
drizzle_return_t drizzle_query_run_all(drizzle_st *drizzle)
341
427
{
342
 
  drizzle_return_t ret;
 
428
  if (drizzle == NULL)
 
429
  {
 
430
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
431
  }
343
432
 
344
433
  while (drizzle->query_new > 0 || drizzle->query_running > 0)
345
434
  {
 
435
    drizzle_return_t ret;
 
436
 
346
437
    (void)drizzle_query_run(drizzle, &ret);
347
438
    if (ret != DRIZZLE_RETURN_OK && ret != DRIZZLE_RETURN_ERROR_CODE)
 
439
    {
348
440
      return ret;
 
441
    }
349
442
  }
350
443
 
351
444
  return DRIZZLE_RETURN_OK;
352
445
}
353
446
 
354
 
ssize_t drizzle_safe_escape_string(char *to, size_t max_to_size, const char *from, size_t from_size)
 
447
ssize_t drizzle_escape_string(char *to, size_t max_to_size, const char *from, size_t from_size)
355
448
{
356
449
  ssize_t to_size= 0;
357
450
  char newchar;
393
486
    if (newchar != '\0')
394
487
    {
395
488
      if ((size_t)to_size + 2 > max_to_size)
 
489
      {
396
490
        return -1;
 
491
      }
397
492
 
398
493
      *to++= '\\';
399
494
      *to++= newchar;
402
497
    else
403
498
    {
404
499
      if ((size_t)to_size + 1 > max_to_size)
 
500
      {
405
501
        return -1;
 
502
      }
406
503
 
407
504
      *to++= *from;
408
505
    }
414
511
  return to_size;
415
512
}
416
513
 
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
514
size_t drizzle_hex_string(char *to, const char *from, size_t from_size)
423
515
{
424
516
  static const char hex_map[]= "0123456789ABCDEF";