← 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-14 07:30:41 UTC
  • Revision ID: me@mark.atwood.name-20111114073041-mo2hgg8ouseo2kpu
release 2011.11.29

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