Drizzle

Merge lp:~brianaker/drizzle/libdrizzle-2.0-not-install into lp:~drizzle-trunk/drizzle/development

  1. libdrizzle-2.0-not-install
  2. Merge into development
Proposed by Brian Aker
Status: Merged
Approved by: Brian Aker
Approved revision: 2469
Merged at revision: 2465
Proposed branch: lp:~brianaker/drizzle/libdrizzle-2.0-not-install
Merge into: lp:~drizzle-trunk/drizzle/development
Diff against target: 4957 lines (+1402/-1001)
39 files modified
client/drizzle.cc (+142/-117)
client/drizzledump_data.cc (+39/-27)
client/drizzledump_data.h (+12/-4)
client/drizzleimport.cc (+12/-3)
client/drizzleslap.cc (+41/-30)
drizzled/internal/m_string.h (+5/-5)
examples/client.cc (+54/-24)
examples/pipe_query.cc (+20/-20)
examples/proxy.cc (+85/-73)
examples/server.cc (+28/-25)
examples/simple_multi.cc (+44/-39)
examples/sqlite_server.cc (+123/-121)
libdrizzle-2.0/column.cc (+7/-3)
libdrizzle-2.0/command.h (+102/-0)
libdrizzle-2.0/conn.cc (+72/-16)
libdrizzle-2.0/constants.h (+9/-172)
libdrizzle-2.0/deprecated_enum.h (+67/-0)
libdrizzle-2.0/drizzle.cc (+79/-65)
libdrizzle-2.0/drizzle.h (+7/-45)
libdrizzle-2.0/drizzle_client.h (+2/-2)
libdrizzle-2.0/drizzle_server.h (+1/-5)
libdrizzle-2.0/handshake.cc (+7/-5)
libdrizzle-2.0/include.am (+40/-36)
libdrizzle-2.0/libdrizzle.hpp (+25/-12)
libdrizzle-2.0/limits.h (+56/-0)
libdrizzle-2.0/query.cc (+30/-48)
libdrizzle-2.0/query.h (+4/-7)
libdrizzle-2.0/result.cc (+31/-20)
libdrizzle-2.0/result.h (+6/-5)
libdrizzle-2.0/return.h (+78/-0)
libdrizzle-2.0/row.cc (+4/-0)
libdrizzle-2.0/structs.h (+28/-4)
libdrizzle-2.0/verbose.h (+58/-0)
plugin/mysql_protocol/mysql_protocol.cc (+10/-6)
plugin/slave/queue_producer.cc (+31/-29)
plugin/slave/queue_producer.h (+3/-2)
plugin/transaction_log/utilities/transaction_log_connection.cc (+36/-27)
plugin/transaction_log/utilities/transaction_log_connection.h (+2/-2)
support-files/include.am (+2/-2)
To merge this branch: bzr merge lp:~brianaker/drizzle/libdrizzle-2.0-not-install
Reviewer Review Type Date Requested Status
Drizzle Merge Team Pending
Review via email: mp+83871@code.launchpad.net
To post a comment you must log in.

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'client/drizzle.cc'
2--- client/drizzle.cc 2011-11-04 21:06:16 +0000
3+++ client/drizzle.cc 2011-11-29 23:07:26 +0000
4@@ -281,8 +281,8 @@
5 enum enum_info_type { INFO_INFO,INFO_ERROR,INFO_RESULT};
6 typedef enum enum_info_type INFO_TYPE;
7
8-static drizzle_st drizzle; /* The library handle */
9-static drizzle_con_st con; /* The connection */
10+static drizzle_st *drizzle= NULL; /* The library handle */
11+static drizzle_con_st *con= NULL; /* The connection */
12 static bool ignore_errors= false, quick= false,
13 connected= false, opt_raw_data= false, unbuffered= false,
14 output_tables= false, opt_rehash= true, skip_updates= false,
15@@ -1188,29 +1188,29 @@
16 static bool server_shutdown(void)
17 {
18 drizzle_result_st result;
19- drizzle_return_t ret;
20
21 if (verbose)
22 {
23 printf(_("shutting down drizzled"));
24 if (opt_drizzle_port > 0)
25+ {
26 printf(_(" on port %d"), opt_drizzle_port);
27+ }
28 printf("... ");
29 }
30
31- if (drizzle_shutdown(&con, &result, DRIZZLE_SHUTDOWN_DEFAULT,
32- &ret) == NULL || ret != DRIZZLE_RETURN_OK)
33+ drizzle_return_t ret;
34+ if (drizzle_shutdown(con, &result, DRIZZLE_SHUTDOWN_DEFAULT, &ret) == NULL or
35+ ret != DRIZZLE_RETURN_OK)
36 {
37 if (ret == DRIZZLE_RETURN_ERROR_CODE)
38 {
39- fprintf(stderr, _("shutdown failed; error: '%s'"),
40- drizzle_result_error(&result));
41+ fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_result_error(&result));
42 drizzle_result_free(&result);
43 }
44 else
45 {
46- fprintf(stderr, _("shutdown failed; error: '%s'"),
47- drizzle_con_error(&con));
48+ fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_con_error(con));
49 }
50 return false;
51 }
52@@ -1218,7 +1218,9 @@
53 drizzle_result_free(&result);
54
55 if (verbose)
56+ {
57 printf(_("done\n"));
58+ }
59
60 return true;
61 }
62@@ -1234,7 +1236,7 @@
63 printf("... ");
64 }
65
66- if (drizzle_kill(&con, &result, query_id,
67+ if (drizzle_kill(con, &result, query_id,
68 &ret) == NULL || ret != DRIZZLE_RETURN_OK)
69 {
70 if (ret == DRIZZLE_RETURN_ERROR_CODE)
71@@ -1245,8 +1247,7 @@
72 }
73 else
74 {
75- fprintf(stderr, _("kill failed; error: '%s'"),
76- drizzle_con_error(&con));
77+ fprintf(stderr, _("kill failed; error: '%s'"), drizzle_con_error(con));
78 }
79 return false;
80 }
81@@ -1272,7 +1273,7 @@
82 drizzle_result_st result;
83 drizzle_return_t ret;
84
85- if (drizzle_ping(&con, &result, &ret) != NULL && ret == DRIZZLE_RETURN_OK)
86+ if (drizzle_ping(con, &result, &ret) != NULL && ret == DRIZZLE_RETURN_OK)
87 {
88 if (opt_silent < 2)
89 printf(_("drizzled is alive\n"));
90@@ -1287,8 +1288,7 @@
91 }
92 else
93 {
94- fprintf(stderr, _("drizzled won't answer to ping, error: '%s'"),
95- drizzle_con_error(&con));
96+ fprintf(stderr, _("drizzled won't answer to ping, error: '%s'"), drizzle_con_error(con));
97 }
98 return false;
99 }
100@@ -1840,10 +1840,10 @@
101 glob_buffer->reserve(512);
102
103 snprintf(&output_buff[0], output_buff.size(),
104- _("Your Drizzle connection id is %u\nConnection protocol: %s\nServer version: %s\n"),
105- drizzle_con_thread_id(&con),
106- opt_protocol.c_str(),
107- server_version_string(&con));
108+ _("Your Drizzle connection id is %u\nConnection protocol: %s\nServer version: %s\n"),
109+ drizzle_con_thread_id(con),
110+ opt_protocol.c_str(),
111+ server_version_string(con));
112 put_info(&output_buff[0], INFO_INFO, 0, 0);
113
114
115@@ -1898,8 +1898,8 @@
116
117 void drizzle_end(int sig)
118 {
119- drizzle_con_free(&con);
120- drizzle_free(&drizzle);
121+ drizzle_con_free(con);
122+ drizzle_free(drizzle);
123 if (!status.getBatch() && !quick && histfile)
124 {
125 /* write-history */
126@@ -1937,39 +1937,38 @@
127 extern "C"
128 void handle_sigint(int sig)
129 {
130- char kill_buffer[40];
131- boost::scoped_ptr<drizzle_con_st> kill_drizzle(new drizzle_con_st);
132- drizzle_result_st res;
133- drizzle_return_t ret;
134-
135 /* terminate if no query being executed, or we already tried interrupting */
136- if (!executing_query || interrupted_query)
137- {
138- goto err;
139- }
140-
141- if (drizzle_con_add_tcp(&drizzle, kill_drizzle.get(), current_host.c_str(),
142- opt_drizzle_port, current_user.c_str(), opt_password.c_str(), NULL,
143- use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)
144- {
145- goto err;
146- }
147-
148- /* kill_buffer is always big enough because max length of %lu is 15 */
149- sprintf(kill_buffer, "KILL /*!50000 QUERY */ %u",
150- drizzle_con_thread_id(&con));
151-
152- if (drizzle_query_str(kill_drizzle.get(), &res, kill_buffer, &ret) != NULL)
153- drizzle_result_free(&res);
154-
155- drizzle_con_free(kill_drizzle.get());
156- tee_fprintf(stdout, _("Query aborted by Ctrl+C\n"));
157-
158- interrupted_query= 1;
159-
160- return;
161-
162-err:
163+ if (executing_query == false or interrupted_query)
164+ { }
165+ else if (drizzle)
166+ {
167+ drizzle_con_st *kill_drizzle_con;
168+ if ((kill_drizzle_con= drizzle_con_add_tcp(drizzle,
169+ current_host.c_str(), opt_drizzle_port,
170+ current_user.c_str(), opt_password.c_str(), NULL,
171+ use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL)))
172+ {
173+ /* kill_buffer is always big enough because max length of %lu is 15 */
174+ char kill_buffer[40];
175+ snprintf(kill_buffer, sizeof(kill_buffer), "KILL /*!50000 QUERY */ %u", drizzle_con_thread_id(kill_drizzle_con));
176+
177+ drizzle_return_t ret;
178+ drizzle_result_st res;
179+ if ((drizzle_query_str(kill_drizzle_con, &res, kill_buffer, &ret)))
180+ {
181+ drizzle_result_free(&res);
182+ }
183+
184+ drizzle_con_free(kill_drizzle_con);
185+
186+ tee_fprintf(stdout, _("Query aborted by Ctrl+C\n"));
187+
188+ interrupted_query= true;
189+
190+ return;
191+ }
192+ }
193+
194 drizzle_end(sig);
195 }
196
197@@ -2206,7 +2205,7 @@
198 }
199 }
200 if (!*ml_comment && inchar == '\\' &&
201- !(*in_string && (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_NO_BACKSLASH_ESCAPES)))
202+ !(*in_string && (drizzle_con_status(con) & DRIZZLE_CON_STATUS_NO_BACKSLASH_ESCAPES)))
203 {
204 // Found possbile one character command like \c
205
206@@ -2622,12 +2621,14 @@
207 /* hash Drizzle functions (to be implemented) */
208
209 /* hash all database names */
210- if (drizzle_query_str(&con, &databases, "select schema_name from information_schema.schemata", &ret) != NULL)
211+ if (drizzle_query_str(con, &databases, "select schema_name from information_schema.schemata", &ret) != NULL)
212 {
213 if (ret == DRIZZLE_RETURN_OK)
214 {
215 if (drizzle_result_buffer(&databases) != DRIZZLE_RETURN_OK)
216- put_info(drizzle_error(&drizzle),INFO_INFO,0,0);
217+ {
218+ put_info(drizzle_error(drizzle),INFO_INFO,0,0);
219+ }
220 else
221 {
222 while ((database_row=drizzle_row_next(&databases)))
223@@ -2646,8 +2647,7 @@
224 query.append(current_db);
225 query.append("' order by table_name");
226
227- if (drizzle_query(&con, &fields, query.c_str(), query.length(),
228- &ret) != NULL)
229+ if (drizzle_query(con, &fields, query.c_str(), query.length(), &ret) != NULL)
230 {
231 if (ret == DRIZZLE_RETURN_OK &&
232 drizzle_result_buffer(&fields) == DRIZZLE_RETURN_OK)
233@@ -2712,7 +2712,7 @@
234 current_db.erase();
235 current_db= "";
236 /* In case of error below current_db will be NULL */
237- if (drizzle_query_str(&con, &res, "SELECT DATABASE()", &ret) != NULL)
238+ if (drizzle_query_str(con, &res, "SELECT DATABASE()", &ret) != NULL)
239 {
240 if (ret == DRIZZLE_RETURN_OK &&
241 drizzle_result_buffer(&res) == DRIZZLE_RETURN_OK)
242@@ -2738,12 +2738,12 @@
243 for (uint32_t retry=0;; retry++)
244 {
245 int error;
246- if (drizzle_query(&con,result,buf,length,&ret) != NULL &&
247+ if (drizzle_query(con, result, buf, length, &ret) != NULL and
248 ret == DRIZZLE_RETURN_OK)
249 {
250 return 0;
251 }
252- error= put_error(&con, result);
253+ error= put_error(con, result);
254
255 if (ret == DRIZZLE_RETURN_ERROR_CODE)
256 {
257@@ -2765,14 +2765,17 @@
258 int drizzleclient_store_result_for_lazy(drizzle_result_st *result)
259 {
260 if (drizzle_result_buffer(result) == DRIZZLE_RETURN_OK)
261+ {
262 return 0;
263+ }
264
265- if (drizzle_con_error(&con)[0])
266+ if (drizzle_con_error(con)[0])
267 {
268- int ret= put_error(&con, result);
269+ int ret= put_error(con, result);
270 drizzle_result_free(result);
271 return ret;
272 }
273+
274 return 0;
275 }
276
277@@ -2836,7 +2839,7 @@
278 uint32_t error_code= 0;
279 int err= 0;
280
281- interrupted_query= 0;
282+ interrupted_query= false;
283
284 /* Remove garbage for nicer messages */
285 remove_cntrl(buffer);
286@@ -2866,7 +2869,7 @@
287 }
288
289 timer=start_timer();
290- executing_query= 1;
291+ executing_query= true;
292 error= drizzleclient_real_query_for_lazy(buffer->c_str(),buffer->length(),&result, &error_code);
293
294 if (status.getAddToHistory())
295@@ -2889,7 +2892,7 @@
296 {
297 if (drizzle_column_buffer(&result) != DRIZZLE_RETURN_OK)
298 {
299- error= put_error(&con, &result);
300+ error= put_error(con, &result);
301 goto end;
302 }
303 }
304@@ -2928,7 +2931,7 @@
305 (long) drizzle_result_row_count(&result));
306 end_pager();
307 if (drizzle_result_error_code(&result))
308- error= put_error(&con, &result);
309+ error= put_error(con, &result);
310 }
311 }
312 else if (drizzle_result_affected_rows(&result) == ~(uint64_t) 0)
313@@ -2963,9 +2966,9 @@
314 fflush(stdout);
315 drizzle_result_free(&result);
316
317- if (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS)
318+ if (drizzle_con_status(con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS)
319 {
320- if (drizzle_result_read(&con, &result, &ret) == NULL ||
321+ if (drizzle_result_read(con, &result, &ret) == NULL ||
322 ret != DRIZZLE_RETURN_OK)
323 {
324 if (ret == DRIZZLE_RETURN_ERROR_CODE)
325@@ -2974,14 +2977,16 @@
326 drizzle_result_free(&result);
327 }
328
329- error= put_error(&con, NULL);
330+ error= put_error(con, NULL);
331 goto end;
332 }
333 }
334
335- } while (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS);
336+ } while (drizzle_con_status(con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS);
337 if (err >= 1)
338- error= put_error(&con, NULL);
339+ {
340+ error= put_error(con, NULL);
341+ }
342
343 end:
344
345@@ -2989,20 +2994,20 @@
346 if (show_warnings == 1 && (warnings >= 1 || error))
347 print_warnings(error_code);
348
349- if (!error && !status.getBatch() &&
350- drizzle_con_status(&con) & DRIZZLE_CON_STATUS_DB_DROPPED)
351+ if (!error && !status.getBatch() and
352+ drizzle_con_status(con) & DRIZZLE_CON_STATUS_DB_DROPPED)
353 {
354 get_current_db();
355 }
356
357- executing_query= 0;
358+ executing_query= false;
359 return error; /* New command follows */
360 }
361
362
363 static void init_pager()
364 {
365- if (!opt_nopager)
366+ if (opt_nopager == false)
367 {
368 if (!(PAGER= popen(pager.c_str(), "w")))
369 {
370@@ -3011,7 +3016,9 @@
371 }
372 }
373 else
374+ {
375 PAGER= stdout;
376+ }
377 }
378
379 static void end_pager()
380@@ -3025,8 +3032,11 @@
381 {
382 FILE* new_outfile;
383 if (opt_outfile)
384+ {
385 end_tee();
386- if (!(new_outfile= fopen(file_name, "a")))
387+ }
388+
389+ if ((new_outfile= fopen(file_name, "a")) == NULL)
390 {
391 tee_fprintf(stdout, _("Error logging to file '%s'\n"), file_name);
392 return;
393@@ -3259,7 +3269,7 @@
394 cur= drizzle_row_buffer(result, &ret);
395 if (ret != DRIZZLE_RETURN_OK)
396 {
397- (void)put_error(&con, result);
398+ (void)put_error(con, result);
399 break;
400 }
401 }
402@@ -3465,7 +3475,7 @@
403 cur= drizzle_row_buffer(result, &ret);
404 if (ret != DRIZZLE_RETURN_OK)
405 {
406- (void)put_error(&con, result);
407+ (void)put_error(con, result);
408 break;
409 }
410 }
411@@ -3631,7 +3641,7 @@
412 cur= drizzle_row_buffer(result, &ret);
413 if (ret != DRIZZLE_RETURN_OK)
414 {
415- (void)put_error(&con, result);
416+ (void)put_error(con, result);
417 break;
418 }
419 }
420@@ -3875,7 +3885,7 @@
421
422 if (connected)
423 {
424- sprintf(buff, _("Connection id: %u"), drizzle_con_thread_id(&con));
425+ sprintf(buff, _("Connection id: %u"), drizzle_con_thread_id(con));
426 put_info(buff,INFO_INFO,0,0);
427 sprintf(buff, _("Current schema: %.128s\n"),
428 !current_db.empty() ? current_db.c_str() : _("*** NONE ***"));
429@@ -4026,21 +4036,25 @@
430 return opt_reconnect ? -1 : 1; // Fatal error
431 for (bool try_again= true; try_again; try_again= false)
432 {
433- if (drizzle_select_db(&con,&result,tmp,&ret) == NULL ||
434+ if (drizzle_select_db(con, &result, tmp, &ret) == NULL ||
435 ret != DRIZZLE_RETURN_OK)
436 {
437 if (ret == DRIZZLE_RETURN_ERROR_CODE)
438 {
439- int error= put_error(&con, &result);
440+ int error= put_error(con, &result);
441 drizzle_result_free(&result);
442 return error;
443 }
444
445 if (ret != DRIZZLE_RETURN_LOST_CONNECTION || !try_again)
446- return put_error(&con, NULL);
447+ {
448+ return put_error(con, NULL);
449+ }
450
451 if (reconnect())
452+ {
453 return opt_reconnect ? -1 : 1; // Fatal error
454+ }
455 }
456 else
457 drizzle_result_free(&result);
458@@ -4067,19 +4081,17 @@
459 printf("... ");
460 }
461
462- if (drizzle_shutdown(&con, &result, DRIZZLE_SHUTDOWN_DEFAULT,
463+ if (drizzle_shutdown(con, &result, DRIZZLE_SHUTDOWN_DEFAULT,
464 &ret) == NULL || ret != DRIZZLE_RETURN_OK)
465 {
466 if (ret == DRIZZLE_RETURN_ERROR_CODE)
467 {
468- fprintf(stderr, _("shutdown failed; error: '%s'"),
469- drizzle_result_error(&result));
470+ fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_result_error(&result));
471 drizzle_result_free(&result);
472 }
473 else
474 {
475- fprintf(stderr, _("shutdown failed; error: '%s'"),
476- drizzle_con_error(&con));
477+ fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_con_error(con));
478 }
479 return false;
480 }
481@@ -4177,27 +4189,32 @@
482 if (connected)
483 {
484 connected= 0;
485- drizzle_con_free(&con);
486- drizzle_free(&drizzle);
487- }
488- drizzle_create(&drizzle);
489-
490- if (drizzle_con_add_tcp(&drizzle, &con, (char *)host.c_str(),
491- opt_drizzle_port, (char *)user.c_str(),
492- (char *)password.c_str(), (char *)database.c_str(),
493- global_con_options) == NULL)
494- {
495- (void) put_error(&con, NULL);
496+ drizzle_con_free(con);
497+ drizzle_free(drizzle);
498+ }
499+
500+ drizzle= drizzle_create();
501+ if (drizzle == NULL)
502+ {
503+ return 1;
504+ }
505+
506+ if ((con= drizzle_con_add_tcp(drizzle, host.c_str(),
507+ opt_drizzle_port, user.c_str(),
508+ password.c_str(), database.c_str(),
509+ global_con_options)) == NULL)
510+ {
511+ (void) put_error(con, NULL);
512 (void) fflush(stdout);
513 return 1;
514 }
515
516- if ((ret= drizzle_con_connect(&con)) != DRIZZLE_RETURN_OK)
517+ if ((ret= drizzle_con_connect(con)) != DRIZZLE_RETURN_OK)
518 {
519
520 if (opt_silent < 2)
521 {
522- (void) put_error(&con, NULL);
523+ (void) put_error(con, NULL);
524 (void) fflush(stdout);
525 return ignore_errors ? -1 : 1; // Abort
526 }
527@@ -4205,7 +4222,7 @@
528 }
529 connected= 1;
530
531- ServerDetect server_detect(&con);
532+ ServerDetect server_detect(con);
533 server_type= server_detect.getServerType();
534
535 build_completion_hash(opt_rehash, 1);
536@@ -4231,12 +4248,12 @@
537
538 if (connected)
539 {
540- tee_fprintf(stdout, _("\nConnection id:\t\t%lu\n"),drizzle_con_thread_id(&con));
541+ tee_fprintf(stdout, _("\nConnection id:\t\t%lu\n"),drizzle_con_thread_id(con));
542 /*
543 Don't remove "limit 1",
544 it is protection againts SQL_SELECT_LIMIT=0
545 */
546- if (drizzle_query_str(&con,&result,"select DATABASE(), USER() limit 1",
547+ if (drizzle_query_str(con, &result, "select DATABASE(), USER() limit 1",
548 &ret) != NULL && ret == DRIZZLE_RETURN_OK &&
549 drizzle_result_buffer(&result) == DRIZZLE_RETURN_OK)
550 {
551@@ -4268,19 +4285,23 @@
552 tee_fprintf(stdout, _("Current pager:\t\t%s\n"), pager.c_str());
553 tee_fprintf(stdout, _("Using outfile:\t\t'%s'\n"), opt_outfile ? outfile.c_str() : "");
554 tee_fprintf(stdout, _("Using delimiter:\t%s\n"), delimiter);
555- tee_fprintf(stdout, _("Server version:\t\t%s\n"), server_version_string(&con));
556+ tee_fprintf(stdout, _("Server version:\t\t%s\n"), server_version_string(con));
557 tee_fprintf(stdout, _("Protocol:\t\t%s\n"), opt_protocol.c_str());
558- tee_fprintf(stdout, _("Protocol version:\t%d\n"), drizzle_con_protocol_version(&con));
559- tee_fprintf(stdout, _("Connection:\t\t%s\n"), drizzle_con_host(&con));
560+ tee_fprintf(stdout, _("Protocol version:\t%d\n"), drizzle_con_protocol_version(con));
561+ tee_fprintf(stdout, _("Connection:\t\t%s\n"), drizzle_con_host(con));
562 /* XXX need to save this from result
563 if ((id= drizzleclient_insert_id(&drizzle)))
564 tee_fprintf(stdout, "Insert id:\t\t%s\n", internal::llstr(id, buff));
565 */
566
567- if (drizzle_con_uds(&con))
568- tee_fprintf(stdout, _("UNIX socket:\t\t%s\n"), drizzle_con_uds(&con));
569+ if (drizzle_con_uds(con))
570+ {
571+ tee_fprintf(stdout, _("UNIX socket:\t\t%s\n"), drizzle_con_uds(con));
572+ }
573 else
574- tee_fprintf(stdout, _("TCP port:\t\t%d\n"), drizzle_con_port(&con));
575+ {
576+ tee_fprintf(stdout, _("TCP port:\t\t%d\n"), drizzle_con_port(con));
577+ }
578
579 if (safe_updates)
580 {
581@@ -4419,10 +4440,14 @@
582 {
583 error= drizzle_result_error(res);
584 if (!strcmp(error, ""))
585+ {
586 error= drizzle_con_error(local_con);
587+ }
588 }
589 else
590+ {
591 error= drizzle_con_error(local_con);
592+ }
593
594 return put_info(error, INFO_ERROR,
595 res == NULL ? drizzle_con_error_code(local_con) :
596@@ -4573,7 +4598,7 @@
597 break;
598 case 'v':
599 if (connected)
600- processed_prompt->append(drizzle_con_server_version(&con));
601+ processed_prompt->append(drizzle_con_server_version(con));
602 else
603 processed_prompt->append("not_connected");
604 break;
605@@ -4582,7 +4607,7 @@
606 break;
607 case 'h':
608 {
609- const char *prompt= connected ? drizzle_con_host(&con) : "not_connected";
610+ const char *prompt= connected ? drizzle_con_host(con) : "not_connected";
611 if (strstr(prompt, "Localhost"))
612 processed_prompt->append("localhost");
613 else
614@@ -4601,13 +4626,13 @@
615 break;
616 }
617
618- if (drizzle_con_uds(&con))
619+ if (drizzle_con_uds(con))
620 {
621- const char *pos=strrchr(drizzle_con_uds(&con),'/');
622- processed_prompt->append(pos ? pos+1 : drizzle_con_uds(&con));
623+ const char *pos=strrchr(drizzle_con_uds(con),'/');
624+ processed_prompt->append(pos ? pos+1 : drizzle_con_uds(con));
625 }
626 else
627- add_int_to_prompt(drizzle_con_port(&con));
628+ add_int_to_prompt(drizzle_con_port(con));
629 }
630 break;
631 case 'U':
632
633=== modified file 'client/drizzledump_data.cc'
634--- client/drizzledump_data.cc 2011-08-07 20:48:33 +0000
635+++ client/drizzledump_data.cc 2011-11-29 23:07:26 +0000
636@@ -17,8 +17,10 @@
637 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
638 */
639
640-#include "drizzledump_data.h"
641-#include "client_priv.h"
642+#include <config.h>
643+
644+#include "client/drizzledump_data.h"
645+#include "client/client_priv.h"
646 #include <drizzled/definitions.h>
647 #include <drizzled/gettext.h>
648 #include <string>
649@@ -541,10 +543,10 @@
650 hostName(host),
651 drizzleProtocol(drizzle_protocol)
652 {
653- drizzle_return_t ret;
654-
655 if (host.empty())
656+ {
657 host= "localhost";
658+ }
659
660 std::string protocol= (drizzle_protocol) ? "Drizzle" : "MySQL";
661 if (verbose)
662@@ -552,21 +554,27 @@
663 std::cerr << _("-- Connecting to ") << host << _(" using protocol ")
664 << protocol << "..." << std::endl;
665 }
666- drizzle_create(&drizzle);
667- drizzle_con_create(&drizzle, &connection);
668- drizzle_con_set_tcp(&connection, (char *)host.c_str(), port);
669- drizzle_con_set_auth(&connection, (char *)username.c_str(),
670- (char *)password.c_str());
671- drizzle_con_add_options(&connection,
672- drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);
673- ret= drizzle_con_connect(&connection);
674+
675+ drizzle= drizzle_create();
676+
677+ if (drizzle == NULL)
678+ {
679+ std::cerr << "drizzle_create() failed" << std::endl;
680+ }
681+
682+ connection= drizzle_con_create(drizzle);
683+ drizzle_con_set_tcp(connection, (char *)host.c_str(), port);
684+ drizzle_con_set_auth(connection, (char *)username.c_str(), (char *)password.c_str());
685+ drizzle_con_add_options(connection, drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);
686+
687+ drizzle_return_t ret= drizzle_con_connect(connection);
688 if (ret != DRIZZLE_RETURN_OK)
689 {
690 errorHandler(NULL, ret, "when trying to connect");
691 throw std::exception();
692 }
693
694- ServerDetect server_detect= ServerDetect(&connection);
695+ ServerDetect server_detect= ServerDetect(connection);
696
697 serverType= server_detect.getServerType();
698 serverVersion= server_detect.getServerVersion();
699@@ -576,7 +584,7 @@
700 {
701 drizzle_return_t ret;
702 drizzle_result_st* result= new drizzle_result_st;
703- if (drizzle_query_str(&connection, result, str_query.c_str(), &ret) == NULL ||
704+ if (drizzle_query_str(connection, result, str_query.c_str(), &ret) == NULL or
705 ret != DRIZZLE_RETURN_OK)
706 {
707 if (ret == DRIZZLE_RETURN_ERROR_CODE)
708@@ -587,16 +595,14 @@
709 }
710 else
711 {
712- std::cerr << _("Error executing query: ") <<
713- drizzle_con_error(&connection) << std::endl;
714+ std::cerr << _("Error executing query: ") << drizzle_con_error(connection) << std::endl;
715 }
716 return NULL;
717 }
718
719 if (drizzle_result_buffer(result) != DRIZZLE_RETURN_OK)
720 {
721- std::cerr << _("Could not buffer result: ") <<
722- drizzle_con_error(&connection) << std::endl;
723+ std::cerr << _("Could not buffer result: ") << drizzle_con_error(connection) << std::endl;
724 return NULL;
725 }
726 return result;
727@@ -613,7 +619,7 @@
728 drizzle_return_t ret;
729 drizzle_result_st result;
730
731- if (drizzle_query_str(&connection, &result, str_query.c_str(), &ret) == NULL ||
732+ if (drizzle_query_str(connection, &result, str_query.c_str(), &ret) == NULL or
733 ret != DRIZZLE_RETURN_OK)
734 {
735 if (ret == DRIZZLE_RETURN_ERROR_CODE)
736@@ -624,8 +630,7 @@
737 }
738 else
739 {
740- std::cerr << _("Error executing query: ") <<
741- drizzle_con_error(&connection) << std::endl;
742+ std::cerr << _("Error executing query: ") << drizzle_con_error(connection) << std::endl;
743 }
744 return false;
745 }
746@@ -638,15 +643,20 @@
747 {
748 drizzle_return_t ret;
749 drizzle_result_st result;
750- if (drizzle_select_db(&connection, &result, databaseName.c_str(), &ret) ==
751- NULL || ret != DRIZZLE_RETURN_OK)
752+
753+ if (drizzle_select_db(connection, &result, databaseName.c_str(), &ret) == NULL or
754+ ret != DRIZZLE_RETURN_OK)
755 {
756 std::cerr << _("Error: Could not set db '") << databaseName << "'" << std::endl;
757 if (ret == DRIZZLE_RETURN_ERROR_CODE)
758+ {
759 drizzle_result_free(&result);
760+ }
761+
762 return false;
763 }
764 drizzle_result_free(&result);
765+
766 return true;
767 }
768
769@@ -655,8 +665,7 @@
770 {
771 if (res == NULL)
772 {
773- std::cerr << _("Got error: ") << drizzle_con_error(&connection) << " "
774- << when << std::endl;
775+ std::cerr << _("Got error: ") << drizzle_con_error(connection) << " " << when << std::endl;
776 }
777 else if (ret == DRIZZLE_RETURN_ERROR_CODE)
778 {
779@@ -675,7 +684,10 @@
780 DrizzleDumpConnection::~DrizzleDumpConnection()
781 {
782 if (verbose)
783+ {
784 std::cerr << _("-- Disconnecting from ") << hostName << "..." << std::endl;
785- drizzle_con_free(&connection);
786- drizzle_free(&drizzle);
787+ }
788+
789+ drizzle_con_free(connection);
790+ drizzle_free(drizzle);
791 }
792
793=== modified file 'client/drizzledump_data.h'
794--- client/drizzledump_data.h 2011-08-14 17:04:01 +0000
795+++ client/drizzledump_data.h 2011-11-29 23:07:26 +0000
796@@ -212,17 +212,22 @@
797 class DrizzleDumpConnection
798 {
799 private:
800- drizzle_st drizzle;
801- drizzle_con_st connection;
802+ drizzle_st *drizzle;
803+ drizzle_con_st *connection;
804 std::string hostName;
805 bool drizzleProtocol;
806 ServerDetect::server_type serverType;
807 std::string serverVersion;
808
809 public:
810- DrizzleDumpConnection(std::string &host, uint16_t port,
811- std::string &username, std::string &password, bool drizzle_protocol);
812+ DrizzleDumpConnection(std::string &host,
813+ uint16_t port,
814+ std::string &username,
815+ std::string &password,
816+ bool drizzle_protocol);
817+
818 ~DrizzleDumpConnection();
819+
820 void errorHandler(drizzle_result_st *res, drizzle_return_t ret, const char *when);
821 drizzle_result_st* query(std::string &str_query);
822 bool queryNoResult(std::string &str_query);
823@@ -232,6 +237,7 @@
824 std::string str_query(ch_query);
825 return query(str_query);
826 }
827+
828 bool queryNoResult(const char* ch_query)
829 {
830 std::string str_query(ch_query);
831@@ -263,7 +269,9 @@
832 void writeString(std::string &str)
833 {
834 if (not connection->queryNoResult(str))
835+ {
836 throw std::exception();
837+ }
838 }
839
840 void setConnection(DrizzleDumpConnection *conn) { connection= conn; }
841
842=== modified file 'client/drizzleimport.cc'
843--- client/drizzleimport.cc 2011-08-07 22:41:28 +0000
844+++ client/drizzleimport.cc 2011-11-29 23:07:26 +0000
845@@ -201,11 +201,20 @@
846 drizzle_return_t ret;
847
848 if (verbose)
849+ {
850 fprintf(stdout, "Connecting to %s, using protocol %s...\n", ! host.empty() ? host.c_str() : "localhost", opt_protocol.c_str());
851- if (!(drizzle= drizzle_create(NULL)))
852+ }
853+
854+ if ((drizzle= drizzle_create()) == NULL)
855+ {
856 return 0;
857- if (!(con= drizzle_con_add_tcp(drizzle,NULL,(char *)host.c_str(),opt_drizzle_port,(char *)user.c_str(),(char *)passwd.c_str(),
858- (char *)database.c_str(), use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL)))
859+ }
860+
861+ if (!(con= drizzle_con_add_tcp(drizzle,
862+ host.c_str(), opt_drizzle_port,
863+ user.c_str(), passwd.c_str(),
864+ database.c_str(),
865+ use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL)))
866 {
867 return 0;
868 }
869
870=== modified file 'client/drizzleslap.cc'
871--- client/drizzleslap.cc 2011-08-12 16:41:20 +0000
872+++ client/drizzleslap.cc 2011-11-29 23:07:26 +0000
873@@ -233,8 +233,8 @@
874 void option_cleanup(OptionString *stmt);
875 void concurrency_loop(drizzle_con_st &con, uint32_t current, OptionString *eptr);
876 static void run_statements(drizzle_con_st &con, Statement *stmt);
877-void slap_connect(drizzle_con_st &con, bool connect_to_schema);
878-void slap_close(drizzle_con_st &con);
879+drizzle_con_st *slap_connect(bool connect_to_schema);
880+void slap_close(drizzle_con_st *con);
881 static int run_query(drizzle_con_st &con, drizzle_result_st *result, const char *query, int len);
882 void standard_deviation(Conclusions &con, Stats *sptr);
883
884@@ -273,23 +273,25 @@
885 uint64_t counter= 0, queries;
886 uint64_t detach_counter;
887 uint32_t commit_counter;
888- boost::scoped_ptr<drizzle_con_st> con_ap(new drizzle_con_st);
889- drizzle_con_st &con= *con_ap.get();
890 drizzle_result_st result;
891 drizzle_row_t row;
892 Statement *ptr;
893
894 master_wakeup.wait();
895
896- slap_connect(con, true);
897+ drizzle_con_st *con= slap_connect(true);
898
899 if (verbose >= 3)
900+ {
901 printf("connected!\n");
902+ }
903 queries= 0;
904
905 commit_counter= 0;
906 if (commit_rate)
907- run_query(con, NULL, "SET AUTOCOMMIT=0", strlen("SET AUTOCOMMIT=0"));
908+ {
909+ run_query(*con, NULL, "SET AUTOCOMMIT=0", strlen("SET AUTOCOMMIT=0"));
910+ }
911
912 limit_not_met:
913 for (ptr= ctx->getStmt(), detach_counter= 0;
914@@ -299,7 +301,7 @@
915 if (not opt_only_print && detach_rate && !(detach_counter % detach_rate))
916 {
917 slap_close(con);
918- slap_connect(con, true);
919+ con= slap_connect(true);
920 }
921
922 /*
923@@ -329,7 +331,7 @@
924
925 int length= snprintf(buffer, HUGE_STRING_LENGTH, "%.*s '%s'", (int)ptr->getLength(), ptr->getString(), key);
926
927- if (run_query(con, &result, buffer, length))
928+ if (run_query(*con, &result, buffer, length))
929 {
930 if ((ptr->getType() == UPDATE_TYPE_REQUIRES_PREFIX) and commit_rate)
931 {
932@@ -342,7 +344,7 @@
933 else
934 {
935 fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",
936- SLAP_NAME, (uint32_t)length, buffer, drizzle_con_error(&con));
937+ SLAP_NAME, (uint32_t)length, buffer, drizzle_con_error(con));
938 abort();
939 }
940 }
941@@ -350,7 +352,7 @@
942 }
943 else
944 {
945- if (run_query(con, &result, ptr->getString(), ptr->getLength()))
946+ if (run_query(*con, &result, ptr->getString(), ptr->getLength()))
947 {
948 if ((ptr->getType() == UPDATE_TYPE_REQUIRES_PREFIX) and commit_rate)
949 {
950@@ -363,7 +365,7 @@
951 else
952 {
953 fprintf(stderr,"%s: Cannot run query %.*s ERROR : %s\n",
954- SLAP_NAME, (uint32_t)ptr->getLength(), ptr->getString(), drizzle_con_error(&con));
955+ SLAP_NAME, (uint32_t)ptr->getLength(), ptr->getString(), drizzle_con_error(con));
956 abort();
957 }
958 }
959@@ -380,7 +382,7 @@
960 if (commit_rate && (++commit_counter == commit_rate) and not is_failed_update)
961 {
962 commit_counter= 0;
963- run_query(con, NULL, "COMMIT", strlen("COMMIT"));
964+ run_query(*con, NULL, "COMMIT", strlen("COMMIT"));
965 }
966
967 /* If the timer is set, and the alarm is not active then end */
968@@ -401,9 +403,12 @@
969
970 end:
971 if (commit_rate)
972- run_query(con, NULL, "COMMIT", strlen("COMMIT"));
973+ {
974+ run_query(*con, NULL, "COMMIT", strlen("COMMIT"));
975+ }
976
977 slap_close(con);
978+ con= NULL;
979
980 delete ctx;
981 }
982@@ -560,7 +565,6 @@
983
984 uint64_t temp_drizzle_port= 0;
985 boost::scoped_ptr<drizzle_con_st> con_ap(new drizzle_con_st);
986- drizzle_con_st &con= *con_ap.get();
987 OptionString *eptr;
988
989 // Disable allow_guessing
990@@ -674,7 +678,7 @@
991 /* globals? Yes, so we only have to run strlen once */
992 delimiter_length= delimiter.length();
993
994- slap_connect(con, false);
995+ drizzle_con_st *con= slap_connect(false);
996
997 /* Main iterations loop */
998 burnin:
999@@ -690,24 +694,26 @@
1000 if (concurrency.size())
1001 {
1002 for (current= &concurrency[0]; current && *current; current++)
1003- concurrency_loop(con, *current, eptr);
1004+ concurrency_loop(*con, *current, eptr);
1005 }
1006 else
1007 {
1008 uint32_t infinite= 1;
1009 do {
1010- concurrency_loop(con, infinite, eptr);
1011+ concurrency_loop(*con, infinite, eptr);
1012 }
1013 while (infinite++);
1014 }
1015
1016 if (not opt_preserve)
1017- drop_schema(con, create_schema_string.c_str());
1018+ drop_schema(*con, create_schema_string.c_str());
1019
1020 } while (eptr ? (eptr= eptr->getNext()) : 0);
1021
1022 if (opt_burnin)
1023+ {
1024 goto burnin;
1025+ }
1026
1027 slap_close(con);
1028
1029@@ -2372,12 +2378,12 @@
1030 }
1031 }
1032
1033-void slap_close(drizzle_con_st &con)
1034+void slap_close(drizzle_con_st *con)
1035 {
1036- drizzle_free(drizzle_con_drizzle(&con));
1037+ drizzle_free(drizzle_con_drizzle(con));
1038 }
1039
1040-void slap_connect(drizzle_con_st &con, bool connect_to_schema)
1041+drizzle_con_st* slap_connect(bool connect_to_schema)
1042 {
1043 /* Connect to server */
1044 static uint32_t connection_retry_sleep= 100000; /* Microseconds */
1045@@ -2388,12 +2394,13 @@
1046 if (opt_delayed_start)
1047 usleep(random()%opt_delayed_start);
1048
1049- if ((drizzle= drizzle_create(NULL)) == NULL ||
1050- drizzle_con_add_tcp(drizzle, &con, host.c_str(), opt_drizzle_port,
1051- user.c_str(),
1052- opt_password.c_str(),
1053- connect_to_schema ? create_schema_string.c_str() : NULL,
1054- use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)
1055+ drizzle_con_st* con;
1056+ if ((drizzle= drizzle_create()) == NULL or
1057+ (con= drizzle_con_add_tcp(drizzle,
1058+ host.c_str(), opt_drizzle_port,
1059+ user.c_str(), opt_password.c_str(),
1060+ connect_to_schema ? create_schema_string.c_str() : NULL,
1061+ use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL)) == NULL)
1062 {
1063 fprintf(stderr,"%s: Error creating drizzle object\n", SLAP_NAME);
1064 abort();
1065@@ -2402,11 +2409,13 @@
1066 drizzle_set_context(drizzle, (void*)(connection_count.fetch_and_increment()));
1067
1068 if (opt_only_print)
1069- return;
1070+ {
1071+ return con;
1072+ }
1073
1074 for (uint32_t x= 0; x < 10; x++)
1075 {
1076- if ((ret= drizzle_con_connect(&con)) == DRIZZLE_RETURN_OK)
1077+ if ((ret= drizzle_con_connect(con)) == DRIZZLE_RETURN_OK)
1078 {
1079 /* Connect suceeded */
1080 connect_error= 0;
1081@@ -2417,9 +2426,11 @@
1082 if (connect_error)
1083 {
1084 fprintf(stderr,"%s: Error when connecting to server: %d %s\n", SLAP_NAME,
1085- ret, drizzle_con_error(&con));
1086+ ret, drizzle_con_error(con));
1087 abort();
1088 }
1089+
1090+ return con;
1091 }
1092
1093 void standard_deviation(Conclusions &con, Stats *sptr)
1094
1095=== modified file 'drizzled/internal/m_string.h'
1096--- drizzled/internal/m_string.h 2011-07-07 13:41:07 +0000
1097+++ drizzled/internal/m_string.h 2011-11-29 23:07:26 +0000
1098@@ -19,12 +19,12 @@
1099 #pragma once
1100
1101 #include <strings.h>
1102-#include <string.h>
1103-#include <stdlib.h>
1104-#include <stddef.h>
1105+#include <cstring>
1106+#include <cstdlib>
1107+#include <cstddef>
1108 #include <cassert>
1109-#include <limits.h>
1110-#include <ctype.h>
1111+#include <climits>
1112+#include <cctype>
1113
1114 #include <drizzled/visibility.h>
1115
1116
1117=== modified file 'examples/client.cc'
1118--- examples/client.cc 2011-11-04 21:06:16 +0000
1119+++ examples/client.cc 2011-11-29 23:07:26 +0000
1120@@ -73,7 +73,7 @@
1121
1122 typedef struct
1123 {
1124- drizzle_st drizzle;
1125+ drizzle_st *drizzle;
1126 bool mysql_protocol;
1127 client_con_st *client_con_list;
1128 uint32_t client_con_count;
1129@@ -88,8 +88,8 @@
1130 void column_info(drizzle_column_st *column);
1131
1132 #define CLIENT_ERROR(__function, __ret, __client) { \
1133- printf(__function ":%d:%s\n", __ret, \
1134- drizzle_error(&((__client)->drizzle))); \
1135+ fprintf(stderr, __function ":%d:%s\n", __ret, \
1136+ drizzle_error(((__client)->drizzle))); \
1137 exit(1); }
1138
1139 int main(int argc, char *argv[])
1140@@ -100,7 +100,6 @@
1141 drizzle_return_t ret;
1142 uint32_t x;
1143 int wait_for_connections= 0;
1144- drizzle_con_st *con;
1145 client_con_st *client_con;
1146 char *host= NULL;
1147 in_port_t port= 0;
1148@@ -132,7 +131,7 @@
1149 client.level= BUFFER_ALL;
1150 else
1151 {
1152- printf("Invalid buffer level: %s\n", optarg);
1153+ fprintf(stderr, "Invalid buffer level: %s\n", optarg);
1154 exit(0);
1155 }
1156 break;
1157@@ -198,20 +197,22 @@
1158 sizeof(client_con_st));
1159 if (client.client_con_list == NULL)
1160 {
1161- printf("calloc:%d\n", errno);
1162+ fprintf(stderr, "calloc:%d\n", errno);
1163 exit(1);
1164 }
1165 }
1166
1167 /* This may fail if there is other initialization that fails. See docs. */
1168- if (drizzle_create(&(client.drizzle)) == NULL)
1169+ if ((client.drizzle= drizzle_create()) == NULL)
1170 {
1171- printf("drizzle_create failed\n");
1172+ fprintf(stderr, "drizzle_create failed\n");
1173 exit(1);
1174 }
1175
1176 if (blocking == 0)
1177- drizzle_add_options(&(client.drizzle), DRIZZLE_NON_BLOCKING);
1178+ {
1179+ drizzle_set_option(client.drizzle, DRIZZLE_NON_BLOCKING, true);
1180+ }
1181
1182 /* Start all connections, and if in non-blocking mode, return as soon as the
1183 connection would block. In blocking mode, this completes the entire
1184@@ -219,14 +220,15 @@
1185 for (x= 0; x < client.client_con_count; x++)
1186 {
1187 /* This may fail if there is other initialization that fails. See docs. */
1188- con= drizzle_con_add_tcp(&(client.drizzle),
1189- &(client.client_con_list[x].con),
1190- host, port, user, password, db,
1191- client.mysql_protocol
1192- ? DRIZZLE_CON_MYSQL
1193- : DRIZZLE_CON_NONE);
1194+ drizzle_con_st *con= drizzle_con_add_tcp(client.drizzle,
1195+ host, port, user, password, db,
1196+ client.mysql_protocol
1197+ ? DRIZZLE_CON_MYSQL
1198+ : DRIZZLE_CON_NONE);
1199 if (con == NULL)
1200+ {
1201 CLIENT_ERROR("drizzle_con_add_tcp", 0, &client);
1202+ }
1203 drizzle_con_set_context(&(client.client_con_list[x].con),
1204 &(client.client_con_list[x]));
1205
1206@@ -238,23 +240,30 @@
1207 ready. Loop exits when all connections have completed. */
1208 while (wait_for_connections != 0)
1209 {
1210- ret= drizzle_con_wait(&(client.drizzle));
1211+ ret= drizzle_con_wait(client.drizzle);
1212 if (ret != DRIZZLE_RETURN_OK)
1213+ {
1214 CLIENT_ERROR("drizzle_con_wait", ret, &client);
1215+ }
1216
1217- while ((con= drizzle_con_ready(&(client.drizzle))) != NULL)
1218+ drizzle_con_st* con;
1219+ while ((con= drizzle_con_ready(client.drizzle)) != NULL)
1220 {
1221 client_con= (client_con_st *)drizzle_con_context(con);
1222
1223 if (client_process(&client, client_con) == 0)
1224+ {
1225 wait_for_connections--;
1226+ }
1227 }
1228 }
1229
1230 for (x= 0; x < client.client_con_count; x++)
1231+ {
1232 drizzle_con_free(&(client.client_con_list[x].con));
1233+ }
1234
1235- drizzle_free(&(client.drizzle));
1236+ drizzle_free(client.drizzle);
1237
1238 free(client.client_con_list);
1239
1240@@ -283,14 +292,20 @@
1241 (void)drizzle_query(&(client_con->con), &(client_con->result),
1242 client->query, client->query_len, &ret);
1243 if (ret == DRIZZLE_RETURN_IO_WAIT)
1244+ {
1245 return 1;
1246+ }
1247 else if (ret != DRIZZLE_RETURN_OK)
1248+ {
1249 CLIENT_ERROR("drizzle_query", ret, client);
1250+ }
1251
1252 result_info(&(client_con->result));
1253
1254 if (drizzle_result_column_count(&(client_con->result)) == 0)
1255+ {
1256 break;
1257+ }
1258
1259 client_con->state= CLIENT_FIELDS;
1260
1261@@ -299,9 +314,13 @@
1262 {
1263 ret= drizzle_result_buffer(&(client_con->result));
1264 if (ret == DRIZZLE_RETURN_IO_WAIT)
1265+ {
1266 return 1;
1267+ }
1268 else if (ret != DRIZZLE_RETURN_OK)
1269+ {
1270 CLIENT_ERROR("drizzle_result_buffer", ret, client);
1271+ }
1272
1273 while ((column= drizzle_column_next(&(client_con->result))) != NULL)
1274 column_info(column);
1275@@ -313,9 +332,13 @@
1276 column= drizzle_column_read(&(client_con->result),
1277 &(client_con->column), &ret);
1278 if (ret == DRIZZLE_RETURN_IO_WAIT)
1279+ {
1280 return 1;
1281+ }
1282 else if (ret != DRIZZLE_RETURN_OK)
1283+ {
1284 CLIENT_ERROR("drizzle_column_read", ret, client);
1285+ }
1286
1287 if (column == NULL)
1288 break;
1289@@ -335,17 +358,17 @@
1290 {
1291 field_sizes= drizzle_row_field_sizes(&(client_con->result));
1292
1293- printf("Row: %" PRId64 "\n",
1294- drizzle_row_current(&(client_con->result)));
1295+ printf("Row: %" PRId64 "\n", drizzle_row_current(&(client_con->result)));
1296
1297 for (x= 0; x < drizzle_result_column_count(&(client_con->result)); x++)
1298 {
1299 if (row[x] == NULL)
1300+ {
1301 printf(" (NULL)\n");
1302+ }
1303 else
1304 {
1305- printf(" (%"PRIu64") %.*s\n", static_cast<uint64_t>(field_sizes[x]), (int32_t)field_sizes[x],
1306- row[x]);
1307+ printf(" (%"PRIu64") %.*s\n", static_cast<uint64_t>(field_sizes[x]), (int32_t)field_sizes[x], row[x]);
1308 }
1309 }
1310
1311@@ -404,15 +427,22 @@
1312 CLIENT_ERROR("drizzle_field_read", ret, client);
1313
1314 if (field == NULL)
1315+ {
1316 printf(" (NULL)");
1317+ }
1318 else if (offset > 0)
1319+ {
1320 printf("%.*s", (int32_t)length, field);
1321+ }
1322 else
1323- printf(" (%" PRIu64 " %.*s", (uint64_t)total,
1324- (int32_t)length, field);
1325+ {
1326+ printf(" (%" PRIu64 " %.*s", (uint64_t)total, (int32_t)length, field);
1327+ }
1328
1329 if (offset + length == total)
1330+ {
1331 printf("\n");
1332+ }
1333
1334 /* If we buffered the entire field, be sure to free it. */
1335 if (client->level == BUFFER_FIELD)
1336
1337=== modified file 'examples/pipe_query.cc'
1338--- examples/pipe_query.cc 2011-11-04 21:06:16 +0000
1339+++ examples/pipe_query.cc 2011-11-29 23:07:26 +0000
1340@@ -54,31 +54,23 @@
1341 char *buffer= NULL;
1342 size_t buffer_size= 0;
1343 ssize_t read_size= 0;
1344- drizzle_st drizzle;
1345- drizzle_con_st *con= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
1346+ drizzle_st *drizzle;
1347 drizzle_result_st result;
1348- drizzle_return_t ret;
1349- drizzle_field_t field;
1350 size_t offset;
1351 size_t size;
1352 size_t total;
1353
1354- if (con == NULL)
1355- {
1356- printf("Failed to allocate memory for drizzle connection");
1357- exit(1);
1358- }
1359-
1360 /* The docs say this might fail, so check for errors. */
1361- if (drizzle_create(&drizzle) == NULL)
1362+ if ((drizzle= drizzle_create()) == NULL)
1363 {
1364 printf("drizzle_create:failed\n");
1365 exit(1);
1366 }
1367
1368- if (drizzle_con_create(&drizzle, con) == NULL)
1369+ drizzle_con_st *con;
1370+ if ((con= drizzle_con_create(drizzle)) == NULL)
1371 {
1372- printf("drizzle_con_create:%s\n", drizzle_error(&drizzle));
1373+ printf("drizzle_con_create:%s\n", drizzle_error(drizzle));
1374 exit(1);
1375 }
1376
1377@@ -146,10 +138,11 @@
1378
1379 } while ((read_size= read(0, buffer + buffer_size, BUFFER_CHUNK)) != 0);
1380
1381+ drizzle_return_t ret;
1382 (void)drizzle_query(con, &result, buffer, buffer_size, &ret);
1383 if (ret != DRIZZLE_RETURN_OK)
1384 {
1385- printf("drizzle_query:%s\n", drizzle_error(&drizzle));
1386+ printf("drizzle_query:%s\n", drizzle_error(drizzle));
1387 return 1;
1388 }
1389
1390@@ -158,7 +151,7 @@
1391 ret= drizzle_column_skip(&result);
1392 if (ret != DRIZZLE_RETURN_OK)
1393 {
1394- printf("drizzle_column_skip:%s\n", drizzle_error(&drizzle));
1395+ printf("drizzle_column_skip:%s\n", drizzle_error(drizzle));
1396 return 1;
1397 }
1398
1399@@ -166,22 +159,30 @@
1400 {
1401 while (1)
1402 {
1403- field= drizzle_field_read(&result, &offset, &size, &total, &ret);
1404+ drizzle_field_t field= drizzle_field_read(&result, &offset, &size, &total, &ret);
1405 if (ret == DRIZZLE_RETURN_ROW_END)
1406+ {
1407 break;
1408+ }
1409 else if (ret != DRIZZLE_RETURN_OK)
1410 {
1411- printf("drizzle_field_read:%s\n", drizzle_error(&drizzle));
1412+ printf("drizzle_field_read:%s\n", drizzle_error(drizzle));
1413 return 1;
1414 }
1415
1416 if (field == NULL)
1417+ {
1418 printf("NULL");
1419+ }
1420 else
1421+ {
1422 printf("%.*s", (int)size, field);
1423+ }
1424
1425 if (offset + size == total)
1426+ {
1427 printf("\t");
1428+ }
1429 }
1430
1431 printf("\n");
1432@@ -189,14 +190,13 @@
1433
1434 if (ret != DRIZZLE_RETURN_OK)
1435 {
1436- printf("drizzle_row_read:%s\n", drizzle_error(&drizzle));
1437+ printf("drizzle_row_read:%s\n", drizzle_error(drizzle));
1438 return 1;
1439 }
1440
1441 drizzle_result_free(&result);
1442 drizzle_con_free(con);
1443- drizzle_free(&drizzle);
1444+ drizzle_free(drizzle);
1445
1446- free(con);
1447 return 0;
1448 }
1449
1450=== modified file 'examples/proxy.cc'
1451--- examples/proxy.cc 2011-11-04 21:06:16 +0000
1452+++ examples/proxy.cc 2011-11-29 23:07:26 +0000
1453@@ -50,13 +50,14 @@
1454
1455 #define DRIZZLE_RETURN_ERROR(__function, __drizzle) \
1456 { \
1457- printf(__function ":%s\n", drizzle_error(__drizzle)); \
1458+ fprintf(stderr, __function ":%s\n", drizzle_error(__drizzle)); \
1459 return; \
1460 }
1461
1462-static void proxy(drizzle_st *drizzle, drizzle_con_st *server,
1463- drizzle_con_st *client, drizzle_result_st *server_result,
1464- drizzle_result_st *client_result, drizzle_column_st *column);
1465+static void proxy(drizzle_st *drizzle,
1466+ drizzle_con_st *server,
1467+ drizzle_con_st *client,
1468+ drizzle_column_st *column);
1469
1470 int main(int argc, char *argv[])
1471 {
1472@@ -70,11 +71,7 @@
1473 in_port_t client_port= 0;
1474 drizzle_verbose_t verbose= DRIZZLE_VERBOSE_NEVER;
1475 drizzle_return_t ret;
1476- drizzle_st drizzle;
1477- drizzle_con_st *con_listen= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
1478- drizzle_con_st *server= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
1479- drizzle_con_st *client= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
1480- drizzle_result_st server_result;
1481+ drizzle_st *drizzle;
1482 drizzle_result_st client_result;
1483 drizzle_column_st column;
1484
1485@@ -135,32 +132,33 @@
1486 break;
1487
1488 default:
1489- printf("\nusage: %s [-c <count>] [-h <host>] [-H <host>] [-m] [-M] "
1490+ fprintf(stderr, "\nusage: %s [-c <count>] [-h <host>] [-H <host>] [-m] [-M] "
1491 "[-p <port>] [-p <port>] [-v]\n", argv[0]);
1492- printf("\t-c <count> - Number of connections to accept before exiting\n");
1493- printf("\t-h <host> - Host to listen on\n");
1494- printf("\t-H <host> - Host to connect to\n");
1495- printf("\t-m - Use MySQL protocol for incoming connections\n");
1496- printf("\t-M - Use MySQL protocol for outgoing connectionsn\n");
1497- printf("\t-p <port> - Port to listen on\n");
1498- printf("\t-P <port> - Port to connect to\n");
1499- printf("\t-v - Increase verbosity level\n");
1500+ fprintf(stderr, "\t-c <count> - Number of connections to accept before exiting\n");
1501+ fprintf(stderr, "\t-h <host> - Host to listen on\n");
1502+ fprintf(stderr, "\t-H <host> - Host to connect to\n");
1503+ fprintf(stderr, "\t-m - Use MySQL protocol for incoming connections\n");
1504+ fprintf(stderr, "\t-M - Use MySQL protocol for outgoing connectionsn\n");
1505+ fprintf(stderr, "\t-p <port> - Port to listen on\n");
1506+ fprintf(stderr, "\t-P <port> - Port to connect to\n");
1507+ fprintf(stderr, "\t-v - Increase verbosity level\n");
1508 return 1;
1509 }
1510 }
1511
1512- if (drizzle_create(&drizzle) == NULL)
1513+ if ((drizzle= drizzle_create()) == NULL)
1514 {
1515- printf("drizzle_create:NULL\n");
1516+ fprintf(stderr, "drizzle_create:NULL\n");
1517 return 1;
1518 }
1519
1520- drizzle_add_options(&drizzle, DRIZZLE_FREE_OBJECTS);
1521- drizzle_set_verbose(&drizzle, verbose);
1522+ drizzle_set_option(drizzle, DRIZZLE_FREE_OBJECTS, true);
1523+ drizzle_set_verbose(drizzle, verbose);
1524
1525- if (drizzle_con_create(&drizzle, con_listen) == NULL)
1526+ drizzle_con_st *con_listen;
1527+ if ((con_listen= drizzle_con_create(drizzle)) == NULL)
1528 {
1529- printf("drizzle_con_create:NULL\n");
1530+ fprintf(stderr, "drizzle_con_create:NULL\n");
1531 return 1;
1532 }
1533
1534@@ -168,43 +166,48 @@
1535 drizzle_con_set_tcp(con_listen, server_host, server_port);
1536
1537 if (server_mysql)
1538+ {
1539 drizzle_con_add_options(con_listen, DRIZZLE_CON_MYSQL);
1540+ }
1541
1542 if (drizzle_con_listen(con_listen) != DRIZZLE_RETURN_OK)
1543 {
1544- printf("drizzle_con_listen:%s\n", drizzle_error(&drizzle));
1545+ fprintf(stderr, "drizzle_con_listen:%s\n", drizzle_error(drizzle));
1546 return 1;
1547 }
1548
1549 while (1)
1550 {
1551- (void)drizzle_con_accept(&drizzle, server, &ret);
1552+ drizzle_con_st *server= drizzle_con_accept(drizzle, &ret);
1553 if (ret != DRIZZLE_RETURN_OK)
1554 {
1555- printf("drizzle_con_accept:%s\n", drizzle_error(&drizzle));
1556+ fprintf(stderr, "drizzle_con_accept:%s\n", drizzle_error(drizzle));
1557 return 1;
1558 }
1559
1560- if (drizzle_con_create(&drizzle, client) == NULL)
1561+ drizzle_con_st *client;
1562+ if ((client= drizzle_con_create(drizzle)) == NULL)
1563 {
1564- printf("drizzle_con_create:NULL\n");
1565+ fprintf(stderr, "drizzle_con_create:NULL\n");
1566 return 1;
1567 }
1568
1569 drizzle_con_add_options(client,
1570 DRIZZLE_CON_RAW_PACKET | DRIZZLE_CON_RAW_SCRAMBLE);
1571 if (client_mysql)
1572+ {
1573 drizzle_con_add_options(client, DRIZZLE_CON_MYSQL);
1574+ }
1575 drizzle_con_set_tcp(client, client_host, client_port);
1576
1577 ret= drizzle_con_connect(client);
1578 if (ret != DRIZZLE_RETURN_OK)
1579 {
1580- printf("drizzle_con_connect:%s\n", drizzle_error(&drizzle));
1581+ fprintf(stderr, "drizzle_con_connect:%s\n", drizzle_error(drizzle));
1582 return 1;
1583 }
1584
1585- proxy(&drizzle, server, client, &server_result, &client_result, &column);
1586+ proxy(drizzle, server, client, &column);
1587
1588 drizzle_con_free(client);
1589 drizzle_con_free(server);
1590@@ -219,18 +222,14 @@
1591 }
1592
1593 drizzle_con_free(con_listen);
1594- drizzle_free(&drizzle);
1595-
1596- free(con_listen);
1597- free(server);
1598- free(client);
1599+ drizzle_free(drizzle);
1600
1601 return 0;
1602 }
1603
1604 static void proxy(drizzle_st *drizzle, drizzle_con_st *server,
1605- drizzle_con_st *client, drizzle_result_st *server_result,
1606- drizzle_result_st *client_result, drizzle_column_st *column)
1607+ drizzle_con_st *client,
1608+ drizzle_column_st *column)
1609 {
1610 drizzle_return_t ret;
1611 drizzle_command_t command;
1612@@ -244,31 +243,34 @@
1613
1614 /* Handshake packets. */
1615 ret= drizzle_handshake_server_read(client);
1616- DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_server_read", drizzle)
1617+ DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_server_read", drizzle);
1618
1619 drizzle_con_copy_handshake(server, client);
1620
1621 ret= drizzle_handshake_server_write(server);
1622- DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_server_write", drizzle)
1623+ DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_server_write", drizzle);
1624
1625 ret= drizzle_handshake_client_read(server);
1626- DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_read", drizzle)
1627+ DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_read", drizzle);
1628
1629 drizzle_con_copy_handshake(client, server);
1630
1631 ret= drizzle_handshake_client_write(client);
1632- DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_write", drizzle)
1633+ DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_write", drizzle);
1634
1635- (void)drizzle_result_read(client, client_result, &ret);
1636- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_read", drizzle)
1637+ drizzle_result_st *client_result= drizzle_result_read(client, NULL, &ret);
1638+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_read", drizzle);
1639
1640 drizzle_con_set_status(server, drizzle_con_status(client));
1641
1642- if (drizzle_result_clone(server, server_result, client_result) == NULL)
1643- DRIZZLE_RETURN_ERROR("drizzle_result_clone", drizzle)
1644+ drizzle_result_st *server_result;
1645+ if ((server_result= drizzle_result_clone(server, client_result)) == NULL)
1646+ {
1647+ DRIZZLE_RETURN_ERROR("drizzle_result_clone", drizzle);
1648+ }
1649
1650 ret= drizzle_result_write(server, server_result, true);
1651- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle)
1652+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle);
1653
1654 if (drizzle_result_error_code(client_result) != 0 ||
1655 drizzle_result_eof(client_result))
1656@@ -287,51 +289,59 @@
1657
1658 while (1)
1659 {
1660- data= (uint8_t *)drizzle_con_command_read(server, &command, &offset, &size, &total,
1661- &ret);
1662+ data= (uint8_t *)drizzle_con_command_read(server, &command, &offset, &size, &total, &ret);
1663 if (ret == DRIZZLE_RETURN_LOST_CONNECTION)
1664+ {
1665 return;
1666-
1667- DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_read", drizzle)
1668-
1669- (void)drizzle_con_command_write(client, NULL, command, data, size, total,
1670- &ret);
1671- DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_write", drizzle)
1672+ }
1673+
1674+ DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_read", drizzle);
1675+
1676+ (void)drizzle_con_command_write(client, NULL, command, data, size, total, &ret);
1677+ DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_write", drizzle);
1678
1679 if ((offset + size) == total)
1680 break;
1681 }
1682
1683 if (command == DRIZZLE_COMMAND_QUIT)
1684+ {
1685 return;
1686+ }
1687 else if (command == DRIZZLE_COMMAND_FIELD_LIST)
1688 {
1689- if (drizzle_result_create(client, client_result) == NULL)
1690+ if ((client_result= drizzle_result_create(client)) == NULL)
1691+ {
1692 DRIZZLE_RETURN_ERROR("drizzle_result_create", drizzle)
1693+ }
1694
1695- if (drizzle_result_create(server, server_result) == NULL)
1696- DRIZZLE_RETURN_ERROR("drizzle_result_create", drizzle)
1697+ if ((server_result= drizzle_result_create(server)) == NULL)
1698+ {
1699+ DRIZZLE_RETURN_ERROR("drizzle_result_create", drizzle);
1700+ }
1701 }
1702 else
1703 {
1704 (void)drizzle_result_read(client, client_result, &ret);
1705- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_read", drizzle)
1706+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_read", drizzle);
1707
1708 drizzle_con_set_status(server, drizzle_con_status(client));
1709- if (drizzle_result_clone(server, server_result, client_result) == NULL)
1710- DRIZZLE_RETURN_ERROR("drizzle_result_clone", drizzle)
1711+ if ((server_result= drizzle_result_clone(server, client_result)) == NULL)
1712+ {
1713+ DRIZZLE_RETURN_ERROR("drizzle_result_clone", drizzle);
1714+ }
1715
1716 if (drizzle_result_column_count(client_result) == 0)
1717 {
1718 /* Simple result with no column, row, or field data. */
1719 ret= drizzle_result_write(server, server_result, true);
1720- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle)
1721+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle);
1722
1723 continue;
1724 }
1725
1726 ret= drizzle_result_write(server, server_result, false);
1727- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle)
1728+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle);
1729 }
1730
1731 /* Columns. */
1732@@ -339,14 +349,14 @@
1733 {
1734 if (drizzle_column_read(client_result, column, &ret) == NULL)
1735 {
1736- DRIZZLE_RETURN_CHECK(ret, "drizzle_column_read", drizzle)
1737+ DRIZZLE_RETURN_CHECK(ret, "drizzle_column_read", drizzle);
1738 break;
1739 }
1740
1741- DRIZZLE_RETURN_CHECK(ret, "drizzle_column_read", drizzle)
1742+ DRIZZLE_RETURN_CHECK(ret, "drizzle_column_read", drizzle);
1743
1744 ret= drizzle_column_write(server_result, column);
1745- DRIZZLE_RETURN_CHECK(ret, "drizzle_column_write", drizzle)
1746+ DRIZZLE_RETURN_CHECK(ret, "drizzle_column_write", drizzle);
1747
1748 drizzle_column_free(column);
1749 }
1750@@ -357,20 +367,20 @@
1751 if (command == DRIZZLE_COMMAND_FIELD_LIST)
1752 {
1753 ret= drizzle_result_write(server, server_result, true);
1754- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle)
1755+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle);
1756 continue;
1757 }
1758 else
1759 {
1760 ret= drizzle_result_write(server, server_result, false);
1761- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle)
1762+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle);
1763 }
1764
1765 /* Rows. */
1766 while (1)
1767 {
1768 row= drizzle_row_read(client_result, &ret);
1769- DRIZZLE_RETURN_CHECK(ret, "drizzle_row_read", drizzle)
1770+ DRIZZLE_RETURN_CHECK(ret, "drizzle_row_read", drizzle);
1771
1772 if (row == 0)
1773 break;
1774@@ -379,7 +389,7 @@
1775 drizzle_result_row_size(client_result));
1776
1777 ret= drizzle_row_write(server_result);
1778- DRIZZLE_RETURN_CHECK(ret, "drizzle_row_write", drizzle)
1779+ DRIZZLE_RETURN_CHECK(ret, "drizzle_row_write", drizzle);
1780
1781 /* Fields. */
1782 row_break= false;
1783@@ -396,14 +406,16 @@
1784 row_break= true;
1785 }
1786 else
1787- DRIZZLE_RETURN_CHECK(ret, "drizzle_field_read", drizzle)
1788+ {
1789+ DRIZZLE_RETURN_CHECK(ret, "drizzle_field_read", drizzle);
1790+ }
1791
1792 ret= drizzle_field_write(server_result, field, size, total);
1793- DRIZZLE_RETURN_CHECK(ret, "drizzle_field_write", drizzle)
1794+ DRIZZLE_RETURN_CHECK(ret, "drizzle_field_write", drizzle);
1795 }
1796 }
1797
1798 ret= drizzle_result_write(server, server_result, true);
1799- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle)
1800+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle);
1801 }
1802 }
1803
1804=== modified file 'examples/server.cc'
1805--- examples/server.cc 2011-11-04 21:06:16 +0000
1806+++ examples/server.cc 2011-11-29 23:07:26 +0000
1807@@ -41,7 +41,7 @@
1808 #include <stdlib.h>
1809 #include <unistd.h>
1810
1811-#include <libdrizzle-1.0/drizzle_server.h>
1812+#include <libdrizzle-2.0/drizzle_server.h>
1813
1814 #define DRIZZLE_FIELD_MAX 32
1815 #define DRIZZLE_RESULT_ROWS 20
1816@@ -58,8 +58,7 @@
1817 return; \
1818 }
1819
1820-static void server(drizzle_st *drizzle, drizzle_con_st *con,
1821- drizzle_result_st *result, drizzle_column_st *column);
1822+static void server(drizzle_st *drizzle, drizzle_con_st *con, drizzle_column_st *column);
1823
1824 int main(int argc, char *argv[])
1825 {
1826@@ -70,10 +69,7 @@
1827 in_port_t port= 0;
1828 drizzle_verbose_t verbose= DRIZZLE_VERBOSE_NEVER;
1829 drizzle_return_t ret;
1830- drizzle_st drizzle;
1831- drizzle_con_st *con_listen= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
1832- drizzle_con_st *con= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
1833- drizzle_result_st result;
1834+ drizzle_st *drizzle;
1835 drizzle_column_st column;
1836
1837 while((c = getopt(argc, argv, "c:h:mp:v")) != -1)
1838@@ -132,18 +128,19 @@
1839 }
1840 }
1841
1842- if (drizzle_create(&drizzle) == NULL)
1843+ if ((drizzle= drizzle_create()) == NULL)
1844 {
1845- printf("drizzle_create:NULL\n");
1846+ fprintf(stderr, "drizzle_create:NULL\n");
1847 return 1;
1848 }
1849
1850- drizzle_add_options(&drizzle, DRIZZLE_FREE_OBJECTS);
1851- drizzle_set_verbose(&drizzle, verbose);
1852+ drizzle_set_option(drizzle, DRIZZLE_FREE_OBJECTS, true);
1853+ drizzle_set_verbose(drizzle, verbose);
1854
1855- if (drizzle_con_create(&drizzle, con_listen) == NULL)
1856+ drizzle_con_st* con_listen;
1857+ if ((con_listen= drizzle_con_create(drizzle)) == NULL)
1858 {
1859- printf("drizzle_con_create:NULL\n");
1860+ fprintf(stderr, "drizzle_con_create:NULL\n");
1861 return 1;
1862 }
1863
1864@@ -151,24 +148,26 @@
1865 drizzle_con_set_tcp(con_listen, host, port);
1866
1867 if (mysql)
1868+ {
1869 drizzle_con_add_options(con_listen, DRIZZLE_CON_MYSQL);
1870+ }
1871
1872 if (drizzle_con_listen(con_listen) != DRIZZLE_RETURN_OK)
1873 {
1874- printf("drizzle_con_listen:%s\n", drizzle_error(&drizzle));
1875+ fprintf(stderr, "drizzle_con_listen:%s\n", drizzle_error(drizzle));
1876 return 1;
1877 }
1878
1879 while (1)
1880 {
1881- (void)drizzle_con_accept(&drizzle, con, &ret);
1882+ drizzle_con_st *con= drizzle_con_accept(drizzle, &ret);
1883 if (ret != DRIZZLE_RETURN_OK)
1884 {
1885- printf("drizzle_con_accept:%s\n", drizzle_error(&drizzle));
1886+ fprintf(stderr, "drizzle_con_accept:%s\n", drizzle_error(drizzle));
1887 return 1;
1888 }
1889
1890- server(&drizzle, con, &result, &column);
1891+ server(drizzle, con, &column);
1892
1893 drizzle_con_free(con);
1894
1895@@ -182,16 +181,13 @@
1896 }
1897
1898 drizzle_con_free(con_listen);
1899- drizzle_free(&drizzle);
1900-
1901- free(con);
1902- free(con_listen);
1903+ drizzle_free(drizzle);
1904
1905 return 0;
1906 }
1907
1908 static void server(drizzle_st *drizzle, drizzle_con_st *con,
1909- drizzle_result_st *result, drizzle_column_st *column)
1910+ drizzle_column_st *column)
1911 {
1912 drizzle_return_t ret;
1913 drizzle_command_t command;
1914@@ -220,10 +216,13 @@
1915 DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_server_write", drizzle)
1916
1917 ret= drizzle_handshake_client_read(con);
1918- DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_read", drizzle)
1919+ DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_read", drizzle);
1920
1921- if (drizzle_result_create(con, result) == NULL)
1922+ drizzle_result_st *result;
1923+ if ((result= drizzle_result_create(con)) == NULL)
1924+ {
1925 DRIZZLE_RETURN_ERROR("drizzle_result_create", drizzle)
1926+ }
1927
1928 ret= drizzle_result_write(con, result, true);
1929 DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle)
1930@@ -243,8 +242,10 @@
1931 }
1932 DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_buffer", drizzle)
1933
1934- if (drizzle_result_create(con, result) == NULL)
1935+ if ((result= drizzle_result_create(con)) == NULL)
1936+ {
1937 DRIZZLE_RETURN_ERROR("drizzle_result_create", drizzle)
1938+ }
1939
1940 if (command != DRIZZLE_COMMAND_QUERY)
1941 {
1942@@ -260,7 +261,9 @@
1943
1944 /* Columns. */
1945 if (drizzle_column_create(result, column) == NULL)
1946+ {
1947 DRIZZLE_RETURN_ERROR("drizzle_column_create", drizzle)
1948+ }
1949
1950 drizzle_column_set_catalog(column, "default");
1951 drizzle_column_set_db(column, "drizzle_test_db");
1952
1953=== modified file 'examples/simple_multi.cc'
1954--- examples/simple_multi.cc 2011-11-04 21:06:16 +0000
1955+++ examples/simple_multi.cc 2011-11-29 23:07:26 +0000
1956@@ -34,9 +34,9 @@
1957 *
1958 */
1959
1960-#include <stdio.h>
1961-#include <string.h>
1962-#include <stdlib.h>
1963+#include <cstdio>
1964+#include <cstring>
1965+#include <cstdlib>
1966
1967 #include <libdrizzle-2.0/drizzle_client.h>
1968
1969@@ -45,86 +45,91 @@
1970 int main(int argc, char *argv[])
1971 {
1972 const char *query= "SELECT table_schema,table_name FROM tables";
1973- drizzle_st drizzle;
1974- drizzle_con_st *con;
1975- drizzle_result_st *result;
1976- drizzle_query_st *ql;
1977- drizzle_return_t ret;
1978- drizzle_row_t row;
1979- int x;
1980-
1981- con= (drizzle_con_st*)malloc(sizeof(drizzle_con_st) * SIMPLE_MULTI_COUNT);
1982- result= (drizzle_result_st*)malloc(sizeof(drizzle_result_st) * SIMPLE_MULTI_COUNT);
1983- ql= (drizzle_query_st*)malloc(sizeof(drizzle_query_st) * SIMPLE_MULTI_COUNT);
1984-
1985- if (drizzle_create(&drizzle) == NULL)
1986+ drizzle_st *drizzle;
1987+
1988+ std::vector<drizzle_con_st *> cons;
1989+ std::vector<drizzle_result_st *> result;
1990+ std::vector<drizzle_query_st *> ql;
1991+
1992+ if ((drizzle= drizzle_create()) == NULL)
1993 {
1994- printf("drizzle_create:NULL\n");
1995+ fprintf(stderr, "drizzle_create:NULL\n");
1996 return 1;
1997 }
1998
1999 /* Create SIMPLE_MULTI_COUNT connections and initialize query list. */
2000- for (x= 0; x < SIMPLE_MULTI_COUNT; x++)
2001+ for (int x= 0; x < SIMPLE_MULTI_COUNT; x++)
2002 {
2003+ drizzle_con_st *con;
2004 if (x == 0)
2005 {
2006- if (drizzle_con_create(&drizzle, &(con[0])) == NULL)
2007+ if ((con= drizzle_con_create(drizzle)) == NULL)
2008 {
2009- printf("drizzle_con_create:%s\n", drizzle_error(&drizzle));
2010+ printf("drizzle_con_create:%s\n", drizzle_error(drizzle));
2011 return 1;
2012 }
2013
2014 if (argc == 2 && !strcmp(argv[1], "-m"))
2015- drizzle_con_add_options(&(con[0]), DRIZZLE_CON_MYSQL);
2016+ {
2017+ drizzle_con_add_options(con, DRIZZLE_CON_MYSQL);
2018+ }
2019 else if (argc != 1)
2020 {
2021 printf("usage: %s [-m]\n", argv[0]);
2022 return 1;
2023 }
2024
2025- drizzle_con_set_db(&(con[0]), "information_schema");
2026+ drizzle_con_set_db(con, "information_schema");
2027+ cons.push_back(con);
2028 }
2029 else
2030 {
2031- if (drizzle_con_clone(&drizzle, &(con[x]), &(con[0])) == NULL)
2032+ if ((con= drizzle_con_clone(drizzle, cons[0])) == NULL)
2033 {
2034- printf("drizzle_con_clone:%s\n", drizzle_error(&drizzle));
2035+ fprintf(stderr, "drizzle_con_clone:%s\n", drizzle_error(drizzle));
2036 return 1;
2037 }
2038 }
2039
2040- if (drizzle_query_add(&drizzle, &(ql[x]), &(con[x]), &(result[x]), query,
2041- strlen(query), DRIZZLE_QUERY_NONE, NULL) == NULL)
2042+ cons.push_back(con);
2043+ drizzle_result_st *res= drizzle_result_create(con);
2044+ result.push_back(res);
2045+
2046+ drizzle_query_st *exec_query;
2047+ if ((exec_query= drizzle_query_add(drizzle, NULL, con, res, query, strlen(query), DRIZZLE_QUERY_NONE, NULL)) == NULL)
2048 {
2049- printf("drizzle_query_add:%s\n", drizzle_error(&drizzle));
2050+ fprintf(stderr, "drizzle_query_add:%s\n", drizzle_error(drizzle));
2051 return 1;
2052 }
2053+ ql.push_back(exec_query);
2054 }
2055
2056- ret= drizzle_query_run_all(&drizzle);
2057+ drizzle_return_t ret= drizzle_query_run_all(drizzle);
2058 if (ret != DRIZZLE_RETURN_OK)
2059 {
2060- printf("drizzle_query_run_all:%s\n", drizzle_error(&drizzle));
2061+ printf("drizzle_query_run_all:%s\n", drizzle_error(drizzle));
2062 return 1;
2063 }
2064
2065- for (x= 0; x < SIMPLE_MULTI_COUNT; x++)
2066+ uint32_t x= 0;
2067+ for (std::vector<drizzle_result_st *>::iterator iter= result.begin(); iter != result.end(); iter++)
2068 {
2069- if (drizzle_result_error_code(&(result[x])) != 0)
2070+ if (drizzle_result_error_code(*iter) != 0)
2071 {
2072- printf("%d:%s\n", drizzle_result_error_code(&(result[x])),
2073- drizzle_result_error(&(result[x])));
2074+ printf("%d:%s\n", drizzle_result_error_code(*iter),
2075+ drizzle_result_error(*iter));
2076 continue;
2077 }
2078
2079- while ((row= drizzle_row_next(&(result[x]))) != NULL)
2080- printf("%d %s:%s\n", x, row[0], row[1]);
2081+ drizzle_row_t row;
2082+ while ((row= drizzle_row_next(*iter)) != NULL)
2083+ {
2084+ printf("%x %s:%s\n", x, row[0], row[1]);
2085+ }
2086+ x++;
2087 }
2088
2089- drizzle_free(&drizzle);
2090+ drizzle_free(drizzle);
2091
2092- free(con);
2093- free(result);
2094- free(ql);
2095 return 0;
2096 }
2097
2098=== modified file 'examples/sqlite_server.cc'
2099--- examples/sqlite_server.cc 2011-11-04 21:06:16 +0000
2100+++ examples/sqlite_server.cc 2011-11-29 23:07:26 +0000
2101@@ -56,7 +56,7 @@
2102
2103 #define DRIZZLE_RETURN_ERROR(__function, __drizzle) \
2104 { \
2105- printf(__function ":%s\n", drizzle_error(__drizzle)); \
2106+ fprintf(stderr, __function ":%s\n", drizzle_error(__drizzle)); \
2107 return; \
2108 }
2109
2110@@ -64,16 +64,16 @@
2111 { \
2112 if ((__ret) != DRIZZLE_RETURN_OK) \
2113 { \
2114- printf(__function ":%s\n", drizzle_error(__drizzle)); \
2115+ fprintf(stderr, __function ":%s\n", drizzle_error(__drizzle)); \
2116 return ret; \
2117 } \
2118 }
2119
2120 typedef struct
2121 {
2122- drizzle_st drizzle;
2123- drizzle_con_st con;
2124- drizzle_result_st result;
2125+ drizzle_st *drizzle;
2126+ drizzle_con_st *con;
2127+ drizzle_result_st *result;
2128 drizzle_column_st column;
2129 sqlite3* db;
2130 bool send_columns;
2131@@ -95,7 +95,6 @@
2132 in_port_t port= 0;
2133 drizzle_return_t ret;
2134 sqlite_server *server= (sqlite_server*)malloc(sizeof(sqlite_server));
2135- drizzle_con_st *con_listen= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
2136
2137 server->db= NULL;
2138 server->verbose= DRIZZLE_VERBOSE_NEVER;
2139@@ -159,22 +158,23 @@
2140 sqlite3_open(argv[optind], &(server->db));
2141 if (server->db == NULL)
2142 {
2143- printf("sqlite3_open: could not open sqlite3 db\n");
2144- return 1;
2145- }
2146-
2147- if (drizzle_create(&(server->drizzle)) == NULL)
2148- {
2149- printf("drizzle_create:NULL\n");
2150- return 1;
2151- }
2152-
2153- drizzle_add_options(&(server->drizzle), DRIZZLE_FREE_OBJECTS);
2154- drizzle_set_verbose(&(server->drizzle), server->verbose);
2155-
2156- if (drizzle_con_create(&(server->drizzle), con_listen) == NULL)
2157- {
2158- printf("drizzle_con_create:NULL\n");
2159+ fprintf(stderr, "sqlite3_open: could not open sqlite3 db\n");
2160+ return 1;
2161+ }
2162+
2163+ if ((server->drizzle= drizzle_create()) == NULL)
2164+ {
2165+ fprintf(stderr, "drizzle_create:NULL\n");
2166+ return 1;
2167+ }
2168+
2169+ drizzle_set_option(server->drizzle, DRIZZLE_FREE_OBJECTS, true);
2170+ drizzle_set_verbose(server->drizzle, server->verbose);
2171+
2172+ drizzle_con_st *con_listen;
2173+ if ((con_listen= drizzle_con_create(server->drizzle)) == NULL)
2174+ {
2175+ fprintf(stderr, "drizzle_con_create:NULL\n");
2176 return 1;
2177 }
2178
2179@@ -182,26 +182,28 @@
2180 drizzle_con_set_tcp(con_listen, host, port);
2181
2182 if (mysql)
2183+ {
2184 drizzle_con_add_options(con_listen, DRIZZLE_CON_MYSQL);
2185+ }
2186
2187 if (drizzle_con_listen(con_listen) != DRIZZLE_RETURN_OK)
2188 {
2189- printf("drizzle_con_listen:%s\n", drizzle_error(&(server->drizzle)));
2190+ fprintf(stderr, "drizzle_con_listen:%s\n", drizzle_error(server->drizzle));
2191 return 1;
2192 }
2193
2194 while (1)
2195 {
2196- (void)drizzle_con_accept(&(server->drizzle), &(server->con), &ret);
2197+ server->con= drizzle_con_accept(server->drizzle, &ret);
2198 if (ret != DRIZZLE_RETURN_OK)
2199 {
2200- printf("drizzle_con_accept:%s\n", drizzle_error(&(server->drizzle)));
2201+ fprintf(stderr, "drizzle_con_accept:%s\n", drizzle_error(server->drizzle));
2202 return 1;
2203 }
2204
2205 server_run(server);
2206
2207- drizzle_con_free(&(server->con));
2208+ drizzle_con_free(server->con);
2209
2210 if (count > 0)
2211 {
2212@@ -213,9 +215,8 @@
2213 }
2214
2215 drizzle_con_free(con_listen);
2216- drizzle_free(&(server->drizzle));
2217+ drizzle_free(server->drizzle);
2218 sqlite3_close(server->db);
2219- free(con_listen);
2220 free(server);
2221
2222 return 0;
2223@@ -231,64 +232,66 @@
2224 char *sqlite_err;
2225
2226 /* Handshake packets. */
2227- drizzle_con_set_protocol_version(&(server->con), 10);
2228- drizzle_con_set_server_version(&(server->con), "libdrizzle+SQLite");
2229- drizzle_con_set_thread_id(&(server->con), 1);
2230- drizzle_con_set_scramble(&(server->con),
2231- (const uint8_t *)"ABCDEFGHIJKLMNOPQRST");
2232- drizzle_con_set_capabilities(&(server->con), DRIZZLE_CAPABILITIES_NONE);
2233- drizzle_con_set_charset(&(server->con), 8);
2234- drizzle_con_set_status(&(server->con), DRIZZLE_CON_STATUS_NONE);
2235- drizzle_con_set_max_packet_size(&(server->con), DRIZZLE_MAX_PACKET_SIZE);
2236-
2237- ret= drizzle_handshake_server_write(&(server->con));
2238- DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_server_write",
2239- &(server->drizzle))
2240-
2241- ret= drizzle_handshake_client_read(&(server->con));
2242- DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_read", &(server->drizzle))
2243-
2244- if (drizzle_result_create(&(server->con), &(server->result)) == NULL)
2245- DRIZZLE_RETURN_ERROR("drizzle_result_create", &(server->drizzle))
2246-
2247- ret= drizzle_result_write(&(server->con), &(server->result), true);
2248- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
2249+ drizzle_con_set_protocol_version(server->con, 10);
2250+ drizzle_con_set_server_version(server->con, "libdrizzle+SQLite");
2251+ drizzle_con_set_thread_id(server->con, 1);
2252+ drizzle_con_set_scramble(server->con, (const uint8_t *)"ABCDEFGHIJKLMNOPQRST");
2253+ drizzle_con_set_capabilities(server->con, DRIZZLE_CAPABILITIES_NONE);
2254+ drizzle_con_set_charset(server->con, 8);
2255+ drizzle_con_set_status(server->con, DRIZZLE_CON_STATUS_NONE);
2256+ drizzle_con_set_max_packet_size(server->con, DRIZZLE_MAX_PACKET_SIZE);
2257+
2258+ ret= drizzle_handshake_server_write(server->con);
2259+ DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_server_write", server->drizzle)
2260+
2261+ ret= drizzle_handshake_client_read(server->con);
2262+ DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_read", server->drizzle)
2263+
2264+ if ((server->result= drizzle_result_create(server->con)) == NULL)
2265+ {
2266+ DRIZZLE_RETURN_ERROR("drizzle_result_create", server->drizzle);
2267+ }
2268+
2269+ ret= drizzle_result_write(server->con, server->result, true);
2270+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle)
2271
2272 /* Command loop. */
2273 while (1)
2274 {
2275- drizzle_result_free(&(server->result));
2276+ drizzle_result_free(server->result);
2277 free(data);
2278
2279- data= (uint8_t *)drizzle_con_command_buffer(&(server->con), &command, &total, &ret);
2280+ data= (uint8_t *)drizzle_con_command_buffer(server->con, &command, &total, &ret);
2281 if (ret == DRIZZLE_RETURN_LOST_CONNECTION ||
2282 (ret == DRIZZLE_RETURN_OK && command == DRIZZLE_COMMAND_QUIT))
2283 {
2284 free(data);
2285 return;
2286 }
2287- DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_buffer", &(server->drizzle))
2288+ DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_buffer", server->drizzle);
2289
2290 if (server->verbose >= DRIZZLE_VERBOSE_INFO)
2291 {
2292- printf("Command=%u Data=%s\n", command,
2293+ fprintf(stderr, "Command=%u Data=%s\n", command,
2294 data == NULL ? "NULL" : (char *)data);
2295 }
2296
2297- if (drizzle_result_create(&(server->con), &(server->result)) == NULL)
2298- DRIZZLE_RETURN_ERROR("drizzle_result_create", &(server->drizzle))
2299+ if ((server->result= drizzle_result_create(server->con)) == NULL)
2300+ {
2301+ DRIZZLE_RETURN_ERROR("drizzle_result_create", server->drizzle);
2302+ }
2303
2304 if (command != DRIZZLE_COMMAND_QUERY ||
2305 !strcasecmp((char *)data, "SHOW DATABASES"))
2306 {
2307- ret= drizzle_result_write(&(server->con), &(server->result), true);
2308- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
2309+ ret= drizzle_result_write(server->con, server->result, true);
2310+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle);
2311
2312 if (command == DRIZZLE_COMMAND_FIELD_LIST)
2313 {
2314- drizzle_result_set_eof(&(server->result), true);
2315- ret= drizzle_result_write(&(server->con), &(server->result), true);
2316- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
2317+ drizzle_result_set_eof(server->result, true);
2318+ ret= drizzle_result_write(server->con, server->result, true);
2319+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle);
2320 }
2321
2322 continue;
2323@@ -321,15 +324,17 @@
2324 if (sqlite_ret != SQLITE_OK)
2325 {
2326 if (sqlite_err == NULL)
2327- printf("sqlite3_exec failed\n");
2328+ {
2329+ fprintf(stderr, "sqlite3_exec failed\n");
2330+ }
2331 else
2332 {
2333- drizzle_result_set_error_code(&(server->result), (uint16_t)sqlite_ret);
2334- drizzle_result_set_error(&(server->result), sqlite_err);
2335- ret= drizzle_result_write(&(server->con), &(server->result), true);
2336- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
2337+ drizzle_result_set_error_code(server->result, (uint16_t)sqlite_ret);
2338+ drizzle_result_set_error(server->result, sqlite_err);
2339+ ret= drizzle_result_write(server->con, server->result, true);
2340+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle)
2341
2342- printf("sqlite3_exec:%s\n", sqlite_err);
2343+ fprintf(stderr, "sqlite3_exec:%s\n", sqlite_err);
2344 sqlite3_free(sqlite_err);
2345 }
2346
2347@@ -338,15 +343,15 @@
2348
2349 if (server->rows == 0)
2350 {
2351- drizzle_result_set_column_count(&(server->result), 0);
2352- ret= drizzle_result_write(&(server->con), &(server->result), true);
2353- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
2354+ drizzle_result_set_column_count(server->result, 0);
2355+ ret= drizzle_result_write(server->con, server->result, true);
2356+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle)
2357 }
2358 else
2359 {
2360- drizzle_result_set_eof(&(server->result), true);
2361- ret= drizzle_result_write(&(server->con), &(server->result), true);
2362- DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", &(server->drizzle))
2363+ drizzle_result_set_eof(server->result, true);
2364+ ret= drizzle_result_write(server->con, server->result, true);
2365+ DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle)
2366 }
2367 }
2368 }
2369@@ -361,15 +366,14 @@
2370 if (server->send_columns == true)
2371 {
2372 server->send_columns= false;
2373- drizzle_result_set_column_count(&(server->result), (uint16_t)field_count);
2374-
2375- ret= drizzle_result_write(&(server->con), &(server->result), false);
2376- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
2377-
2378- if (drizzle_column_create(&(server->result), &(server->column)) == NULL)
2379+ drizzle_result_set_column_count(server->result, (uint16_t)field_count);
2380+
2381+ ret= drizzle_result_write(server->con, server->result, false);
2382+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", server->drizzle)
2383+
2384+ if (drizzle_column_create(server->result, &(server->column)) == NULL)
2385 {
2386- DRIZZLE_RETURN_CHECK_VAL(DRIZZLE_RETURN_MEMORY, "drizzle_column_create",
2387- &(server->drizzle))
2388+ DRIZZLE_RETURN_CHECK_VAL(DRIZZLE_RETURN_MEMORY, "drizzle_column_create", server->drizzle)
2389 }
2390
2391 drizzle_column_set_catalog(&(server->column), "sqlite");
2392@@ -387,16 +391,16 @@
2393 drizzle_column_set_name(&(server->column), columns[x]);
2394 drizzle_column_set_orig_name(&(server->column), columns[x]);
2395
2396- ret= drizzle_column_write(&(server->result), &(server->column));
2397- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_column_write", &(server->drizzle))
2398+ ret= drizzle_column_write(server->result, &(server->column));
2399+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_column_write", server->drizzle)
2400 }
2401
2402 drizzle_column_free(&(server->column));
2403
2404- drizzle_result_set_eof(&(server->result), true);
2405+ drizzle_result_set_eof(server->result, true);
2406
2407- ret= drizzle_result_write(&(server->con), &(server->result), false);
2408- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
2409+ ret= drizzle_result_write(server->con, server->result, false);
2410+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", server->drizzle)
2411 }
2412
2413 for (x= 0; x < field_count; x++)
2414@@ -408,17 +412,17 @@
2415 }
2416
2417 /* This is needed for MySQL and old Drizzle protocol. */
2418- drizzle_result_calc_row_size(&(server->result), (drizzle_field_t *)fields,
2419+ drizzle_result_calc_row_size(server->result, (drizzle_field_t *)fields,
2420 sizes);
2421
2422- ret= drizzle_row_write(&(server->result));
2423- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_row_write", &(server->drizzle))
2424+ ret= drizzle_row_write(server->result);
2425+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_row_write", server->drizzle)
2426
2427 for (x= 0; x < field_count; x++)
2428 {
2429- ret= drizzle_field_write(&(server->result), (drizzle_field_t)fields[x],
2430+ ret= drizzle_field_write(server->result, (drizzle_field_t)fields[x],
2431 sizes[x], sizes[x]);
2432- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_field_write", &(server->drizzle))
2433+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_field_write", server->drizzle)
2434 }
2435
2436 server->rows++;
2437@@ -437,15 +441,14 @@
2438 fields[0]= (drizzle_field_t)SQLITE_SERVER_VERSION;
2439 sizes[0]= strlen(SQLITE_SERVER_VERSION);
2440
2441- drizzle_result_set_column_count(&(server->result), 1);
2442-
2443- ret= drizzle_result_write(&(server->con), &(server->result), false);
2444- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
2445-
2446- if (drizzle_column_create(&(server->result), &(server->column)) == NULL)
2447+ drizzle_result_set_column_count(server->result, 1);
2448+
2449+ ret= drizzle_result_write(server->con, server->result, false);
2450+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", server->drizzle)
2451+
2452+ if (drizzle_column_create(server->result, &(server->column)) == NULL)
2453 {
2454- DRIZZLE_RETURN_CHECK_VAL(DRIZZLE_RETURN_MEMORY, "drizzle_column_create",
2455- &(server->drizzle))
2456+ DRIZZLE_RETURN_CHECK_VAL(DRIZZLE_RETURN_MEMORY, "drizzle_column_create", server->drizzle)
2457 }
2458
2459 drizzle_column_set_catalog(&(server->column), "sqlite");
2460@@ -458,38 +461,37 @@
2461 drizzle_column_set_name(&(server->column), "version");
2462 drizzle_column_set_orig_name(&(server->column), "version");
2463
2464- ret= drizzle_column_write(&(server->result), &(server->column));
2465- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_column_write", &(server->drizzle))
2466+ ret= drizzle_column_write(server->result, &(server->column));
2467+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_column_write", server->drizzle)
2468
2469 drizzle_column_free(&(server->column));
2470
2471- drizzle_result_set_eof(&(server->result), true);
2472+ drizzle_result_set_eof(server->result, true);
2473
2474- ret= drizzle_result_write(&(server->con), &(server->result), false);
2475- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
2476+ ret= drizzle_result_write(server->con, server->result, false);
2477+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", server->drizzle)
2478
2479 /* This is needed for MySQL and old Drizzle protocol. */
2480- drizzle_result_calc_row_size(&(server->result), fields, sizes);
2481-
2482- ret= drizzle_row_write(&(server->result));
2483- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_row_write", &(server->drizzle))
2484-
2485- ret= drizzle_field_write(&(server->result), fields[0], sizes[0], sizes[0]);
2486- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_field_write", &(server->drizzle))
2487-
2488- ret= drizzle_result_write(&(server->con), &(server->result), true);
2489- DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", &(server->drizzle))
2490+ drizzle_result_calc_row_size(server->result, fields, sizes);
2491+
2492+ ret= drizzle_row_write(server->result);
2493+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_row_write", server->drizzle)
2494+
2495+ ret= drizzle_field_write(server->result, fields[0], sizes[0], sizes[0]);
2496+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_field_write", server->drizzle)
2497+
2498+ ret= drizzle_result_write(server->con, server->result, true);
2499+ DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", server->drizzle)
2500
2501 return DRIZZLE_RETURN_OK;
2502 }
2503
2504 static void usage(char *name)
2505 {
2506- printf("\nusage: %s [-c <count>] [-h <host>] [-m] [-p <port>] [-v] "
2507- "<sqlite3 db file>\n", name);
2508- printf("\t-c <count> - Number of connections to accept before exiting\n");
2509- printf("\t-h <host> - Host to listen on\n");
2510- printf("\t-m - Use the MySQL protocol\n");
2511- printf("\t-p <port> - Port to listen on\n");
2512- printf("\t-v - Increase verbosity level\n");
2513+ fprintf(stderr, "\nusage: %s [-c <count>] [-h <host>] [-m] [-p <port>] [-v] " "<sqlite3 db file>\n", name);
2514+ fprintf(stderr, "\t-c <count> - Number of connections to accept before exiting\n");
2515+ fprintf(stderr, "\t-h <host> - Host to listen on\n");
2516+ fprintf(stderr, "\t-m - Use the MySQL protocol\n");
2517+ fprintf(stderr, "\t-p <port> - Port to listen on\n");
2518+ fprintf(stderr, "\t-v - Increase verbosity level\n");
2519 }
2520
2521=== modified file 'libdrizzle-2.0/column.cc'
2522--- libdrizzle-2.0/column.cc 2011-11-18 16:11:02 +0000
2523+++ libdrizzle-2.0/column.cc 2011-11-29 23:07:26 +0000
2524@@ -371,7 +371,7 @@
2525 column->result= result;
2526 /* SET BELOW: column->next */
2527 column->prev= NULL;
2528- column->options= DRIZZLE_COLUMN_ALLOCATED;
2529+ column->options.is_allocated= true;
2530 column->catalog[0]= '\0';
2531 column->schema[0]= '\0';
2532 column->table[0]= '\0';
2533@@ -392,7 +392,7 @@
2534 column->result = result;
2535 /* SET BELOW: column->next */
2536 column->prev = NULL;
2537- column->options= drizzle_column_options_t();
2538+ column->options.is_allocated= false;
2539 column->catalog[0] = '\0';
2540 column->schema[0] = '\0';
2541 column->table[0] = '\0';
2542@@ -441,7 +441,7 @@
2543 column->next->prev= column->prev;
2544 }
2545
2546- if (column->options & DRIZZLE_COLUMN_ALLOCATED)
2547+ if (column->options.is_allocated)
2548 {
2549 delete column;
2550 }
2551@@ -1170,9 +1170,13 @@
2552 ptr+= 4;
2553
2554 if (con->options & DRIZZLE_CON_MYSQL)
2555+ {
2556 ptr[0]= column->type;
2557+ }
2558 else
2559+ {
2560 ptr[0]= _column_type_drizzle_map_from[column->type];
2561+ }
2562 ptr++;
2563
2564 drizzle_set_byte2(ptr, column->flags);
2565
2566=== added file 'libdrizzle-2.0/command.h'
2567--- libdrizzle-2.0/command.h 1970-01-01 00:00:00 +0000
2568+++ libdrizzle-2.0/command.h 2011-11-29 23:07:26 +0000
2569@@ -0,0 +1,102 @@
2570+/*
2571+ * Drizzle Client & Protocol Library
2572+ *
2573+ * Copyright (C) 2011 Brian Aker (brian@tangent.org)
2574+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
2575+ * All rights reserved.
2576+ *
2577+ * Redistribution and use in source and binary forms, with or without
2578+ * modification, are permitted provided that the following conditions are
2579+ * met:
2580+ *
2581+ * * Redistributions of source code must retain the above copyright
2582+ * notice, this list of conditions and the following disclaimer.
2583+ *
2584+ * * Redistributions in binary form must reproduce the above
2585+ * copyright notice, this list of conditions and the following disclaimer
2586+ * in the documentation and/or other materials provided with the
2587+ * distribution.
2588+ *
2589+ * * The names of its contributors may not be used to endorse or
2590+ * promote products derived from this software without specific prior
2591+ * written permission.
2592+ *
2593+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
2594+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
2595+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
2596+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
2597+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2598+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
2599+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2600+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
2601+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
2602+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
2603+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2604+ *
2605+ */
2606+
2607+
2608+/**
2609+ * @ingroup drizzle_command
2610+ * Commands for drizzle_command functions.
2611+ */
2612+enum drizzle_command_t
2613+{
2614+ DRIZZLE_COMMAND_SLEEP, /* Not used currently. */
2615+ DRIZZLE_COMMAND_QUIT,
2616+ DRIZZLE_COMMAND_INIT_DB,
2617+ DRIZZLE_COMMAND_QUERY,
2618+ DRIZZLE_COMMAND_FIELD_LIST, /* Deprecated. */
2619+ DRIZZLE_COMMAND_CREATE_DB, /* Deprecated. */
2620+ DRIZZLE_COMMAND_DROP_DB, /* Deprecated. */
2621+ DRIZZLE_COMMAND_REFRESH,
2622+ DRIZZLE_COMMAND_SHUTDOWN,
2623+ DRIZZLE_COMMAND_STATISTICS,
2624+ DRIZZLE_COMMAND_PROCESS_INFO, /* Deprecated. */
2625+ DRIZZLE_COMMAND_CONNECT, /* Not used currently. */
2626+ DRIZZLE_COMMAND_PROCESS_KILL, /* Deprecated. */
2627+ DRIZZLE_COMMAND_DEBUG,
2628+ DRIZZLE_COMMAND_PING,
2629+ DRIZZLE_COMMAND_TIME, /* Not used currently. */
2630+ DRIZZLE_COMMAND_DELAYED_INSERT, /* Not used currently. */
2631+ DRIZZLE_COMMAND_CHANGE_USER,
2632+ DRIZZLE_COMMAND_BINLOG_DUMP, /* Not used currently. */
2633+ DRIZZLE_COMMAND_TABLE_DUMP, /* Not used currently. */
2634+ DRIZZLE_COMMAND_CONNECT_OUT, /* Not used currently. */
2635+ DRIZZLE_COMMAND_REGISTER_SLAVE, /* Not used currently. */
2636+ DRIZZLE_COMMAND_STMT_PREPARE, /* Not used currently. */
2637+ DRIZZLE_COMMAND_STMT_EXECUTE, /* Not used currently. */
2638+ DRIZZLE_COMMAND_STMT_SEND_LONG_DATA, /* Not used currently. */
2639+ DRIZZLE_COMMAND_STMT_CLOSE, /* Not used currently. */
2640+ DRIZZLE_COMMAND_STMT_RESET, /* Not used currently. */
2641+ DRIZZLE_COMMAND_SET_OPTION, /* Not used currently. */
2642+ DRIZZLE_COMMAND_STMT_FETCH, /* Not used currently. */
2643+ DRIZZLE_COMMAND_DAEMON, /* Not used currently. */
2644+ DRIZZLE_COMMAND_END /* Not used currently. */
2645+};
2646+
2647+#ifndef __cplusplus
2648+typedef enum drizzle_command_t drizzle_command_t;
2649+#endif
2650+
2651+/**
2652+ * @ingroup drizzle_command
2653+ * Commands for the Drizzle protocol functions.
2654+ */
2655+enum drizzle_command_drizzle_t
2656+{
2657+ DRIZZLE_COMMAND_DRIZZLE_SLEEP,
2658+ DRIZZLE_COMMAND_DRIZZLE_QUIT,
2659+ DRIZZLE_COMMAND_DRIZZLE_INIT_DB,
2660+ DRIZZLE_COMMAND_DRIZZLE_QUERY,
2661+ DRIZZLE_COMMAND_DRIZZLE_SHUTDOWN,
2662+ DRIZZLE_COMMAND_DRIZZLE_CONNECT,
2663+ DRIZZLE_COMMAND_DRIZZLE_PING,
2664+ DRIZZLE_COMMAND_DRIZZLE_KILL,
2665+ DRIZZLE_COMMAND_DRIZZLE_END
2666+};
2667+
2668+#ifndef __cplusplus
2669+typedef enum drizzle_command_drizzle_t drizzle_command_drizzle_t;
2670+#endif
2671+
2672
2673=== modified file 'libdrizzle-2.0/conn.cc'
2674--- libdrizzle-2.0/conn.cc 2011-11-18 16:11:02 +0000
2675+++ libdrizzle-2.0/conn.cc 2011-11-29 23:07:26 +0000
2676@@ -176,34 +176,40 @@
2677 return con->options;
2678 }
2679
2680-void drizzle_con_set_options(drizzle_con_st *con,
2681- int options)
2682+void drizzle_con_set_options(drizzle_con_st *con, int options)
2683 {
2684 con->options= options;
2685 }
2686
2687-void drizzle_con_add_options(drizzle_con_st *con,
2688- int options)
2689+void drizzle_con_add_options(drizzle_con_st *con, int options)
2690 {
2691 con->options|= options;
2692
2693 /* If asking for the experimental Drizzle protocol, clean the MySQL flag. */
2694 if (con->options & DRIZZLE_CON_EXPERIMENTAL)
2695+ {
2696 con->options&= ~DRIZZLE_CON_MYSQL;
2697+ }
2698 }
2699
2700-void drizzle_con_remove_options(drizzle_con_st *con,
2701- int options)
2702+void drizzle_con_remove_options(drizzle_con_st *con, int options)
2703 {
2704 con->options&= ~options;
2705 }
2706
2707 const char *drizzle_con_host(const drizzle_con_st *con)
2708 {
2709+ if (con == NULL)
2710+ {
2711+ return NULL;
2712+ }
2713+
2714 if (con->socket_type == DRIZZLE_CON_SOCKET_TCP)
2715 {
2716 if (con->socket.tcp.host == NULL && !(con->options & DRIZZLE_CON_LISTEN))
2717+ {
2718 return DRIZZLE_DEFAULT_TCP_HOST;
2719+ }
2720
2721 return con->socket.tcp.host;
2722 }
2723@@ -234,7 +240,9 @@
2724 con->socket_type= DRIZZLE_CON_SOCKET_TCP;
2725
2726 if (host == NULL)
2727+ {
2728 con->socket.tcp.host= NULL;
2729+ }
2730 else
2731 {
2732 con->socket.tcp.host= con->socket.tcp.host_buffer;
2733@@ -247,19 +255,35 @@
2734
2735 const char *drizzle_con_user(const drizzle_con_st *con)
2736 {
2737+ if (con == NULL)
2738+ {
2739+ return NULL;
2740+ }
2741+
2742 return con->user;
2743 }
2744
2745 const char *drizzle_con_password(const drizzle_con_st *con)
2746 {
2747+ if (con == NULL)
2748+ {
2749+ return NULL;
2750+ }
2751+
2752 return con->password;
2753 }
2754
2755-void drizzle_con_set_auth(drizzle_con_st *con, const char *user,
2756- const char *password)
2757+void drizzle_con_set_auth(drizzle_con_st *con, const char *user, const char *password)
2758 {
2759+ if (con == NULL)
2760+ {
2761+ return;
2762+ }
2763+
2764 if (user == NULL)
2765+ {
2766 con->user[0]= 0;
2767+ }
2768 else
2769 {
2770 strncpy(con->user, user, DRIZZLE_MAX_USER_SIZE);
2771@@ -368,7 +392,7 @@
2772
2773 uint32_t drizzle_con_server_version_number(const drizzle_con_st *con)
2774 {
2775- if (con == NULL)
2776+ if (con == NULL or con->server_version)
2777 {
2778 return 0;
2779 }
2780@@ -614,7 +638,7 @@
2781 }
2782 }
2783
2784- con->result= drizzle_result_create(con, result);
2785+ con->result= drizzle_result_create_with(con, result);
2786 if (con->result == NULL)
2787 {
2788 *ret_ptr= DRIZZLE_RETURN_MEMORY;
2789@@ -1044,6 +1068,10 @@
2790
2791 drizzle_return_t drizzle_state_connect(drizzle_con_st *con)
2792 {
2793+ if (con == NULL)
2794+ {
2795+ return DRIZZLE_RETURN_INVALID_ARGUMENT;
2796+ }
2797 drizzle_log_debug(con->drizzle, "drizzle_state_connect");
2798
2799 if (con->fd != -1)
2800@@ -1152,6 +1180,10 @@
2801
2802 drizzle_return_t drizzle_state_connecting(drizzle_con_st *con)
2803 {
2804+ if (con == NULL)
2805+ {
2806+ return DRIZZLE_RETURN_INVALID_ARGUMENT;
2807+ }
2808 drizzle_log_debug(con->drizzle, "drizzle_state_connecting");
2809
2810 while (1)
2811@@ -1189,7 +1221,10 @@
2812
2813 drizzle_return_t drizzle_state_read(drizzle_con_st *con)
2814 {
2815- drizzle_return_t ret;
2816+ if (con == NULL)
2817+ {
2818+ return DRIZZLE_RETURN_INVALID_ARGUMENT;
2819+ }
2820
2821 drizzle_log_debug(con->drizzle, "drizzle_state_read");
2822
2823@@ -1207,9 +1242,11 @@
2824 /* non-blocking mode: return IO_WAIT instead of attempting to read. This
2825 * avoids reading immediately after writing a command, which typically
2826 * returns EAGAIN. This improves performance. */
2827- ret= drizzle_con_set_events(con, POLLIN);
2828+ drizzle_return_t ret= drizzle_con_set_events(con, POLLIN);
2829 if (ret != DRIZZLE_RETURN_OK)
2830+ {
2831 return ret;
2832+ }
2833 return DRIZZLE_RETURN_IO_WAIT;
2834 }
2835
2836@@ -1271,9 +1308,11 @@
2837 {
2838 /* clear the read ready flag */
2839 con->revents&= ~POLLIN;
2840- ret= drizzle_con_set_events(con, POLLIN);
2841+ drizzle_return_t ret= drizzle_con_set_events(con, POLLIN);
2842 if (ret != DRIZZLE_RETURN_OK)
2843+ {
2844 return ret;
2845+ }
2846
2847 if (con->drizzle->options.is_non_blocking)
2848 {
2849@@ -1322,7 +1361,10 @@
2850
2851 drizzle_return_t drizzle_state_write(drizzle_con_st *con)
2852 {
2853- drizzle_return_t ret;
2854+ if (con == NULL)
2855+ {
2856+ return DRIZZLE_RETURN_INVALID_ARGUMENT;
2857+ }
2858
2859 drizzle_log_debug(con->drizzle, "drizzle_state_write");
2860
2861@@ -1380,7 +1422,7 @@
2862 {
2863 if (errno == EAGAIN)
2864 {
2865- ret= drizzle_con_set_events(con, POLLOUT);
2866+ drizzle_return_t ret= drizzle_con_set_events(con, POLLOUT);
2867 if (ret != DRIZZLE_RETURN_OK)
2868 {
2869 return ret;
2870@@ -1436,6 +1478,12 @@
2871 int opt;
2872 drizzle_con_st *new_con;
2873
2874+ if (con == NULL)
2875+ {
2876+ return DRIZZLE_RETURN_INVALID_ARGUMENT;
2877+ }
2878+
2879+
2880 for (; con->addrinfo_next != NULL;
2881 con->addrinfo_next= con->addrinfo_next->ai_next)
2882 {
2883@@ -1508,7 +1556,7 @@
2884 }
2885 else
2886 {
2887- new_con= drizzle_con_clone(con->drizzle, NULL, con);
2888+ new_con= drizzle_con_clone(con->drizzle, con);
2889 if (new_con == NULL)
2890 {
2891 closesocket(fd);
2892@@ -1531,7 +1579,9 @@
2893
2894 /* Report last socket() error if we couldn't find an address to bind. */
2895 if (con->fd == -1)
2896+ {
2897 return DRIZZLE_RETURN_ERRNO;
2898+ }
2899
2900 drizzle_state_pop(con);
2901 return DRIZZLE_RETURN_OK;
2902@@ -1547,6 +1597,12 @@
2903 struct linger linger;
2904 struct timeval waittime;
2905
2906+ if (con == NULL)
2907+ {
2908+ return DRIZZLE_RETURN_INVALID_ARGUMENT;
2909+ }
2910+
2911+
2912 ret= 1;
2913
2914 #ifdef _WIN32
2915
2916=== modified file 'libdrizzle-2.0/constants.h'
2917--- libdrizzle-2.0/constants.h 2011-11-18 16:11:02 +0000
2918+++ libdrizzle-2.0/constants.h 2011-11-29 23:07:26 +0000
2919@@ -42,8 +42,6 @@
2920 * @brief Defines, typedefs, enums, and macros
2921 */
2922
2923-#include <stdint.h>
2924-
2925 #ifdef __cplusplus
2926
2927 #include <vector>
2928@@ -66,113 +64,30 @@
2929 #define DRIZZLE_DEFAULT_UDS "/tmp/drizzle.sock"
2930 #define DRIZZLE_DEFAULT_UDS_MYSQL "/tmp/mysql.sock"
2931 #define DRIZZLE_DEFAULT_BACKLOG 64
2932-#define DRIZZLE_MAX_ERROR_SIZE 2048
2933-#define DRIZZLE_MAX_USER_SIZE 64
2934-#define DRIZZLE_MAX_PASSWORD_SIZE 32
2935-#define DRIZZLE_MAX_SCHEMA_SIZE 64
2936-#define DRIZZLE_MAX_DB_SIZE DRIZZLE_MAX_SCHEMA_SIZE
2937-#define DRIZZLE_MAX_INFO_SIZE 2048
2938-#define DRIZZLE_MAX_SQLSTATE_SIZE 5
2939-#define DRIZZLE_MAX_CATALOG_SIZE 128
2940-#define DRIZZLE_MAX_TABLE_SIZE 128
2941-#define DRIZZLE_MAX_COLUMN_NAME_SIZE 2048
2942-#define DRIZZLE_MAX_DEFAULT_VALUE_SIZE 2048
2943-#define DRIZZLE_MAX_PACKET_SIZE UINT32_MAX
2944-#define DRIZZLE_MAX_BUFFER_SIZE 32768
2945 #define DRIZZLE_BUFFER_COPY_THRESHOLD 8192
2946-#define DRIZZLE_MAX_SERVER_VERSION_SIZE 32
2947-#define DRIZZLE_MAX_SERVER_EXTRA_SIZE 32
2948-#define DRIZZLE_MAX_SCRAMBLE_SIZE 20
2949+#define DRIZZLE_ROW_GROW_SIZE 8192
2950 #define DRIZZLE_STATE_STACK_SIZE 8
2951-#define DRIZZLE_ROW_GROW_SIZE 8192
2952 #define DRIZZLE_DEFAULT_SOCKET_TIMEOUT 10
2953 #define DRIZZLE_DEFAULT_SOCKET_SEND_SIZE 32768
2954 #define DRIZZLE_DEFAULT_SOCKET_RECV_SIZE 32768
2955 #define DRIZZLE_MYSQL_PASSWORD_HASH 41
2956
2957-/**
2958- * Return codes.
2959- */
2960-enum drizzle_return_t
2961-{
2962- DRIZZLE_RETURN_OK,
2963- DRIZZLE_RETURN_IO_WAIT,
2964- DRIZZLE_RETURN_PAUSE,
2965- DRIZZLE_RETURN_ROW_BREAK,
2966- DRIZZLE_RETURN_MEMORY,
2967- DRIZZLE_RETURN_ERRNO,
2968- DRIZZLE_RETURN_INTERNAL_ERROR,
2969- DRIZZLE_RETURN_GETADDRINFO,
2970- DRIZZLE_RETURN_NOT_READY,
2971- DRIZZLE_RETURN_BAD_PACKET_NUMBER,
2972- DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET,
2973- DRIZZLE_RETURN_BAD_PACKET,
2974- DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED,
2975- DRIZZLE_RETURN_UNEXPECTED_DATA,
2976- DRIZZLE_RETURN_NO_SCRAMBLE,
2977- DRIZZLE_RETURN_AUTH_FAILED,
2978- DRIZZLE_RETURN_NULL_SIZE,
2979- DRIZZLE_RETURN_ERROR_CODE,
2980- DRIZZLE_RETURN_TOO_MANY_COLUMNS,
2981- DRIZZLE_RETURN_ROW_END,
2982- DRIZZLE_RETURN_LOST_CONNECTION,
2983- DRIZZLE_RETURN_COULD_NOT_CONNECT,
2984- DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS,
2985- DRIZZLE_RETURN_HANDSHAKE_FAILED,
2986- DRIZZLE_RETURN_TIMEOUT,
2987- DRIZZLE_RETURN_INVALID_ARGUMENT,
2988- DRIZZLE_RETURN_MAX /* Always add new codes to the end before this one. */
2989-};
2990-
2991-#ifndef __cplusplus
2992-typedef enum drizzle_return_t drizzle_return_t
2993-#endif
2994-
2995-/**
2996- * Verbosity levels.
2997- */
2998-enum drizzle_verbose_t
2999-{
3000- DRIZZLE_VERBOSE_NEVER,
3001- DRIZZLE_VERBOSE_FATAL,
3002- DRIZZLE_VERBOSE_ERROR,
3003- DRIZZLE_VERBOSE_INFO,
3004- DRIZZLE_VERBOSE_DEBUG,
3005- DRIZZLE_VERBOSE_CRAZY,
3006- DRIZZLE_VERBOSE_MAX
3007-};
3008-
3009-#ifndef __cplusplus
3010-typedef enum drizzle_verbose_t drizzle_verbose_t;
3011-#endif
3012+#include <libdrizzle-2.0/deprecated_enum.h>
3013+#include <libdrizzle-2.0/return.h>
3014+#include <libdrizzle-2.0/command.h>
3015+#include <libdrizzle-2.0/verbose.h>
3016+#include <libdrizzle-2.0/limits.h>
3017
3018 /** @} */
3019
3020 /**
3021- * @ingroup drizzle
3022- * Options for drizzle_st.
3023- */
3024-enum drizzle_options_t
3025-{
3026- DRIZZLE_NONE= 0,
3027- DRIZZLE_ALLOCATED= (1 << 0),
3028- DRIZZLE_NON_BLOCKING= (1 << 1),
3029- DRIZZLE_FREE_OBJECTS= (1 << 2),
3030- DRIZZLE_ASSERT_DANGLING= (1 << 3)
3031-};
3032-
3033-#ifndef __cplusplus
3034-typedef enum drizzle_options_t drizzle_options_t;
3035-#endif
3036-
3037-/**
3038 * @ingroup drizzle_con
3039 * Options for drizzle_con_st.
3040 */
3041 enum drizzle_con_options_t
3042 {
3043 DRIZZLE_CON_NONE= 0,
3044- DRIZZLE_CON_ALLOCATED= (1 << 0),
3045+ DRIZZLE_CON_ALLOCATED= (1 << 0), // DEPRECATED
3046 DRIZZLE_CON_MYSQL= (1 << 1),
3047 DRIZZLE_CON_RAW_PACKET= (1 << 2),
3048 DRIZZLE_CON_RAW_SCRAMBLE= (1 << 3),
3049@@ -272,84 +187,6 @@
3050 #endif
3051
3052 /**
3053- * @ingroup drizzle_command
3054- * Commands for drizzle_command functions.
3055- */
3056-enum drizzle_command_t
3057-{
3058- DRIZZLE_COMMAND_SLEEP, /* Not used currently. */
3059- DRIZZLE_COMMAND_QUIT,
3060- DRIZZLE_COMMAND_INIT_DB,
3061- DRIZZLE_COMMAND_QUERY,
3062- DRIZZLE_COMMAND_FIELD_LIST, /* Deprecated. */
3063- DRIZZLE_COMMAND_CREATE_DB, /* Deprecated. */
3064- DRIZZLE_COMMAND_DROP_DB, /* Deprecated. */
3065- DRIZZLE_COMMAND_REFRESH,
3066- DRIZZLE_COMMAND_SHUTDOWN,
3067- DRIZZLE_COMMAND_STATISTICS,
3068- DRIZZLE_COMMAND_PROCESS_INFO, /* Deprecated. */
3069- DRIZZLE_COMMAND_CONNECT, /* Not used currently. */
3070- DRIZZLE_COMMAND_PROCESS_KILL, /* Deprecated. */
3071- DRIZZLE_COMMAND_DEBUG,
3072- DRIZZLE_COMMAND_PING,
3073- DRIZZLE_COMMAND_TIME, /* Not used currently. */
3074- DRIZZLE_COMMAND_DELAYED_INSERT, /* Not used currently. */
3075- DRIZZLE_COMMAND_CHANGE_USER,
3076- DRIZZLE_COMMAND_BINLOG_DUMP, /* Not used currently. */
3077- DRIZZLE_COMMAND_TABLE_DUMP, /* Not used currently. */
3078- DRIZZLE_COMMAND_CONNECT_OUT, /* Not used currently. */
3079- DRIZZLE_COMMAND_REGISTER_SLAVE, /* Not used currently. */
3080- DRIZZLE_COMMAND_STMT_PREPARE, /* Not used currently. */
3081- DRIZZLE_COMMAND_STMT_EXECUTE, /* Not used currently. */
3082- DRIZZLE_COMMAND_STMT_SEND_LONG_DATA, /* Not used currently. */
3083- DRIZZLE_COMMAND_STMT_CLOSE, /* Not used currently. */
3084- DRIZZLE_COMMAND_STMT_RESET, /* Not used currently. */
3085- DRIZZLE_COMMAND_SET_OPTION, /* Not used currently. */
3086- DRIZZLE_COMMAND_STMT_FETCH, /* Not used currently. */
3087- DRIZZLE_COMMAND_DAEMON, /* Not used currently. */
3088- DRIZZLE_COMMAND_END /* Not used currently. */
3089-};
3090-
3091-#ifndef __cplusplus
3092-typedef enum drizzle_command_t drizzle_command_t;
3093-#endif
3094-
3095-/**
3096- * @ingroup drizzle_command
3097- * Commands for the Drizzle protocol functions.
3098- */
3099-enum drizzle_command_drizzle_t
3100-{
3101- DRIZZLE_COMMAND_DRIZZLE_SLEEP,
3102- DRIZZLE_COMMAND_DRIZZLE_QUIT,
3103- DRIZZLE_COMMAND_DRIZZLE_INIT_DB,
3104- DRIZZLE_COMMAND_DRIZZLE_QUERY,
3105- DRIZZLE_COMMAND_DRIZZLE_SHUTDOWN,
3106- DRIZZLE_COMMAND_DRIZZLE_CONNECT,
3107- DRIZZLE_COMMAND_DRIZZLE_PING,
3108- DRIZZLE_COMMAND_DRIZZLE_KILL,
3109- DRIZZLE_COMMAND_DRIZZLE_END
3110-};
3111-
3112-#ifndef __cplusplus
3113-typedef enum drizzle_command_drizzle_t drizzle_command_drizzle_t;
3114-#endif
3115-
3116-/**
3117- * @ingroup drizzle_query
3118- * Options for drizzle_query_st.
3119- */
3120-enum drizzle_query_options_t
3121-{
3122- DRIZZLE_QUERY_NONE,
3123- DRIZZLE_QUERY_ALLOCATED= (1 << 0)
3124-};
3125-
3126-#ifndef __cplusplus
3127-typedef enum drizzle_query_options_t drizzle_query_options_t;
3128-#endif
3129-
3130-/**
3131 * @ingroup drizzle_query
3132 * States for drizle_query_st.
3133 */
3134@@ -372,7 +209,7 @@
3135 enum drizzle_result_options_t
3136 {
3137 DRIZZLE_RESULT_NONE= 0,
3138- DRIZZLE_RESULT_ALLOCATED= (1 << 0),
3139+ DRIZZLE_RESULT_ALLOCATED= (1 << 0), // DEPRECATED
3140 DRIZZLE_RESULT_SKIP_COLUMN= (1 << 1),
3141 DRIZZLE_RESULT_BUFFER_COLUMN= (1 << 2),
3142 DRIZZLE_RESULT_BUFFER_ROW= (1 << 3),
3143@@ -390,7 +227,7 @@
3144 */
3145 enum drizzle_column_options_t
3146 {
3147- DRIZZLE_COLUMN_ALLOCATED= (1 << 0)
3148+ DRIZZLE_COLUMN_ALLOCATED= (1 << 0) // DEPRECATED
3149 };
3150
3151 #ifndef __cplusplus
3152
3153=== added file 'libdrizzle-2.0/deprecated_enum.h'
3154--- libdrizzle-2.0/deprecated_enum.h 1970-01-01 00:00:00 +0000
3155+++ libdrizzle-2.0/deprecated_enum.h 2011-11-29 23:07:26 +0000
3156@@ -0,0 +1,67 @@
3157+/*
3158+ * Drizzle Client & Protocol Library
3159+ *
3160+ * Copyright (C) 2011 Brian Aker (brian@tangent.org)
3161+ * All rights reserved.
3162+ *
3163+ * Redistribution and use in source and binary forms, with or without
3164+ * modification, are permitted provided that the following conditions are
3165+ * met:
3166+ *
3167+ * * Redistributions of source code must retain the above copyright
3168+ * notice, this list of conditions and the following disclaimer.
3169+ *
3170+ * * Redistributions in binary form must reproduce the above
3171+ * copyright notice, this list of conditions and the following disclaimer
3172+ * in the documentation and/or other materials provided with the
3173+ * distribution.
3174+ *
3175+ * * The names of its contributors may not be used to endorse or
3176+ * promote products derived from this software without specific prior
3177+ * written permission.
3178+ *
3179+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
3180+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3181+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
3182+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
3183+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
3184+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3185+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
3186+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
3187+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
3188+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3189+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3190+ *
3191+ */
3192+
3193+#pragma once
3194+
3195+/**
3196+ * @ingroup drizzle_query
3197+ * Options for drizzle_query_st.
3198+ */
3199+enum drizzle_query_options_t
3200+{
3201+ DRIZZLE_QUERY_NONE,
3202+ DRIZZLE_QUERY_ALLOCATED
3203+};
3204+
3205+#ifndef __cplusplus
3206+typedef enum drizzle_query_options_t drizzle_query_options_t;
3207+#endif
3208+
3209+/**
3210+ * @ingroup drizzle
3211+ * Options for drizzle_st.
3212+ */
3213+enum drizzle_options_t
3214+{
3215+ DRIZZLE_NON_BLOCKING,
3216+ DRIZZLE_FREE_OBJECTS,
3217+ DRIZZLE_ASSERT_DANGLING
3218+};
3219+
3220+#ifndef __cplusplus
3221+typedef enum drizzle_options_t drizzle_options_t;
3222+#endif
3223+
3224
3225=== modified file 'libdrizzle-2.0/drizzle.cc'
3226--- libdrizzle-2.0/drizzle.cc 2011-11-18 16:11:02 +0000
3227+++ libdrizzle-2.0/drizzle.cc 2011-11-29 23:07:26 +0000
3228@@ -86,7 +86,7 @@
3229 return _verbose_name[verbose];
3230 }
3231
3232-drizzle_st *drizzle_create(drizzle_st *drizzle)
3233+drizzle_st *drizzle_create()
3234 {
3235 #if defined(_WIN32)
3236 /* if it is MS windows, invoke WSAStartup */
3237@@ -101,15 +101,11 @@
3238 sigaction(SIGPIPE, &act, NULL);
3239 #endif
3240
3241+ drizzle_st *drizzle= new (std::nothrow) drizzle_st;
3242+
3243 if (drizzle == NULL)
3244 {
3245- drizzle= new (std::nothrow) drizzle_st;
3246-
3247- if (drizzle == NULL)
3248- {
3249- return NULL;
3250- }
3251- drizzle->options.is_allocated= true;
3252+ return NULL;
3253 }
3254
3255 /* @todo remove this default free flag with new API. */
3256@@ -140,21 +136,17 @@
3257 return drizzle;
3258 }
3259
3260-drizzle_st *drizzle_clone(drizzle_st *drizzle, const drizzle_st *from)
3261+drizzle_st *drizzle_clone(const drizzle_st *source)
3262 {
3263- drizzle= drizzle_create(drizzle);
3264+ drizzle_st *drizzle= drizzle_create();
3265 if (drizzle == NULL)
3266 {
3267 return NULL;
3268 }
3269
3270- bool cache_state= drizzle->options.is_allocated;
3271- drizzle->options= from->options;
3272- drizzle->options.is_allocated= cache_state;
3273-
3274- for (drizzle_con_st* con= from->con_list; con != NULL; con= con->next)
3275+ for (drizzle_con_st* con= source->con_list; con != NULL; con= con->next)
3276 {
3277- if (drizzle_con_clone(drizzle, NULL, con) == NULL)
3278+ if (drizzle_con_clone(drizzle, con) == NULL)
3279 {
3280 drizzle_free(drizzle);
3281 return NULL;
3282@@ -184,10 +176,7 @@
3283
3284 free(drizzle->pfds);
3285
3286- if (drizzle->options.is_allocated)
3287- {
3288- delete drizzle;
3289- }
3290+ delete drizzle;
3291 #if defined(_WIN32)
3292 /* if it is MS windows, invoke WSACleanup() at the end*/
3293 WSACleanup();
3294@@ -199,6 +188,27 @@
3295 return drizzle->last_error;
3296 }
3297
3298+drizzle_return_t drizzle_set_option(drizzle_st *drizzle, drizzle_options_t arg, bool set)
3299+{
3300+ switch (arg)
3301+ {
3302+ case DRIZZLE_NON_BLOCKING:
3303+ drizzle->options.is_non_blocking= set;
3304+ return DRIZZLE_RETURN_OK;
3305+
3306+ case DRIZZLE_FREE_OBJECTS:
3307+ return DRIZZLE_RETURN_OK;
3308+
3309+ case DRIZZLE_ASSERT_DANGLING:
3310+ return DRIZZLE_RETURN_OK;
3311+
3312+ default:
3313+ break;
3314+ }
3315+
3316+ return DRIZZLE_RETURN_INVALID_ARGUMENT;
3317+}
3318+
3319 int drizzle_errno(const drizzle_st *drizzle)
3320 {
3321 return drizzle->last_errno;
3322@@ -214,19 +224,6 @@
3323 return drizzle->sqlstate;
3324 }
3325
3326-int drizzle_options(const drizzle_st *)
3327-{
3328- return 0;
3329-}
3330-
3331-void drizzle_set_options(drizzle_st *, int)
3332-{
3333-}
3334-
3335-void drizzle_add_options(drizzle_st *, int)
3336-{
3337-}
3338-
3339 void *drizzle_context(const drizzle_st *drizzle)
3340 {
3341 return drizzle->context;
3342@@ -278,20 +275,24 @@
3343 drizzle->event_watch_context= context;
3344 }
3345
3346-drizzle_con_st *drizzle_con_create(drizzle_st *drizzle, drizzle_con_st *con)
3347+drizzle_con_st *drizzle_con_create(drizzle_st *drizzle)
3348 {
3349+ if (drizzle == NULL)
3350+ {
3351+ return NULL;
3352+ }
3353+
3354+ drizzle_con_st *con= new (std::nothrow) drizzle_con_st;
3355+
3356 if (con == NULL)
3357 {
3358- con= new (std::nothrow) drizzle_con_st;
3359- con->options= DRIZZLE_CON_ALLOCATED;
3360- }
3361- else
3362- {
3363- con->options= 0;
3364+ return NULL;
3365 }
3366
3367 if (drizzle->con_list != NULL)
3368+ {
3369 drizzle->con_list->prev= con;
3370+ }
3371
3372 con->next= drizzle->con_list;
3373 con->prev= NULL;
3374@@ -346,32 +347,31 @@
3375 return con;
3376 }
3377
3378-drizzle_con_st *drizzle_con_clone(drizzle_st *drizzle, drizzle_con_st *con,
3379- const drizzle_con_st *from)
3380+drizzle_con_st *drizzle_con_clone(drizzle_st *drizzle, drizzle_con_st *source)
3381 {
3382- con= drizzle_con_create(drizzle, con);
3383+ drizzle_con_st *con= drizzle_con_create(drizzle);
3384 if (con == NULL)
3385 {
3386 return NULL;
3387 }
3388
3389 /* Clear "operational" options such as IO status. */
3390- con->options|= (from->options & ~(DRIZZLE_CON_ALLOCATED|DRIZZLE_CON_READY|
3391+ con->options|= (source->options & ~(DRIZZLE_CON_ALLOCATED|DRIZZLE_CON_READY|
3392 DRIZZLE_CON_NO_RESULT_READ|DRIZZLE_CON_IO_READY|
3393 DRIZZLE_CON_LISTEN));
3394- con->backlog= from->backlog;
3395- strcpy(con->schema, from->schema);
3396- strcpy(con->password, from->password);
3397- strcpy(con->user, from->user);
3398+ con->backlog= source->backlog;
3399+ strcpy(con->schema, source->schema);
3400+ strcpy(con->password, source->password);
3401+ strcpy(con->user, source->user);
3402
3403- switch (from->socket_type)
3404+ switch (source->socket_type)
3405 {
3406 case DRIZZLE_CON_SOCKET_TCP:
3407- drizzle_con_set_tcp(con, from->socket.tcp.host, from->socket.tcp.port);
3408+ drizzle_con_set_tcp(con, source->socket.tcp.host, source->socket.tcp.port);
3409 break;
3410
3411 case DRIZZLE_CON_SOCKET_UDS:
3412- drizzle_con_set_uds(con, from->socket.uds.sockaddr.sun_path);
3413+ drizzle_con_set_uds(con, source->socket.uds.sockaddr.sun_path);
3414 break;
3415 }
3416
3417@@ -415,10 +415,7 @@
3418 }
3419 con->drizzle->con_count--;
3420
3421- if (con->options & DRIZZLE_CON_ALLOCATED)
3422- {
3423- delete con;
3424- }
3425+ delete con;
3426 }
3427
3428 void drizzle_con_free_all(drizzle_st *drizzle)
3429@@ -552,13 +549,13 @@
3430 * Client Definitions
3431 */
3432
3433-drizzle_con_st *drizzle_con_add_tcp(drizzle_st *drizzle, drizzle_con_st *con,
3434+drizzle_con_st *drizzle_con_add_tcp(drizzle_st *drizzle,
3435 const char *host, in_port_t port,
3436 const char *user, const char *password,
3437 const char *db,
3438 drizzle_con_options_t options)
3439 {
3440- con= drizzle_con_create(drizzle, con);
3441+ drizzle_con_st *con= drizzle_con_create(drizzle);
3442 if (con == NULL)
3443 {
3444 return NULL;
3445@@ -572,12 +569,12 @@
3446 return con;
3447 }
3448
3449-drizzle_con_st *drizzle_con_add_uds(drizzle_st *drizzle, drizzle_con_st *con,
3450+drizzle_con_st *drizzle_con_add_uds(drizzle_st *drizzle,
3451 const char *uds, const char *user,
3452 const char *password, const char *db,
3453 drizzle_con_options_t options)
3454 {
3455- con= drizzle_con_create(drizzle, con);
3456+ drizzle_con_st *con= drizzle_con_create(drizzle);
3457 if (con == NULL)
3458 {
3459 return NULL;
3460@@ -596,12 +593,11 @@
3461 */
3462
3463 drizzle_con_st *drizzle_con_add_tcp_listen(drizzle_st *drizzle,
3464- drizzle_con_st *con,
3465 const char *host, in_port_t port,
3466 int backlog,
3467 drizzle_con_options_t options)
3468 {
3469- con= drizzle_con_create(drizzle, con);
3470+ drizzle_con_st *con= drizzle_con_create(drizzle);
3471 if (con == NULL)
3472 {
3473 return NULL;
3474@@ -615,11 +611,10 @@
3475 }
3476
3477 drizzle_con_st *drizzle_con_add_uds_listen(drizzle_st *drizzle,
3478- drizzle_con_st *con,
3479 const char *uds, int backlog,
3480 drizzle_con_options_t options)
3481 {
3482- con= drizzle_con_create(drizzle, con);
3483+ drizzle_con_st *con= drizzle_con_create(drizzle);
3484 if (con == NULL)
3485 {
3486 return NULL;
3487@@ -632,16 +627,22 @@
3488 return con;
3489 }
3490
3491-drizzle_con_st *drizzle_con_accept(drizzle_st *drizzle, drizzle_con_st *con,
3492+drizzle_con_st *drizzle_con_accept(drizzle_st *drizzle,
3493 drizzle_return_t *ret_ptr)
3494 {
3495+ drizzle_return_t unused;
3496+ if (ret_ptr == NULL)
3497+ {
3498+ ret_ptr= &unused;
3499+ }
3500+
3501 while (1)
3502 {
3503 if (drizzle_con_st* ready= drizzle_con_ready_listen(drizzle))
3504 {
3505 int fd= accept(ready->fd, NULL, NULL);
3506
3507- con= drizzle_con_create(drizzle, con);
3508+ drizzle_con_st *con= drizzle_con_create(drizzle);
3509 if (con == NULL)
3510 {
3511 (void)closesocket(fd);
3512@@ -672,12 +673,16 @@
3513 for (drizzle_con_st* ready= drizzle->con_list; ready != NULL; ready= ready->next)
3514 {
3515 if (ready->options & DRIZZLE_CON_LISTEN)
3516+ {
3517 drizzle_con_set_events(ready, POLLIN);
3518+ }
3519 }
3520
3521 *ret_ptr= drizzle_con_wait(drizzle);
3522 if (*ret_ptr != DRIZZLE_RETURN_OK)
3523+ {
3524 return NULL;
3525+ }
3526 }
3527 }
3528
3529@@ -688,6 +693,10 @@
3530 void drizzle_set_error(drizzle_st *drizzle, const char *function,
3531 const char *format, ...)
3532 {
3533+ if (drizzle == NULL)
3534+ {
3535+ return;
3536+ }
3537 char log_buffer[DRIZZLE_MAX_ERROR_SIZE];
3538
3539 size_t size= strlen(function);
3540@@ -732,6 +741,11 @@
3541 {
3542 char log_buffer[DRIZZLE_MAX_ERROR_SIZE];
3543
3544+ if (drizzle == NULL)
3545+ {
3546+ return;
3547+ }
3548+
3549 if (drizzle->log_fn == NULL)
3550 {
3551 printf("%5s: ", drizzle_verbose_name(verbose));
3552
3553=== modified file 'libdrizzle-2.0/drizzle.h'
3554--- libdrizzle-2.0/drizzle.h 2011-11-18 16:11:02 +0000
3555+++ libdrizzle-2.0/drizzle.h 2011-11-29 23:07:26 +0000
3556@@ -152,7 +152,7 @@
3557 * failure this will be NULL.
3558 */
3559 DRIZZLE_API
3560-drizzle_st *drizzle_create(drizzle_st *drizzle);
3561+drizzle_st *drizzle_create();
3562
3563 /**
3564 * Clone a drizzle structure.
3565@@ -162,7 +162,7 @@
3566 * @return Same return as drizzle_create().
3567 */
3568 DRIZZLE_API
3569-drizzle_st *drizzle_clone(drizzle_st *drizzle, const drizzle_st *from);
3570+drizzle_st *drizzle_clone(const drizzle_st *from);
3571
3572 /**
3573 * Free a drizzle structure.
3574@@ -214,46 +214,6 @@
3575 const char *drizzle_sqlstate(const drizzle_st *drizzle);
3576
3577 /**
3578- * Get options for a drizzle structure.
3579- *
3580- * @param[in] drizzle Drizzle structure previously initialized with
3581- * drizzle_create() or drizzle_clone().
3582- * @return Options set for the drizzle structure.
3583- */
3584-DRIZZLE_API
3585-int drizzle_options(const drizzle_st *drizzle);
3586-
3587-/**
3588- * Set options for a drizzle structure.
3589- *
3590- * @param[in] drizzle Drizzle structure previously initialized with
3591- * drizzle_create() or drizzle_clone().
3592- * @param[in] options Available options for drizzle structure to set.
3593- */
3594-DRIZZLE_API
3595-void drizzle_set_options(drizzle_st *drizzle, int options);
3596-
3597-/**
3598- * Add options for a drizzle structure.
3599- *
3600- * @param[in] drizzle Drizzle structure previously initialized with
3601- * drizzle_create() or drizzle_clone().
3602- * @param[in] options Available options for drizzle structure to add.
3603- */
3604-DRIZZLE_API
3605-void drizzle_add_options(drizzle_st *drizzle, int options);
3606-
3607-/**
3608- * Remove options for a drizzle structure.
3609- *
3610- * @param[in] drizzle Drizzle structure previously initialized with
3611- * drizzle_create() or drizzle_clone().
3612- * @param[in] options Available options for drizzle structure to remove.
3613- */
3614-DRIZZLE_API
3615-void drizzle_remove_options(drizzle_st *, drizzle_options_t);
3616-
3617-/**
3618 * Get application context pointer.
3619 *
3620 * @param[in] drizzle Drizzle structure previously initialized with
3621@@ -375,7 +335,7 @@
3622 * failure this will be NULL.
3623 */
3624 DRIZZLE_API
3625-drizzle_con_st *drizzle_con_create(drizzle_st *drizzle, drizzle_con_st *con);
3626+drizzle_con_st *drizzle_con_create(drizzle_st *drizzle);
3627
3628 /**
3629 * Clone a connection structure.
3630@@ -387,8 +347,10 @@
3631 * @return Same return as drizzle_con_create().
3632 */
3633 DRIZZLE_API
3634-drizzle_con_st *drizzle_con_clone(drizzle_st *drizzle, drizzle_con_st *con,
3635- const drizzle_con_st *from);
3636+drizzle_con_st *drizzle_con_clone(drizzle_st *drizzle, drizzle_con_st *con);
3637+
3638+DRIZZLE_API
3639+drizzle_return_t drizzle_set_option(drizzle_st *drizzle, drizzle_options_t arg, bool set);
3640
3641 /**
3642 * Free a connection structure.
3643
3644=== modified file 'libdrizzle-2.0/drizzle_client.h'
3645--- libdrizzle-2.0/drizzle_client.h 2011-11-07 15:04:16 +0000
3646+++ libdrizzle-2.0/drizzle_client.h 2011-11-29 23:07:26 +0000
3647@@ -81,7 +81,7 @@
3648 * @return Same return as drizzle_con_create().
3649 */
3650 DRIZZLE_API
3651-drizzle_con_st *drizzle_con_add_tcp(drizzle_st *drizzle, drizzle_con_st *con,
3652+drizzle_con_st *drizzle_con_add_tcp(drizzle_st *drizzle,
3653 const char *host, in_port_t port,
3654 const char *user, const char *password,
3655 const char *db,
3656@@ -101,7 +101,7 @@
3657 * @return Same return as drizzle_con_create().
3658 */
3659 DRIZZLE_API
3660-drizzle_con_st *drizzle_con_add_uds(drizzle_st *drizzle, drizzle_con_st *con,
3661+drizzle_con_st *drizzle_con_add_uds(drizzle_st *drizzle,
3662 const char *uds, const char *user,
3663 const char *password, const char *db,
3664 drizzle_con_options_t options);
3665
3666=== modified file 'libdrizzle-2.0/drizzle_server.h'
3667--- libdrizzle-2.0/drizzle_server.h 2011-11-07 15:04:16 +0000
3668+++ libdrizzle-2.0/drizzle_server.h 2011-11-29 23:07:26 +0000
3669@@ -79,7 +79,6 @@
3670 */
3671 DRIZZLE_API
3672 drizzle_con_st *drizzle_con_add_tcp_listen(drizzle_st *drizzle,
3673- drizzle_con_st *con,
3674 const char *host, in_port_t port,
3675 int backlog,
3676 drizzle_con_options_t options);
3677@@ -89,7 +88,6 @@
3678 *
3679 * @param[in] drizzle Drizzle structure previously initialized with
3680 * drizzle_create() or drizzle_clone().
3681- * @param[in] con Caller allocated structure, or NULL to allocate one.
3682 * @param[in] uds Path to unix domain socket to use for listening.
3683 * @param[in] backlog Number of backlog connections passed to listen().
3684 * @param[in] options Drizzle connection options to add.
3685@@ -97,7 +95,6 @@
3686 */
3687 DRIZZLE_API
3688 drizzle_con_st *drizzle_con_add_uds_listen(drizzle_st *drizzle,
3689- drizzle_con_st *con,
3690 const char *uds, int backlog,
3691 drizzle_con_options_t options);
3692
3693@@ -116,12 +113,11 @@
3694 *
3695 * @param[in] drizzle Drizzle structure previously initialized with
3696 * drizzle_create() or drizzle_clone().
3697- * @param[in] con Caller allocated structure, or NULL to allocate one.
3698 * @param[out] ret_ptr Standard drizzle return value.
3699 * @return Same return as drizzle_con_create().
3700 */
3701 DRIZZLE_API
3702-drizzle_con_st *drizzle_con_accept(drizzle_st *drizzle, drizzle_con_st *con,
3703+drizzle_con_st *drizzle_con_accept(drizzle_st *drizzle,
3704 drizzle_return_t *ret_ptr);
3705
3706 /** @} */
3707
3708=== modified file 'libdrizzle-2.0/handshake.cc'
3709--- libdrizzle-2.0/handshake.cc 2011-11-18 02:03:41 +0000
3710+++ libdrizzle-2.0/handshake.cc 2011-11-29 23:07:26 +0000
3711@@ -572,34 +572,36 @@
3712
3713 drizzle_return_t drizzle_state_handshake_result_read(drizzle_con_st *con)
3714 {
3715- drizzle_result_st result;
3716+ drizzle_result_st *result;
3717
3718 drizzle_log_debug(con->drizzle, "drizzle_state_handshake_result_read");
3719
3720- if (drizzle_result_create(con, &result) == NULL)
3721+ if ((result= drizzle_result_create(con)) == NULL)
3722 {
3723 return DRIZZLE_RETURN_MEMORY;
3724 }
3725
3726- con->result= &result;
3727+ con->result= result;
3728
3729 drizzle_return_t ret= drizzle_state_result_read(con);
3730 if (drizzle_state_none(con))
3731 {
3732 if (ret == DRIZZLE_RETURN_OK)
3733 {
3734- if (drizzle_result_eof(&result))
3735+ if (drizzle_result_eof(result))
3736 {
3737 drizzle_set_error(con->drizzle, "drizzle_state_handshake_result_read",
3738 "old insecure authentication mechanism not supported");
3739 ret= DRIZZLE_RETURN_AUTH_FAILED;
3740 }
3741 else
3742+ {
3743 con->options|= DRIZZLE_CON_READY;
3744+ }
3745 }
3746 }
3747
3748- drizzle_result_free(&result);
3749+ drizzle_result_free(result);
3750
3751 if (ret == DRIZZLE_RETURN_ERROR_CODE)
3752 {
3753
3754=== modified file 'libdrizzle-2.0/include.am'
3755--- libdrizzle-2.0/include.am 2011-11-22 15:31:32 +0000
3756+++ libdrizzle-2.0/include.am 2011-11-29 23:07:26 +0000
3757@@ -34,7 +34,7 @@
3758 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3759 #
3760
3761-lib_LTLIBRARIES+= libdrizzle-2.0/libdrizzle-2.0.la
3762+noinst_LTLIBRARIES+= libdrizzle-2.0/libdrizzle-2.0.la
3763
3764 if HAVE_LIBSQLITE3
3765 SQLITE_PROGS= examples/sqlite_server
3766@@ -48,18 +48,19 @@
3767 # to call it drizzle_password_hash but to remain backward compatible I didn't
3768 # change any sources, rather just build it twice and provide both.
3769 # Only drizzle_password_hash is installed by make install though.
3770-bin_PROGRAMS+= libdrizzle-2.0/drizzle_password_hash
3771+noinst_PROGRAMS+= libdrizzle-2.0/drizzle_password_hash
3772 libdrizzle_2_0_drizzle_password_hash_LDADD= libdrizzle-2.0/libdrizzle-2.0.la
3773 libdrizzle_2_0_drizzle_password_hash_SOURCES= libdrizzle-2.0/mysql_password_hash.cc
3774
3775 noinst_PROGRAMS+= \
3776+ $(SQLITE_PROGS) \
3777 examples/client \
3778+ examples/pipe_query \
3779+ examples/proxy \
3780+ examples/server \
3781 examples/simple \
3782 examples/simple_multi \
3783- examples/pipe_query \
3784- examples/server \
3785- examples/proxy \
3786- $(SQLITE_PROGS)
3787+ libdrizzle-2.0/mysql_password_hash
3788
3789 libdrizzle_2_0_libdrizzle_2_0_la_CXXFLAGS= \
3790 ${AM_CXXFLAGS} \
3791@@ -111,38 +112,41 @@
3792 examples_sqlite_server_SOURCES= examples/sqlite_server.cc
3793 endif
3794
3795-nobase_include_HEADERS+= \
3796- libdrizzle-2.0/column.h \
3797- libdrizzle-2.0/column_client.h \
3798- libdrizzle-2.0/column_server.h \
3799- libdrizzle-2.0/command_client.h \
3800- libdrizzle-2.0/command_server.h \
3801- libdrizzle-2.0/conn.h \
3802- libdrizzle-2.0/conn_client.h \
3803- libdrizzle-2.0/conn_server.h \
3804- libdrizzle-2.0/constants.h \
3805- libdrizzle-2.0/drizzle.h \
3806- libdrizzle-2.0/drizzle_client.h \
3807- libdrizzle-2.0/drizzle_server.h \
3808- libdrizzle-2.0/field_client.h \
3809- libdrizzle-2.0/field_server.h \
3810- libdrizzle-2.0/handshake_client.h \
3811- libdrizzle-2.0/handshake_server.h \
3812- libdrizzle-2.0/libdrizzle.h \
3813- libdrizzle-2.0/libdrizzle.hpp \
3814- libdrizzle-2.0/query.h \
3815- libdrizzle-2.0/result.h \
3816- libdrizzle-2.0/result_client.h \
3817- libdrizzle-2.0/result_server.h \
3818- libdrizzle-2.0/row_client.h \
3819- libdrizzle-2.0/row_server.h \
3820- libdrizzle-2.0/structs.h \
3821- libdrizzle-2.0/visibility.h
3822-
3823 noinst_HEADERS+= \
3824+ libdrizzle-2.0/column.h \
3825+ libdrizzle-2.0/column_client.h \
3826+ libdrizzle-2.0/column_server.h \
3827+ libdrizzle-2.0/command.h \
3828+ libdrizzle-2.0/command_client.h \
3829+ libdrizzle-2.0/command_server.h \
3830 libdrizzle-2.0/common.h \
3831+ libdrizzle-2.0/conn.h \
3832+ libdrizzle-2.0/conn_client.h \
3833+ libdrizzle-2.0/conn_local.h \
3834+ libdrizzle-2.0/conn_server.h \
3835+ libdrizzle-2.0/constants.h \
3836+ libdrizzle-2.0/deprecated_enum.h \
3837+ libdrizzle-2.0/drizzle.h \
3838+ libdrizzle-2.0/drizzle_client.h \
3839 libdrizzle-2.0/drizzle_local.h \
3840- libdrizzle-2.0/conn_local.h \
3841+ libdrizzle-2.0/drizzle_server.h \
3842+ libdrizzle-2.0/field_client.h \
3843+ libdrizzle-2.0/field_server.h \
3844+ libdrizzle-2.0/handshake_client.h \
3845+ libdrizzle-2.0/handshake_server.h \
3846+ libdrizzle-2.0/libdrizzle.h \
3847+ libdrizzle-2.0/libdrizzle.hpp \
3848+ libdrizzle-2.0/limits.h \
3849 libdrizzle-2.0/pack.h \
3850+ libdrizzle-2.0/query.h \
3851+ libdrizzle-2.0/result.h \
3852+ libdrizzle-2.0/result_client.h \
3853+ libdrizzle-2.0/result_server.h \
3854+ libdrizzle-2.0/return.h \
3855+ libdrizzle-2.0/row_client.h \
3856+ libdrizzle-2.0/row_server.h \
3857+ libdrizzle-2.0/sha1.h \
3858 libdrizzle-2.0/state.h \
3859- libdrizzle-2.0/sha1.h
3860+ libdrizzle-2.0/structs.h \
3861+ libdrizzle-2.0/verbose.h \
3862+ libdrizzle-2.0/visibility.h
3863
3864=== modified file 'libdrizzle-2.0/libdrizzle.hpp'
3865--- libdrizzle-2.0/libdrizzle.hpp 2011-11-18 02:03:41 +0000
3866+++ libdrizzle-2.0/libdrizzle.hpp 2011-11-29 23:07:26 +0000
3867@@ -69,20 +69,20 @@
3868 public:
3869 drizzle_c()
3870 {
3871- drizzle_create(*this);
3872+ b_= drizzle_create();
3873 }
3874
3875 ~drizzle_c()
3876 {
3877- drizzle_free(*this);
3878+ drizzle_free(b_);
3879 }
3880
3881 operator drizzle_st*()
3882 {
3883- return &b_;
3884+ return b_;
3885 }
3886 private:
3887- drizzle_st b_;
3888+ drizzle_st *b_;
3889 };
3890
3891 class result_c
3892@@ -148,46 +148,56 @@
3893 public:
3894 explicit connection_c(drizzle_c& drizzle)
3895 {
3896- drizzle_con_create(drizzle, *this);
3897+ b_= drizzle_con_create(drizzle);
3898+
3899+ if (b_ == NULL)
3900+ {
3901+ throw "drizzle_con_create() failed";
3902+ }
3903 read_conf_files();
3904 }
3905
3906 ~connection_c()
3907 {
3908- drizzle_con_free(*this);
3909+ drizzle_con_free(b_);
3910 }
3911
3912 operator drizzle_con_st*()
3913 {
3914- return &b_;
3915+ return b_;
3916 }
3917
3918 const char* error()
3919 {
3920- return drizzle_con_error(*this);
3921+ return drizzle_con_error(b_);
3922 }
3923
3924 void set_tcp(const char* host, in_port_t port)
3925 {
3926- drizzle_con_set_tcp(*this, host, port);
3927+ drizzle_con_set_tcp(b_, host, port);
3928 }
3929
3930 void set_auth(const char* user, const char* password)
3931 {
3932- drizzle_con_set_auth(*this, user, password);
3933+ drizzle_con_set_auth(b_, user, password);
3934 }
3935
3936 void set_db(const char* db)
3937 {
3938- drizzle_con_set_db(*this, db);
3939+ drizzle_con_set_db(b_, db);
3940 }
3941
3942 drizzle_return_t query(result_c& result, const char* str, size_t str_size)
3943 {
3944 drizzle_return_t ret;
3945+
3946 drizzle_query(*this, result, str, str_size, &ret);
3947+
3948 if (!ret)
3949+ {
3950 ret = drizzle_result_buffer(result);
3951+ }
3952+
3953 return ret;
3954 }
3955
3956@@ -205,7 +215,10 @@
3957 {
3958 result_c result;
3959 if (query(result, str, str_size))
3960+ {
3961 throw bad_query(error());
3962+ }
3963+
3964 return result;
3965 }
3966
3967@@ -221,7 +234,7 @@
3968 private:
3969 void read_conf_files();
3970
3971- drizzle_con_st b_;
3972+ drizzle_con_st *b_;
3973 };
3974
3975 class query_c
3976
3977=== added file 'libdrizzle-2.0/limits.h'
3978--- libdrizzle-2.0/limits.h 1970-01-01 00:00:00 +0000
3979+++ libdrizzle-2.0/limits.h 2011-11-29 23:07:26 +0000
3980@@ -0,0 +1,56 @@
3981+/*
3982+ * Drizzle Client & Protocol Library
3983+ *
3984+ * Copyright (C) 2011 Brian Aker (brian@tangent.org)
3985+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
3986+ * All rights reserved.
3987+ *
3988+ * Redistribution and use in source and binary forms, with or without
3989+ * modification, are permitted provided that the following conditions are
3990+ * met:
3991+ *
3992+ * * Redistributions of source code must retain the above copyright
3993+ * notice, this list of conditions and the following disclaimer.
3994+ *
3995+ * * Redistributions in binary form must reproduce the above
3996+ * copyright notice, this list of conditions and the following disclaimer
3997+ * in the documentation and/or other materials provided with the
3998+ * distribution.
3999+ *
4000+ * * The names of its contributors may not be used to endorse or
4001+ * promote products derived from this software without specific prior
4002+ * written permission.
4003+ *
4004+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4005+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
4006+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
4007+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
4008+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
4009+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
4010+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
4011+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
4012+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
4013+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
4014+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
4015+ *
4016+ */
4017+
4018+#pragma once
4019+
4020+#define DRIZZLE_MAX_BUFFER_SIZE 32768
4021+#define DRIZZLE_MAX_CATALOG_SIZE 128
4022+#define DRIZZLE_MAX_COLUMN_NAME_SIZE 2048
4023+#define DRIZZLE_MAX_DB_SIZE DRIZZLE_MAX_SCHEMA_SIZE
4024+#define DRIZZLE_MAX_DEFAULT_VALUE_SIZE 2048
4025+#define DRIZZLE_MAX_ERROR_SIZE 2048
4026+#define DRIZZLE_MAX_INFO_SIZE 2048
4027+#define DRIZZLE_MAX_PACKET_SIZE UINT32_MAX
4028+#define DRIZZLE_MAX_PASSWORD_SIZE 32
4029+#define DRIZZLE_MAX_SCHEMA_SIZE 64
4030+#define DRIZZLE_MAX_SCRAMBLE_SIZE 20
4031+#define DRIZZLE_MAX_SERVER_EXTRA_SIZE 32
4032+#define DRIZZLE_MAX_SERVER_VERSION_SIZE 32
4033+#define DRIZZLE_MAX_SQLSTATE_SIZE 5
4034+#define DRIZZLE_MAX_TABLE_SIZE 128
4035+#define DRIZZLE_MAX_USER_SIZE 64
4036+
4037
4038=== modified file 'libdrizzle-2.0/query.cc'
4039--- libdrizzle-2.0/query.cc 2011-11-18 16:11:02 +0000
4040+++ libdrizzle-2.0/query.cc 2011-11-29 23:07:26 +0000
4041@@ -72,7 +72,7 @@
4042 drizzle_con_st *con,
4043 drizzle_result_st *result,
4044 const char *query_string, size_t size,
4045- drizzle_query_options_t options,
4046+ drizzle_query_options_t,
4047 void *context)
4048 {
4049 // @note drizzle_query_st handle the null drizzle case
4050@@ -85,14 +85,12 @@
4051 drizzle_query_set_con(query, con);
4052 drizzle_query_set_result(query, result);
4053 drizzle_query_set_string(query, query_string, size);
4054- drizzle_query_add_options(query, options);
4055 drizzle_query_set_context(query, context);
4056
4057 return query;
4058 }
4059
4060-drizzle_query_st *drizzle_query_create(drizzle_st *drizzle,
4061- drizzle_query_st *query)
4062+drizzle_query_st *drizzle_query_create(drizzle_st *drizzle, drizzle_query_st *query)
4063 {
4064 if (drizzle == NULL)
4065 {
4066@@ -107,12 +105,11 @@
4067 {
4068 return NULL;
4069 }
4070- query->options|= DRIZZLE_CON_ALLOCATED;
4071+ query->options.is_allocated= true;
4072 }
4073 else
4074 {
4075 query->prev= NULL;
4076- query->options= 0;
4077 query->state= DRIZZLE_QUERY_STATE_INIT;
4078 query->con= NULL;
4079 query->result= NULL;
4080@@ -120,6 +117,7 @@
4081 query->size= 0;
4082 query->context= NULL;
4083 query->context_free_fn= NULL;
4084+ query->options.is_allocated= false;
4085 }
4086
4087 query->drizzle= drizzle;
4088@@ -144,21 +142,31 @@
4089 }
4090
4091 if (query->context != NULL && query->context_free_fn != NULL)
4092+ {
4093 query->context_free_fn(query, query->context);
4094+ }
4095
4096 if (query->drizzle->query_list == query)
4097+ {
4098 query->drizzle->query_list= query->next;
4099+ }
4100
4101 if (query->prev)
4102+ {
4103 query->prev->next= query->next;
4104+ }
4105
4106 if (query->next)
4107+ {
4108 query->next->prev= query->prev;
4109+ }
4110
4111 query->drizzle->query_count--;
4112
4113- if (query->options & DRIZZLE_QUERY_ALLOCATED)
4114+ if (query->options.is_allocated)
4115+ {
4116 delete query;
4117+ }
4118 }
4119
4120 void drizzle_query_free_all(drizzle_st *drizzle)
4121@@ -233,47 +241,21 @@
4122 query->size= size;
4123 }
4124
4125-int drizzle_query_options(drizzle_query_st *query)
4126-{
4127- if (query == NULL)
4128- {
4129- return 0;
4130- }
4131-
4132- return query->options;
4133-}
4134-
4135-void drizzle_query_set_options(drizzle_query_st *query,
4136- int options)
4137-{
4138- if (query == NULL)
4139- {
4140- return;
4141- }
4142-
4143- query->options= options;
4144-}
4145-
4146-void drizzle_query_add_options(drizzle_query_st *query,
4147- int options)
4148-{
4149- if (query == NULL)
4150- {
4151- return;
4152- }
4153-
4154- query->options|= options;
4155-}
4156-
4157-void drizzle_query_remove_options(drizzle_query_st *query,
4158- int options)
4159-{
4160- if (query == NULL)
4161- {
4162- return;
4163- }
4164-
4165- query->options&= ~options;
4166+int drizzle_query_options(drizzle_query_st *)
4167+{
4168+ return 0;
4169+}
4170+
4171+void drizzle_query_set_options(drizzle_query_st *, int)
4172+{
4173+}
4174+
4175+void drizzle_query_add_options(drizzle_query_st *, int)
4176+{
4177+}
4178+
4179+void drizzle_query_remove_options(drizzle_query_st *, int)
4180+{
4181 }
4182
4183 void *drizzle_query_context(drizzle_query_st *query)
4184
4185=== modified file 'libdrizzle-2.0/query.h'
4186--- libdrizzle-2.0/query.h 2011-11-18 02:03:41 +0000
4187+++ libdrizzle-2.0/query.h 2011-11-29 23:07:26 +0000
4188@@ -164,28 +164,25 @@
4189 * Get options for a query.
4190 */
4191 DRIZZLE_API
4192-int drizzle_query_options(drizzle_query_st *query);
4193+int drizzle_query_options(drizzle_query_st *);
4194
4195 /**
4196 * Set options for a query.
4197 */
4198 DRIZZLE_API
4199-void drizzle_query_set_options(drizzle_query_st *query,
4200- int options);
4201+void drizzle_query_set_options(drizzle_query_st *, int);
4202
4203 /**
4204 * Add options for a query.
4205 */
4206 DRIZZLE_API
4207-void drizzle_query_add_options(drizzle_query_st *query,
4208- int options);
4209+void drizzle_query_add_options(drizzle_query_st *, int);
4210
4211 /**
4212 * Remove options for a query.
4213 */
4214 DRIZZLE_API
4215-void drizzle_query_remove_options(drizzle_query_st *query,
4216- int options);
4217+void drizzle_query_remove_options(drizzle_query_st *, int);
4218
4219 /**
4220 * Get application context for a query.
4221
4222=== modified file 'libdrizzle-2.0/result.cc'
4223--- libdrizzle-2.0/result.cc 2011-11-18 16:11:02 +0000
4224+++ libdrizzle-2.0/result.cc 2011-11-29 23:07:26 +0000
4225@@ -46,8 +46,13 @@
4226 * Common definitions
4227 */
4228
4229-drizzle_result_st *drizzle_result_create(drizzle_con_st *con,
4230- drizzle_result_st *result)
4231+drizzle_result_st *drizzle_result_create(drizzle_con_st *con)
4232+{
4233+ return drizzle_result_create_with(con, NULL);
4234+}
4235+
4236+drizzle_result_st *drizzle_result_create_with(drizzle_con_st *con,
4237+ drizzle_result_st *result)
4238 {
4239 if (result == NULL)
4240 {
4241@@ -58,7 +63,7 @@
4242 return NULL;
4243 }
4244
4245- result->options|= DRIZZLE_RESULT_ALLOCATED;
4246+ result->_options.is_allocated= true;
4247 }
4248 else
4249 {
4250@@ -93,6 +98,8 @@
4251 result->row_list= NULL;
4252 result->field_sizes= NULL;
4253 result->field_sizes_list= NULL;
4254+
4255+ result->_options.is_allocated= false;
4256 }
4257
4258 result->con= con;
4259@@ -108,25 +115,24 @@
4260 }
4261
4262 drizzle_result_st *drizzle_result_clone(drizzle_con_st *con,
4263- drizzle_result_st *result,
4264- drizzle_result_st *from)
4265+ drizzle_result_st *source)
4266 {
4267- result= drizzle_result_create(con, result);
4268+ drizzle_result_st *result= drizzle_result_create(con);
4269 if (result == NULL)
4270 {
4271 return NULL;
4272 }
4273
4274- result->options|= from->options & ~DRIZZLE_RESULT_ALLOCATED;
4275+ result->options= source->options;
4276
4277- drizzle_result_set_info(result, from->info);
4278- result->error_code= from->error_code;
4279- drizzle_result_set_sqlstate(result, from->sqlstate);
4280- result->warning_count= from->warning_count;
4281- result->insert_id= from->insert_id;
4282- result->affected_rows= from->affected_rows;
4283- result->column_count= from->column_count;
4284- result->row_count= from->row_count;
4285+ drizzle_result_set_info(result, source->info);
4286+ result->error_code= source->error_code;
4287+ drizzle_result_set_sqlstate(result, source->sqlstate);
4288+ result->warning_count= source->warning_count;
4289+ result->insert_id= source->insert_id;
4290+ result->affected_rows= source->affected_rows;
4291+ result->column_count= source->column_count;
4292+ result->row_count= source->row_count;
4293
4294 return result;
4295 }
4296@@ -134,7 +140,6 @@
4297 void drizzle_result_free(drizzle_result_st *result)
4298 {
4299 drizzle_column_st *column;
4300- uint64_t x;
4301
4302 if (result == NULL)
4303 {
4304@@ -150,8 +155,10 @@
4305
4306 if (result->options & DRIZZLE_RESULT_BUFFER_ROW)
4307 {
4308- for (x= 0; x < result->row_count; x++)
4309- drizzle_row_free(result, result->row_list->at(static_cast<size_t>(x)));
4310+ for (size_t x= 0; x < result->row_count; x++)
4311+ {
4312+ drizzle_row_free(result, result->row_list->at(x));
4313+ }
4314
4315 delete result->row_list;
4316 delete result->field_sizes_list;
4317@@ -163,13 +170,17 @@
4318 if (result->con->result_list == result)
4319 result->con->result_list= result->next;
4320 }
4321+
4322 if (result->prev)
4323 result->prev->next= result->next;
4324+
4325 if (result->next)
4326 result->next->prev= result->prev;
4327
4328- if (result->options & DRIZZLE_RESULT_ALLOCATED)
4329+ if (result->_options.is_allocated)
4330+ {
4331 delete result;
4332+ }
4333 }
4334
4335 void drizzle_result_free_all(drizzle_con_st *con)
4336@@ -312,7 +323,7 @@
4337
4338 if (drizzle_state_none(con))
4339 {
4340- con->result= drizzle_result_create(con, result);
4341+ con->result= drizzle_result_create_with(con, result);
4342 if (con->result == NULL)
4343 {
4344 *ret_ptr= DRIZZLE_RETURN_MEMORY;
4345
4346=== modified file 'libdrizzle-2.0/result.h'
4347--- libdrizzle-2.0/result.h 2011-11-07 15:04:16 +0000
4348+++ libdrizzle-2.0/result.h 2011-11-29 23:07:26 +0000
4349@@ -58,16 +58,17 @@
4350 * Initialize a result structure.
4351 */
4352 DRIZZLE_API
4353-drizzle_result_st *drizzle_result_create(drizzle_con_st *con,
4354- drizzle_result_st *result);
4355+drizzle_result_st *drizzle_result_create(drizzle_con_st *con);
4356+
4357+drizzle_result_st *drizzle_result_create_with(drizzle_con_st *con,
4358+ drizzle_result_st *result);
4359
4360 /**
4361 * Clone a connection structure.
4362 */
4363 DRIZZLE_API
4364-drizzle_result_st *drizzle_result_clone(drizzle_con_st *con,
4365- drizzle_result_st *result,
4366- drizzle_result_st *from);
4367+ drizzle_result_st *drizzle_result_clone(drizzle_con_st *con,
4368+ drizzle_result_st *source);
4369
4370 /**
4371 * Free a result structure.
4372
4373=== added file 'libdrizzle-2.0/return.h'
4374--- libdrizzle-2.0/return.h 1970-01-01 00:00:00 +0000
4375+++ libdrizzle-2.0/return.h 2011-11-29 23:07:26 +0000
4376@@ -0,0 +1,78 @@
4377+/*
4378+ * Drizzle Client & Protocol Library
4379+ *
4380+ * Copyright (C) 2011 Brian Aker (brian@tangent.org)
4381+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
4382+ * All rights reserved.
4383+ *
4384+ * Redistribution and use in source and binary forms, with or without
4385+ * modification, are permitted provided that the following conditions are
4386+ * met:
4387+ *
4388+ * * Redistributions of source code must retain the above copyright
4389+ * notice, this list of conditions and the following disclaimer.
4390+ *
4391+ * * Redistributions in binary form must reproduce the above
4392+ * copyright notice, this list of conditions and the following disclaimer
4393+ * in the documentation and/or other materials provided with the
4394+ * distribution.
4395+ *
4396+ * * The names of its contributors may not be used to endorse or
4397+ * promote products derived from this software without specific prior
4398+ * written permission.
4399+ *
4400+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4401+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
4402+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
4403+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
4404+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
4405+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
4406+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
4407+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
4408+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
4409+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
4410+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
4411+ *
4412+ */
4413+
4414+#pragma once
4415+
4416+/**
4417+ * Return codes.
4418+ */
4419+enum drizzle_return_t
4420+{
4421+ DRIZZLE_RETURN_OK,
4422+ DRIZZLE_RETURN_IO_WAIT,
4423+ DRIZZLE_RETURN_PAUSE,
4424+ DRIZZLE_RETURN_ROW_BREAK,
4425+ DRIZZLE_RETURN_MEMORY,
4426+ DRIZZLE_RETURN_ERRNO,
4427+ DRIZZLE_RETURN_INTERNAL_ERROR,
4428+ DRIZZLE_RETURN_GETADDRINFO,
4429+ DRIZZLE_RETURN_NOT_READY,
4430+ DRIZZLE_RETURN_BAD_PACKET_NUMBER,
4431+ DRIZZLE_RETURN_BAD_HANDSHAKE_PACKET,
4432+ DRIZZLE_RETURN_BAD_PACKET,
4433+ DRIZZLE_RETURN_PROTOCOL_NOT_SUPPORTED,
4434+ DRIZZLE_RETURN_UNEXPECTED_DATA,
4435+ DRIZZLE_RETURN_NO_SCRAMBLE,
4436+ DRIZZLE_RETURN_AUTH_FAILED,
4437+ DRIZZLE_RETURN_NULL_SIZE,
4438+ DRIZZLE_RETURN_ERROR_CODE,
4439+ DRIZZLE_RETURN_TOO_MANY_COLUMNS,
4440+ DRIZZLE_RETURN_ROW_END,
4441+ DRIZZLE_RETURN_LOST_CONNECTION,
4442+ DRIZZLE_RETURN_COULD_NOT_CONNECT,
4443+ DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS,
4444+ DRIZZLE_RETURN_HANDSHAKE_FAILED,
4445+ DRIZZLE_RETURN_TIMEOUT,
4446+ DRIZZLE_RETURN_INVALID_ARGUMENT,
4447+ DRIZZLE_RETURN_MAX /* Always add new codes to the end before this one. */
4448+};
4449+
4450+#ifndef __cplusplus
4451+typedef enum drizzle_return_t drizzle_return_t
4452+#endif
4453+
4454+
4455
4456=== modified file 'libdrizzle-2.0/row.cc'
4457--- libdrizzle-2.0/row.cc 2011-11-18 16:11:02 +0000
4458+++ libdrizzle-2.0/row.cc 2011-11-29 23:07:26 +0000
4459@@ -226,7 +226,9 @@
4460 return DRIZZLE_RETURN_OK;
4461 }
4462 else if (con->result->options & DRIZZLE_RESULT_ROW_BREAK)
4463+ {
4464 con->result->options&= ~DRIZZLE_RESULT_ROW_BREAK;
4465+ }
4466 else
4467 {
4468 con->result->row_count++;
4469@@ -235,6 +237,7 @@
4470 }
4471
4472 drizzle_state_pop(con);
4473+
4474 return DRIZZLE_RETURN_OK;
4475 }
4476
4477@@ -258,5 +261,6 @@
4478 con->buffer_size+= 4;
4479
4480 drizzle_state_pop(con);
4481+
4482 return DRIZZLE_RETURN_OK;
4483 }
4484
4485=== modified file 'libdrizzle-2.0/structs.h'
4486--- libdrizzle-2.0/structs.h 2011-11-18 16:11:02 +0000
4487+++ libdrizzle-2.0/structs.h 2011-11-29 23:07:26 +0000
4488@@ -161,6 +161,13 @@
4489 int capabilities;
4490 drizzle_charset_t charset;
4491 drizzle_command_t command;
4492+ struct option_t {
4493+ bool is_allocated;
4494+
4495+ option_t() :
4496+ is_allocated(false)
4497+ { }
4498+ } _options;
4499 int options;
4500 drizzle_con_socket_t socket_type;
4501 drizzle_con_status_t status;
4502@@ -245,7 +252,13 @@
4503 drizzle_st *drizzle;
4504 drizzle_query_st *next;
4505 drizzle_query_st *prev;
4506- int options;
4507+ struct option_t {
4508+ bool is_allocated;
4509+
4510+ option_t() :
4511+ is_allocated(false)
4512+ { }
4513+ } options;
4514 drizzle_query_state_t state;
4515 drizzle_con_st *con;
4516 drizzle_result_st *result;
4517@@ -258,7 +271,6 @@
4518 drizzle(NULL),
4519 next(NULL),
4520 prev(NULL),
4521- options(0),
4522 con(NULL),
4523 result(NULL),
4524 string(NULL),
4525@@ -277,6 +289,13 @@
4526 drizzle_con_st *con;
4527 drizzle_result_st *next;
4528 drizzle_result_st *prev;
4529+ struct option_t {
4530+ bool is_allocated;
4531+
4532+ option_t() :
4533+ is_allocated(false)
4534+ { }
4535+ } _options;
4536 int options;
4537
4538 char info[DRIZZLE_MAX_INFO_SIZE];
4539@@ -344,7 +363,13 @@
4540 drizzle_result_st *result;
4541 drizzle_column_st *next;
4542 drizzle_column_st *prev;
4543- int options;
4544+ struct options_t {
4545+ bool is_allocated;
4546+
4547+ options_t() :
4548+ is_allocated(false)
4549+ { }
4550+ } options;
4551 char catalog[DRIZZLE_MAX_CATALOG_SIZE];
4552 char schema[DRIZZLE_MAX_DB_SIZE];
4553 char table[DRIZZLE_MAX_TABLE_SIZE];
4554@@ -364,7 +389,6 @@
4555 result(NULL),
4556 next(NULL),
4557 prev(NULL),
4558- options(0),
4559 size(0),
4560 max_size(0),
4561 flags(DRIZZLE_COLUMN_FLAGS_NONE),
4562
4563=== added file 'libdrizzle-2.0/verbose.h'
4564--- libdrizzle-2.0/verbose.h 1970-01-01 00:00:00 +0000
4565+++ libdrizzle-2.0/verbose.h 2011-11-29 23:07:26 +0000
4566@@ -0,0 +1,58 @@
4567+/*
4568+ * Drizzle Client & Protocol Library
4569+ *
4570+ * Copyright (C) 2011 Brian Aker (brian@tangent.org)
4571+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
4572+ * All rights reserved.
4573+ *
4574+ * Redistribution and use in source and binary forms, with or without
4575+ * modification, are permitted provided that the following conditions are
4576+ * met:
4577+ *
4578+ * * Redistributions of source code must retain the above copyright
4579+ * notice, this list of conditions and the following disclaimer.
4580+ *
4581+ * * Redistributions in binary form must reproduce the above
4582+ * copyright notice, this list of conditions and the following disclaimer
4583+ * in the documentation and/or other materials provided with the
4584+ * distribution.
4585+ *
4586+ * * The names of its contributors may not be used to endorse or
4587+ * promote products derived from this software without specific prior
4588+ * written permission.
4589+ *
4590+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4591+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
4592+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
4593+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
4594+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
4595+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
4596+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
4597+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
4598+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
4599+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
4600+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
4601+ *
4602+ */
4603+
4604+#pragma once
4605+
4606+
4607+/**
4608+ * Verbosity levels.
4609+ */
4610+enum drizzle_verbose_t
4611+{
4612+ DRIZZLE_VERBOSE_NEVER,
4613+ DRIZZLE_VERBOSE_FATAL,
4614+ DRIZZLE_VERBOSE_ERROR,
4615+ DRIZZLE_VERBOSE_INFO,
4616+ DRIZZLE_VERBOSE_DEBUG,
4617+ DRIZZLE_VERBOSE_CRAZY,
4618+ DRIZZLE_VERBOSE_MAX
4619+};
4620+
4621+#ifndef __cplusplus
4622+typedef enum drizzle_verbose_t drizzle_verbose_t;
4623+#endif
4624+
4625
4626=== modified file 'plugin/mysql_protocol/mysql_protocol.cc'
4627--- plugin/mysql_protocol/mysql_protocol.cc 2011-11-04 21:06:16 +0000
4628+++ plugin/mysql_protocol/mysql_protocol.cc 2011-11-29 23:07:26 +0000
4629@@ -18,19 +18,23 @@
4630 */
4631
4632 #include <config.h>
4633+
4634+#include <boost/program_options.hpp>
4635+
4636+#include <algorithm>
4637+#include <climits>
4638+
4639 #include <drizzled/gettext.h>
4640 #include <drizzled/error.h>
4641 #include <drizzled/error/sql_state.h>
4642 #include <drizzled/session.h>
4643 #include <drizzled/internal/m_string.h>
4644-#include <algorithm>
4645-#include <boost/program_options.hpp>
4646 #include <drizzled/module/option_map.h>
4647 #include <drizzled/util/tokenize.h>
4648-#include "errmsg.h"
4649-#include "mysql_protocol.h"
4650-#include "mysql_password.h"
4651-#include "options.h"
4652+#include <plugin/mysql_protocol/errmsg.h>
4653+#include <plugin/mysql_protocol/mysql_protocol.h>
4654+#include <plugin/mysql_protocol/mysql_password.h>
4655+#include <plugin/mysql_protocol/options.h>
4656 #include <drizzled/identifier.h>
4657 #include <drizzled/plugin/function.h>
4658 #include <drizzled/diagnostics_area.h>
4659
4660=== modified file 'plugin/slave/queue_producer.cc'
4661--- plugin/slave/queue_producer.cc 2011-07-06 23:13:00 +0000
4662+++ plugin/slave/queue_producer.cc 2011-11-29 23:07:26 +0000
4663@@ -18,6 +18,8 @@
4664 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
4665 */
4666
4667+#include <config.h>
4668+
4669 #include <plugin/slave/queue_producer.h>
4670 #include <drizzled/errmsg_print.h>
4671 #include <drizzled/sql/result_set.h>
4672@@ -133,34 +135,34 @@
4673
4674 bool QueueProducer::openConnection()
4675 {
4676- if (drizzle_create(&_drizzle) == NULL)
4677- {
4678- _last_return= DRIZZLE_RETURN_INTERNAL_ERROR;
4679- _last_error_message= "Replication slave: ";
4680- _last_error_message.append(drizzle_error(&_drizzle));
4681- errmsg_printf(error::ERROR, _("%s"), _last_error_message.c_str());
4682- return false;
4683- }
4684-
4685- if (drizzle_con_create(&_drizzle, &_connection) == NULL)
4686- {
4687- _last_return= DRIZZLE_RETURN_INTERNAL_ERROR;
4688- _last_error_message= "Replication slave: ";
4689- _last_error_message.append(drizzle_error(&_drizzle));
4690- errmsg_printf(error::ERROR, _("%s"), _last_error_message.c_str());
4691- return false;
4692- }
4693-
4694- drizzle_con_set_tcp(&_connection, _master_host.c_str(), _master_port);
4695- drizzle_con_set_auth(&_connection, _master_user.c_str(), _master_pass.c_str());
4696+ if ((_drizzle= drizzle_create()) == NULL)
4697+ {
4698+ _last_return= DRIZZLE_RETURN_INTERNAL_ERROR;
4699+ _last_error_message= "Replication slave: ";
4700+ _last_error_message.append(drizzle_error(_drizzle));
4701+ errmsg_printf(error::ERROR, _("%s"), _last_error_message.c_str());
4702+ return false;
4703+ }
4704+
4705+ if ((_connection= drizzle_con_create(_drizzle)) == NULL)
4706+ {
4707+ _last_return= DRIZZLE_RETURN_INTERNAL_ERROR;
4708+ _last_error_message= "Replication slave: ";
4709+ _last_error_message.append(drizzle_error(_drizzle));
4710+ errmsg_printf(error::ERROR, _("%s"), _last_error_message.c_str());
4711+ return false;
4712+ }
4713+
4714+ drizzle_con_set_tcp(_connection, _master_host.c_str(), _master_port);
4715+ drizzle_con_set_auth(_connection, _master_user.c_str(), _master_pass.c_str());
4716
4717- drizzle_return_t ret= drizzle_con_connect(&_connection);
4718+ drizzle_return_t ret= drizzle_con_connect(_connection);
4719
4720 if (ret != DRIZZLE_RETURN_OK)
4721 {
4722 _last_return= ret;
4723 _last_error_message= "Replication slave: ";
4724- _last_error_message.append(drizzle_error(&_drizzle));
4725+ _last_error_message.append(drizzle_error(_drizzle));
4726 errmsg_printf(error::ERROR, _("%s"), _last_error_message.c_str());
4727 return false;
4728 }
4729@@ -177,7 +179,7 @@
4730
4731 _is_connected= false;
4732
4733- if (drizzle_quit(&_connection, &result, &ret) == NULL)
4734+ if (drizzle_quit(_connection, &result, &ret) == NULL)
4735 {
4736 _last_return= ret;
4737 drizzle_result_free(&result);
4738@@ -246,13 +248,13 @@
4739
4740 drizzle_return_t ret;
4741 drizzle_result_st result;
4742- drizzle_query_str(&_connection, &result, sql.c_str(), &ret);
4743+ drizzle_query_str(_connection, &result, sql.c_str(), &ret);
4744
4745 if (ret != DRIZZLE_RETURN_OK)
4746 {
4747 _last_return= ret;
4748 _last_error_message= "Replication slave: ";
4749- _last_error_message.append(drizzle_error(&_drizzle));
4750+ _last_error_message.append(drizzle_error(_drizzle));
4751 errmsg_printf(error::ERROR, _("%s"), _last_error_message.c_str());
4752 drizzle_result_free(&result);
4753 return false;
4754@@ -264,7 +266,7 @@
4755 {
4756 _last_return= ret;
4757 _last_error_message= "Replication slave: ";
4758- _last_error_message.append(drizzle_error(&_drizzle));
4759+ _last_error_message.append(drizzle_error(_drizzle));
4760 errmsg_printf(error::ERROR, _("%s"), _last_error_message.c_str());
4761 drizzle_result_free(&result);
4762 return false;
4763@@ -418,13 +420,13 @@
4764
4765 drizzle_return_t ret;
4766 drizzle_result_st result;
4767- drizzle_query_str(&_connection, &result, sql.c_str(), &ret);
4768+ drizzle_query_str(_connection, &result, sql.c_str(), &ret);
4769
4770 if (ret != DRIZZLE_RETURN_OK)
4771 {
4772 _last_return= ret;
4773 _last_error_message= "Replication slave: ";
4774- _last_error_message.append(drizzle_error(&_drizzle));
4775+ _last_error_message.append(drizzle_error(_drizzle));
4776 errmsg_printf(error::ERROR, _("%s"), _last_error_message.c_str());
4777 drizzle_result_free(&result);
4778 return ER_YES;
4779@@ -438,7 +440,7 @@
4780 {
4781 _last_return= ret;
4782 _last_error_message= "Replication slave: ";
4783- _last_error_message.append(drizzle_error(&_drizzle));
4784+ _last_error_message.append(drizzle_error(_drizzle));
4785 errmsg_printf(error::ERROR, _("%s"), _last_error_message.c_str());
4786 drizzle_result_free(&result);
4787 return ER_YES;
4788
4789=== modified file 'plugin/slave/queue_producer.h'
4790--- plugin/slave/queue_producer.h 2011-07-06 23:13:00 +0000
4791+++ plugin/slave/queue_producer.h 2011-11-29 23:07:26 +0000
4792@@ -38,6 +38,7 @@
4793 _check_interval(5),
4794 _master_port(3306),
4795 _master_id(0),
4796+ _drizzle(NULL),
4797 _last_return(DRIZZLE_RETURN_OK),
4798 _is_connected(false),
4799 _saved_max_commit_id(0),
4800@@ -123,8 +124,8 @@
4801
4802 uint32_t _master_id;
4803
4804- drizzle_st _drizzle;
4805- drizzle_con_st _connection;
4806+ drizzle_st *_drizzle;
4807+ drizzle_con_st *_connection;
4808 drizzle_return_t _last_return;
4809
4810 bool _is_connected;
4811
4812=== modified file 'plugin/transaction_log/utilities/transaction_log_connection.cc'
4813--- plugin/transaction_log/utilities/transaction_log_connection.cc 2011-03-18 06:14:52 +0000
4814+++ plugin/transaction_log/utilities/transaction_log_connection.cc 2011-11-29 23:07:26 +0000
4815@@ -18,31 +18,44 @@
4816 */
4817
4818 #include <config.h>
4819-#include "transaction_log_connection.h"
4820+#include <plugin/transaction_log/utilities/transaction_log_connection.h>
4821 #include <iostream>
4822
4823 using namespace std;
4824
4825 TransactionLogConnection::TransactionLogConnection(string &host, uint16_t port,
4826 string &username, string &password,
4827- bool drizzle_protocol)
4828- :
4829- hostName(host),
4830- drizzleProtocol(drizzle_protocol)
4831+ bool drizzle_protocol) :
4832+ hostName(host),
4833+ drizzleProtocol(drizzle_protocol)
4834 {
4835- drizzle_return_t ret;
4836-
4837 if (host.empty())
4838+ {
4839 host= "localhost";
4840-
4841- drizzle_create(&drizzle);
4842- drizzle_con_create(&drizzle, &connection);
4843- drizzle_con_set_tcp(&connection, (char *)host.c_str(), port);
4844- drizzle_con_set_auth(&connection, (char *)username.c_str(),
4845- (char *)password.c_str());
4846- drizzle_con_add_options(&connection,
4847- drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);
4848- ret= drizzle_con_connect(&connection);
4849+ }
4850+
4851+ drizzle= drizzle_create();
4852+
4853+ if (drizzle == NULL)
4854+ {
4855+ errorHandler(NULL, DRIZZLE_RETURN_MEMORY, "drizzle_create() failed");
4856+ throw "drizzle_create() failed";
4857+ }
4858+
4859+ connection= drizzle_con_create(drizzle);
4860+ if (connection == NULL)
4861+ {
4862+ errorHandler(NULL, DRIZZLE_RETURN_MEMORY, "drizzle_create() failed");
4863+ throw "drizzle_con_create() failed";
4864+ }
4865+ drizzle_con_set_tcp(connection, (char *)host.c_str(), port);
4866+ drizzle_con_set_auth(connection, (char *)username.c_str(), (char *)password.c_str());
4867+
4868+ drizzle_con_add_options(connection,
4869+ drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);
4870+
4871+ drizzle_return_t ret= drizzle_con_connect(connection);
4872+
4873 if (ret != DRIZZLE_RETURN_OK)
4874 {
4875 errorHandler(NULL, ret, "when trying to connect");
4876@@ -54,7 +67,8 @@
4877 drizzle_result_st *result)
4878 {
4879 drizzle_return_t ret;
4880- if (drizzle_query_str(&connection, result, str_query.c_str(), &ret) == NULL ||
4881+
4882+ if (drizzle_query_str(connection, result, str_query.c_str(), &ret) == NULL ||
4883 ret != DRIZZLE_RETURN_OK)
4884 {
4885 if (ret == DRIZZLE_RETURN_ERROR_CODE)
4886@@ -66,7 +80,7 @@
4887 else
4888 {
4889 cerr << "Error executing query: " <<
4890- drizzle_con_error(&connection) << endl;
4891+ drizzle_con_error(connection) << endl;
4892 drizzle_result_free(result);
4893 }
4894 return;
4895@@ -75,31 +89,26 @@
4896 if (drizzle_result_buffer(result) != DRIZZLE_RETURN_OK)
4897 {
4898 cerr << "Could not buffer result: " <<
4899- drizzle_con_error(&connection) << endl;
4900+ drizzle_con_error(connection) << endl;
4901 drizzle_result_free(result);
4902 return;
4903 }
4904- return;
4905 }
4906
4907 void TransactionLogConnection::errorHandler(drizzle_result_st *res,
4908- drizzle_return_t ret, const char *when)
4909+ drizzle_return_t ret, const char *when)
4910 {
4911 if (res == NULL)
4912 {
4913- cerr << "Got error: " << drizzle_con_error(&connection) << " "
4914- << when << endl;
4915+ cerr << "Got error: " << drizzle_con_error(connection) << " " << when << endl;
4916 }
4917 else if (ret == DRIZZLE_RETURN_ERROR_CODE)
4918 {
4919- cerr << "Got error: " << drizzle_result_error(res)
4920- << " (" << drizzle_result_error_code(res) << ") " << when << endl;
4921+ cerr << "Got error: " << drizzle_result_error(res) << " (" << drizzle_result_error_code(res) << ") " << when << endl;
4922 drizzle_result_free(res);
4923 }
4924 else
4925 {
4926 cerr << "Got error: " << ret << " " << when << endl;
4927 }
4928-
4929- return;
4930 }
4931
4932=== modified file 'plugin/transaction_log/utilities/transaction_log_connection.h'
4933--- plugin/transaction_log/utilities/transaction_log_connection.h 2011-03-14 05:40:28 +0000
4934+++ plugin/transaction_log/utilities/transaction_log_connection.h 2011-11-29 23:07:26 +0000
4935@@ -38,8 +38,8 @@
4936 void errorHandler(drizzle_result_st *res, drizzle_return_t ret, const char *when);
4937
4938 private:
4939- drizzle_st drizzle;
4940- drizzle_con_st connection;
4941+ drizzle_st *drizzle;
4942+ drizzle_con_st *connection;
4943 std::string hostName;
4944 bool drizzleProtocol;
4945 };
4946
4947=== modified file 'support-files/include.am'
4948--- support-files/include.am 2011-03-22 18:39:54 +0000
4949+++ support-files/include.am 2011-11-29 23:07:26 +0000
4950@@ -26,5 +26,5 @@
4951 pkgconfigdir= $(libdir)/pkgconfig
4952 pkgconfig_DATA= \
4953 support-files/drizzle7.pc \
4954- support-files/libdrizzle-1.0.pc \
4955- support-files/libdrizzle-2.0.pc
4956+ support-files/libdrizzle-1.0.pc
4957+# support-files/libdrizzle-2.0.pc