Drizzle Client & Protocol Library

Merge lp:~brianaker/libdrizzle/non-block-fix into lp:libdrizzle

  1. non-block-fix
  2. Merge into libdrizzle-redux
Proposed by Brian Aker
Status: Merged
Approved by: Andrew Hutchings
Approved revision: 73
Merged at revision: 73
Proposed branch: lp:~brianaker/libdrizzle/non-block-fix
Merge into: lp:libdrizzle
Diff against target: 1377 lines (+515/-367)
20 files modified
libdrizzle-5.1/constants.h (+2/-1)
libdrizzle-5.1/drizzle.h (+8/-0)
libdrizzle-5.1/error.h (+1/-1)
libdrizzle-5.1/include.am (+0/-1)
libdrizzle-5.1/structs.h (+0/-17)
libdrizzle/common.h (+6/-6)
libdrizzle/conn.cc (+245/-179)
libdrizzle/datetime.h (+52/-0)
libdrizzle/drizzle.cc (+6/-7)
libdrizzle/include.am (+2/-0)
libdrizzle/pack.h (+3/-10)
libdrizzle/structs.h (+5/-0)
tests/unit/binlog.c (+12/-8)
tests/unit/column.c (+24/-10)
tests/unit/connect.c (+14/-15)
tests/unit/insert_id.c (+21/-5)
tests/unit/query.c (+27/-22)
tests/unit/row.c (+27/-22)
tests/unit/statement.c (+33/-41)
tests/unit/unbuffered_query.c (+27/-22)
To merge this branch: bzr merge lp:~brianaker/libdrizzle/non-block-fix
Reviewer Review Type Date Requested Status
Andrew Hutchings Approve
Review via email: mp+141474@code.launchpad.net

Description of the change

This updates more of the tests to yatl lite. If MySQL or Drizzle are available it will use them.

This also solves many corner cases around NON Block. We still hit recv() too often.

pack functions and the datetime structure are now private.

To post a comment you must log in.
Revision history for this message
Andrew Hutchings (linuxjedi) wrote :

Currently the user needs the public date/time struct. But I've figured out a way of doing that much better. So Approve! many thanks for this :)

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'libdrizzle-5.1/constants.h'
2--- libdrizzle-5.1/constants.h 2012-12-29 21:44:53 +0000
3+++ libdrizzle-5.1/constants.h 2012-12-30 02:26:20 +0000
4@@ -61,8 +61,10 @@
5 #define DRIZZLE_DEFAULT_TCP_HOST "localhost"
6 #define DRIZZLE_DEFAULT_TCP_PORT 3306
7 #define DRIZZLE_MYSQL_TCP_PORT 3306
8+#define DRIZZLE_MYSQL_TCP_SERVICE "mysql"
9 #define DRIZZLE_DRIZZLE_TCP_PORT 4427
10 #define DRIZZLE_DEFAULT_TCP_SERVICE "mysql"
11+#define DRIZZLE_DRIZZLE_TCP_SERVICE "drizzle"
12 #define DRIZZLE_DEFAULT_UDS "/tmp/mysql.sock"
13 #define DRIZZLE_DEFAULT_BACKLOG 64
14 #define DRIZZLE_MAX_ERROR_SIZE 2048
15@@ -594,7 +596,6 @@
16 typedef struct drizzle_binlog_st drizzle_binlog_st;
17 typedef struct drizzle_stmt_st drizzle_stmt_st;
18 typedef struct drizzle_bind_st drizzle_bind_st;
19-typedef struct drizzle_datetime_st drizzle_datetime_st;
20 typedef char *drizzle_field_t;
21 typedef drizzle_field_t *drizzle_row_t;
22
23
24=== modified file 'libdrizzle-5.1/drizzle.h'
25--- libdrizzle-5.1/drizzle.h 2012-12-24 10:20:04 +0000
26+++ libdrizzle-5.1/drizzle.h 2012-12-30 02:26:20 +0000
27@@ -256,6 +256,14 @@
28
29 /** @} */
30
31+#include <stdio.h>
32+static inline void drizzle_stderr_logger(const char *line, drizzle_verbose_t verbose, void *context)
33+{
34+ (void)context;
35+ fprintf(stderr, "__LOG: %s: %s\n", drizzle_verbose_name(verbose), line);
36+}
37+
38+
39 #ifdef __cplusplus
40 }
41 #endif
42
43=== modified file 'libdrizzle-5.1/error.h'
44--- libdrizzle-5.1/error.h 2012-12-18 11:36:28 +0000
45+++ libdrizzle-5.1/error.h 2012-12-30 02:26:20 +0000
46@@ -1,7 +1,7 @@
47 /*
48 * Drizzle Client & Protocol Library
49 *
50- * Copyright (C) 2012 Brian Aker (brian@tangent.org)
51+ * Copyright (C) 2012 Drizzle Developer Group
52 * All rights reserved.
53 *
54 * Redistribution and use in source and binary forms, with or without
55
56=== modified file 'libdrizzle-5.1/include.am'
57--- libdrizzle-5.1/include.am 2012-12-24 10:20:04 +0000
58+++ libdrizzle-5.1/include.am 2012-12-30 02:26:20 +0000
59@@ -15,7 +15,6 @@
60 nobase_include_HEADERS+= libdrizzle-5.1/field_client.h
61 nobase_include_HEADERS+= libdrizzle-5.1/handshake_client.h
62 nobase_include_HEADERS+= libdrizzle-5.1/libdrizzle.h
63-nobase_include_HEADERS+= libdrizzle-5.1/pack.h
64 nobase_include_HEADERS+= libdrizzle-5.1/query.h
65 nobase_include_HEADERS+= libdrizzle-5.1/result.h
66 nobase_include_HEADERS+= libdrizzle-5.1/result_client.h
67
68=== modified file 'libdrizzle-5.1/structs.h'
69--- libdrizzle-5.1/structs.h 2012-12-23 01:05:57 +0000
70+++ libdrizzle-5.1/structs.h 2012-12-30 02:26:20 +0000
71@@ -47,21 +47,4 @@
72 struct drizzle_column_st;
73 struct drizzle_stmt_st;
74 struct drizzle_bind_st;
75-struct drizzle_datetime_st;
76 #endif
77-
78-/* These types may seem strange but they are defined this way in the MySQL
79- * * protocol
80- * */
81-struct drizzle_datetime_st
82-{
83- uint16_t year;
84- uint8_t month;
85- uint32_t day;
86- uint16_t hour;
87- uint8_t minute;
88- uint8_t second;
89- uint32_t microsecond;
90- bool negative;
91-};
92-
93
94=== modified file 'libdrizzle/common.h'
95--- libdrizzle/common.h 2012-12-24 10:20:04 +0000
96+++ libdrizzle/common.h 2012-12-30 02:26:20 +0000
97@@ -62,11 +62,11 @@
98 #include <string.h>
99 #include <signal.h>
100
101-#include <libdrizzle/structs.h>
102-#include <libdrizzle/drizzle_local.h>
103-#include <libdrizzle/conn_local.h>
104-#include <libdrizzle-5.1/pack.h>
105-#include <libdrizzle/state.h>
106-#include <libdrizzle/sha1.h>
107+#include "libdrizzle/structs.h"
108+#include "libdrizzle/drizzle_local.h"
109+#include "libdrizzle/conn_local.h"
110+#include "libdrizzle/pack.h"
111+#include "libdrizzle/state.h"
112+#include "libdrizzle/sha1.h"
113
114 #include <memory.h>
115
116=== modified file 'libdrizzle/conn.cc'
117--- libdrizzle/conn.cc 2012-12-22 13:07:06 +0000
118+++ libdrizzle/conn.cc 2012-12-30 02:26:20 +0000
119@@ -63,19 +63,41 @@
120 */
121 static drizzle_return_t _setsockopt(drizzle_st *con);
122
123+static void __closesocket(int& fd)
124+{
125+ if (fd != -1)
126+ {
127+ (void)shutdown(fd, SHUT_RDWR);
128+ (void)closesocket(fd);
129+ fd= -1;
130+ }
131+}
132+
133 static bool connect_poll(drizzle_st *con)
134 {
135 struct pollfd fds[1];
136 fds[0].fd= con->fd;
137- fds[0].events= POLLOUT;
138+ fds[0].events= POLLIN;
139
140- size_t loop_max= 5;
141+ size_t loop_max= 5; // This should only be used for EINTR
142 while (--loop_max) // Should only loop on cases of ERESTART or EINTR
143 {
144 int error= poll(fds, 1, con->timeout);
145- switch (error)
146+ if (error == 1)
147 {
148- case 1:
149+ if (fds[0].revents & (POLLIN))
150+ {
151+ drizzle_log_crazy(con, "poll(POLLIN)");
152+ return true;
153+ }
154+
155+ if (fds[0].revents & (POLLOUT))
156+ {
157+ drizzle_log_crazy(con, "poll(POLLOUT)");
158+ return true;
159+ }
160+
161+ if (fds[0].revents & (POLLERR | POLLHUP | POLLNVAL))
162 {
163 int err;
164 socklen_t len= sizeof (err);
165@@ -89,53 +111,48 @@
166 return true;
167 }
168 errno= err;
169+ perror("poll()");
170 }
171
172 // "getsockopt() failed"
173 return false;
174 }
175
176- case 0:
177- {
178- // "timeout occurred while trying to connect"
179- return false;
180- }
181-
182- default: // A real error occurred and we need to completely bail
183- switch (get_socket_errno())
184- {
185+ assert(0);
186+
187+ return false;
188+ }
189+ else if (error == 0)
190+ {
191+ // "timeout occurred while trying to connect"
192+ drizzle_log_crazy(con, "poll(TIMEOUT) %d", con->timeout);
193+ return false;
194+ }
195+
196+ perror("poll2()");
197+ switch (get_socket_errno())
198+ {
199 #ifdef TARGET_OS_LINUX
200- case ERESTART:
201+ case ERESTART:
202 #endif
203- case EINTR:
204- continue;
205-
206- case EFAULT:
207- case ENOMEM:
208- // "poll() failure"
209- return false;
210-
211- case EINVAL:
212- // "RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid"
213- return false;
214-
215- default: // This should not happen
216- if (fds[0].revents & POLLERR)
217- {
218- int err;
219- socklen_t len= sizeof (err);
220- (void)getsockopt(con->fd, SOL_SOCKET, SO_ERROR, &err, &len);
221- errno= err;
222- }
223- else
224- {
225- errno= get_socket_errno();
226- }
227-
228- //"socket error occurred");
229- return false;
230- }
231+ case EINTR:
232+ continue;
233+
234+ case EFAULT:
235+ case ENOMEM:
236+ // "poll() failure"
237+ break;
238+
239+ case EINVAL:
240+ // "RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid"
241+ break;
242+
243+ default:
244+ break;
245 }
246+
247+ //"socket error occurred");
248+ return false;
249 }
250
251 // This should only be possible from ERESTART or EINTR;
252@@ -171,8 +188,7 @@
253 return;
254 }
255
256- (void)closesocket(con->fd);
257- con->fd= -1;
258+ __closesocket(con->fd);
259
260 con->options = (drizzle_options_t)((int)con->options & (int)~DRIZZLE_CON_READY);
261 con->packet_number= 0;
262@@ -585,13 +601,25 @@
263
264 drizzle_return_t drizzle_quit(drizzle_st *con)
265 {
266- drizzle_return_t ret;
267- drizzle_result_st *result;
268- result= drizzle_command_write(con, NULL, DRIZZLE_COMMAND_QUIT, NULL, 0,
269- 0, &ret);
270- drizzle_result_free(result);
271- drizzle_free(con);
272- return ret;
273+ if (con)
274+ {
275+ drizzle_log_crazy(con, "shutting down the connection");
276+ con->flags.is_shutdown= true;
277+ drizzle_return_t ret;
278+ drizzle_result_st *result;
279+ result= drizzle_command_write(con, NULL, DRIZZLE_COMMAND_QUIT, NULL, 0, 0, &ret);
280+ drizzle_result_free(result);
281+ drizzle_free(con);
282+
283+ if (ret == DRIZZLE_RETURN_LOST_CONNECTION)
284+ {
285+ return DRIZZLE_RETURN_OK;
286+ }
287+
288+ return ret;
289+ }
290+
291+ return DRIZZLE_RETURN_INVALID_ARGUMENT;
292 }
293
294 drizzle_result_st *drizzle_select_db(drizzle_st *con,
295@@ -774,7 +802,6 @@
296 const char *host;
297 char port[NI_MAXSERV];
298 struct addrinfo ai;
299- int ret;
300
301 if (con == NULL)
302 {
303@@ -786,47 +813,49 @@
304 switch (con->socket_type)
305 {
306 case DRIZZLE_CON_SOCKET_TCP:
307- tcp= &(con->socket.tcp);
308-
309- if (tcp->addrinfo != NULL)
310- {
311- freeaddrinfo(tcp->addrinfo);
312- tcp->addrinfo= NULL;
313- }
314-
315- if (tcp->port != 0)
316- {
317- snprintf(port, NI_MAXSERV, "%u", tcp->port);
318- }
319- else
320- {
321- snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT);
322- }
323- port[NI_MAXSERV-1]= 0;
324-
325- memset(&ai, 0, sizeof(struct addrinfo));
326- ai.ai_socktype= SOCK_STREAM;
327- ai.ai_protocol= IPPROTO_TCP;
328- ai.ai_flags = AI_PASSIVE;
329- ai.ai_family = AF_UNSPEC;
330-
331- if (tcp->host == NULL)
332- {
333- host= DRIZZLE_DEFAULT_TCP_HOST;
334- }
335- else
336- {
337- host= tcp->host;
338- }
339-
340- ret= getaddrinfo(host, port, &ai, &(tcp->addrinfo));
341- if (ret != 0)
342- {
343- drizzle_set_error(con, "drizzle_state_addrinfo", "getaddrinfo:%s", gai_strerror(ret));
344- return DRIZZLE_RETURN_GETADDRINFO;
345- }
346-
347- con->addrinfo_next= tcp->addrinfo;
348+ {
349+ tcp= &(con->socket.tcp);
350+
351+ if (tcp->addrinfo != NULL)
352+ {
353+ freeaddrinfo(tcp->addrinfo);
354+ tcp->addrinfo= NULL;
355+ }
356+
357+ if (tcp->port != 0)
358+ {
359+ snprintf(port, NI_MAXSERV, "%u", tcp->port);
360+ }
361+ else
362+ {
363+ snprintf(port, NI_MAXSERV, "%u", DRIZZLE_DEFAULT_TCP_PORT);
364+ }
365+ port[NI_MAXSERV-1]= 0;
366+
367+ memset(&ai, 0, sizeof(struct addrinfo));
368+ ai.ai_socktype= SOCK_STREAM;
369+ ai.ai_protocol= IPPROTO_TCP;
370+ ai.ai_family= AF_UNSPEC;
371+
372+ if (tcp->host == NULL)
373+ {
374+ host= DRIZZLE_DEFAULT_TCP_HOST;
375+ }
376+ else
377+ {
378+ host= tcp->host;
379+ }
380+
381+ drizzle_log_crazy(con, "host=%s port=%s", host, port);
382+ int ret= getaddrinfo(host, port, &ai, &(tcp->addrinfo));
383+ if (ret != 0)
384+ {
385+ drizzle_set_error(con, "drizzle_state_addrinfo", "getaddrinfo:%s", gai_strerror(ret));
386+ return DRIZZLE_RETURN_GETADDRINFO;
387+ }
388+
389+ con->addrinfo_next= tcp->addrinfo;
390+ }
391
392 break;
393
394@@ -850,11 +879,7 @@
395
396 drizzle_log_debug(con, "drizzle_state_connect");
397
398- if (con->fd != -1)
399- {
400- (void)closesocket(con->fd);
401- con->fd= -1;
402- }
403+ __closesocket(con->fd);
404
405 if (con->socket_type == DRIZZLE_CON_SOCKET_UDS)
406 {
407@@ -927,9 +952,7 @@
408
409 while (1)
410 {
411- int ret;
412- ret= connect(con->fd, con->addrinfo_next->ai_addr,
413- con->addrinfo_next->ai_addrlen);
414+ int ret= connect(con->fd, con->addrinfo_next->ai_addr, con->addrinfo_next->ai_addrlen);
415
416 #ifdef _WIN32
417 errno = WSAGetLastError();
418@@ -1080,7 +1103,9 @@
419 drizzle_log_debug(con, "drizzle_state_read");
420
421 if (con->buffer_size == 0)
422+ {
423 con->buffer_ptr= con->buffer;
424+ }
425 else if ((con->buffer_ptr - con->buffer) > (DRIZZLE_MAX_BUFFER_SIZE / 2))
426 {
427 memmove(con->buffer, con->buffer_ptr, con->buffer_size);
428@@ -1095,107 +1120,144 @@
429 * returns EAGAIN. This improves performance. */
430 ret= drizzle_set_events(con, POLLIN);
431 if (ret != DRIZZLE_RETURN_OK)
432+ {
433 return ret;
434+ }
435+
436 return DRIZZLE_RETURN_IO_WAIT;
437 }
438
439 while (1)
440 {
441- size_t available_buffer= (size_t)DRIZZLE_MAX_BUFFER_SIZE -
442- ((size_t)(con->buffer_ptr - con->buffer) + con->buffer_size);
443+ size_t available_buffer= (size_t)DRIZZLE_MAX_BUFFER_SIZE - ((size_t)(con->buffer_ptr - con->buffer) + con->buffer_size);
444+
445 #ifdef USE_OPENSSL
446 if (con->ssl_state == DRIZZLE_SSL_STATE_HANDSHAKE_COMPLETE)
447+ {
448 read_size= SSL_read(con->ssl, (char*)con->buffer_ptr + con->buffer_size, available_buffer);
449+ }
450 else
451 #endif
452+ {
453 read_size= recv(con->fd, (char *)con->buffer_ptr + con->buffer_size, available_buffer, MSG_NOSIGNAL);
454+ }
455 #ifdef _WIN32
456- errno = WSAGetLastError();
457- switch(errno) {
458- case WSAENOTCONN:
459- case WSAEWOULDBLOCK:
460- errno= EAGAIN;
461- break;
462- case WSAEINVAL:
463- case WSAEALREADY:
464- errno= EINPROGRESS;
465- break;
466- case WSAECONNREFUSED:
467- errno= ECONNREFUSED;
468- break;
469- case WSAENETUNREACH:
470- errno= ENETUNREACH;
471- break;
472- case WSAETIMEDOUT:
473- errno= ETIMEDOUT;
474- break;
475- case WSAECONNRESET:
476- errno= ECONNRESET;
477- break;
478- case WSAEADDRINUSE:
479- errno= EADDRINUSE;
480- break;
481- case WSAEOPNOTSUPP:
482- errno= EOPNOTSUPP;
483- break;
484- case WSAENOPROTOOPT:
485- errno= ENOPROTOOPT;
486- break;
487- default:
488- break;
489+ if (_WIN32)
490+ {
491+ errno= WSAGetLastError();
492+ switch (errno)
493+ {
494+ case WSAENOTCONN:
495+ case WSAEWOULDBLOCK:
496+ errno= EAGAIN;
497+ break;
498+ case WSAEINVAL:
499+ case WSAEALREADY:
500+ errno= EINPROGRESS;
501+ break;
502+ case WSAECONNREFUSED:
503+ errno= ECONNREFUSED;
504+ break;
505+ case WSAENETUNREACH:
506+ errno= ENETUNREACH;
507+ break;
508+ case WSAETIMEDOUT:
509+ errno= ETIMEDOUT;
510+ break;
511+ case WSAECONNRESET:
512+ errno= ECONNRESET;
513+ break;
514+ case WSAEADDRINUSE:
515+ errno= EADDRINUSE;
516+ break;
517+ case WSAEOPNOTSUPP:
518+ errno= EOPNOTSUPP;
519+ break;
520+ case WSAENOPROTOOPT:
521+ errno= ENOPROTOOPT;
522+ break;
523+ default:
524+ break;
525+ }
526 }
527 #endif /* _WIN32 */
528- drizzle_log_crazy(con, "read fd=%d return=%zd ssl= %d errno=%s",
529+
530+ drizzle_log_crazy(con, "read fd=%d recv=%zd ssl= %d errno=%s",
531 con->fd, read_size,
532 (con->ssl_state == DRIZZLE_SSL_STATE_HANDSHAKE_COMPLETE) ? 1 : 0,
533 strerror(errno));
534
535 if (read_size == 0)
536 {
537- drizzle_set_error(con, __func__,
538- "%s:%d lost connection to server (EOF)", __FILE__, __LINE__);
539+ if (con->flags.is_shutdown == false)
540+ {
541+ drizzle_set_error(con, __func__,
542+ "%s:%d lost connection to server (EOF)", __FILE__, __LINE__);
543+ }
544+
545 return DRIZZLE_RETURN_LOST_CONNECTION;
546 }
547 else if (read_size == -1)
548 {
549- if (errno == EAGAIN)
550- {
551- /* clear the read ready flag */
552- con->revents&= ~POLLIN;
553- ret= drizzle_set_events(con, POLLIN);
554- if (ret != DRIZZLE_RETURN_OK)
555- return ret;
556-
557- if (con->options & DRIZZLE_CON_OPTIONS_NON_BLOCKING)
558- return DRIZZLE_RETURN_IO_WAIT;
559-
560- ret= drizzle_wait(con);
561- if (ret != DRIZZLE_RETURN_OK)
562- return ret;
563-
564- continue;
565- }
566- else if (errno == ECONNREFUSED)
567- {
568- con->revents= 0;
569- drizzle_state_pop(con);
570- drizzle_state_push(con, drizzle_state_connect);
571- con->addrinfo_next= con->addrinfo_next->ai_next;
572- return DRIZZLE_RETURN_OK;
573- }
574- else if (errno == EINTR)
575- {
576- continue;
577- }
578- else if (errno == EPIPE || errno == ECONNRESET)
579- {
580- drizzle_set_error(con, __func__,
581- "%s:%d lost connection to server (%s)",
582- __FILE__, __LINE__, strerror(errno));
583- return DRIZZLE_RETURN_LOST_CONNECTION;
584- }
585-
586- drizzle_set_error(con, __func__, "read:%s", strerror(errno));
587+ // switch (get_socket_errno())
588+ switch (errno)
589+ {
590+ case EAGAIN:
591+#if EWOULDBLOCK != EAGAIN
592+ case EWOULDBLOCK:
593+#endif
594+ {
595+ /* clear the read ready flag */
596+ con->revents&= ~POLLIN;
597+ ret= drizzle_set_events(con, POLLIN);
598+ if (ret != DRIZZLE_RETURN_OK)
599+ {
600+ return ret;
601+ }
602+
603+ if (con->options & DRIZZLE_CON_OPTIONS_NON_BLOCKING)
604+ {
605+ return DRIZZLE_RETURN_IO_WAIT;
606+ }
607+
608+ ret= drizzle_wait(con);
609+ if (ret != DRIZZLE_RETURN_OK)
610+ {
611+ return ret;
612+ }
613+
614+ continue;
615+ }
616+ case ECONNREFUSED:
617+ {
618+ con->revents= 0;
619+ drizzle_state_pop(con);
620+ drizzle_state_push(con, drizzle_state_connect);
621+ con->addrinfo_next= con->addrinfo_next->ai_next;
622+ return DRIZZLE_RETURN_OK;
623+ }
624+
625+ case EINTR:
626+ continue;
627+
628+ case EINVAL:
629+ {
630+ drizzle_log_crazy(con, "EINVAL fd=%d buffer=%p available_buffer=%zd",
631+ con->fd, (char *)con->buffer_ptr + con->buffer_size, available_buffer);
632+ }
633+ break;
634+
635+ case EPIPE:
636+ case ECONNRESET:
637+ {
638+ drizzle_set_error(con, __func__,
639+ "%s:%d lost connection to server (%s)",
640+ __FILE__, __LINE__, strerror(errno));
641+ return DRIZZLE_RETURN_LOST_CONNECTION;
642+ }
643+ }
644+
645+ drizzle_set_error(con, __func__, "recv:%s", strerror(errno));
646 con->last_errno= errno;
647 return DRIZZLE_RETURN_ERRNO;
648 }
649@@ -1230,10 +1292,14 @@
650 {
651 #ifdef USE_OPENSSL
652 if (con->ssl_state == DRIZZLE_SSL_STATE_HANDSHAKE_COMPLETE)
653+ {
654 write_size= SSL_write(con->ssl, con->buffer_ptr, con->buffer_size);
655+ }
656 else
657 #endif
658- write_size = send(con->fd,(char *) con->buffer_ptr, con->buffer_size, MSG_NOSIGNAL);
659+ {
660+ write_size= send(con->fd,(char *) con->buffer_ptr, con->buffer_size, MSG_NOSIGNAL);
661+ }
662
663 #ifdef _WIN32
664 errno = WSAGetLastError();
665@@ -1313,7 +1379,7 @@
666 return DRIZZLE_RETURN_LOST_CONNECTION;
667 }
668
669- drizzle_set_error(con, "drizzle_state_write", "write:%s", strerror(errno));
670+ drizzle_set_error(con, "drizzle_state_write", "send: %s", strerror(errno));
671 con->last_errno= errno;
672 return DRIZZLE_RETURN_ERRNO;
673 }
674
675=== added file 'libdrizzle/datetime.h'
676--- libdrizzle/datetime.h 1970-01-01 00:00:00 +0000
677+++ libdrizzle/datetime.h 2012-12-30 02:26:20 +0000
678@@ -0,0 +1,52 @@
679+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
680+ *
681+ * Drizzle Client & Protocol Library
682+ *
683+ * Copyright (C) 2012 Drizzle Developer Group
684+ * All rights reserved.
685+ *
686+ * Redistribution and use in source and binary forms, with or without
687+ * modification, are permitted provided that the following conditions are
688+ * met:
689+ *
690+ * * Redistributions of source code must retain the above copyright
691+ * notice, this list of conditions and the following disclaimer.
692+ *
693+ * * Redistributions in binary form must reproduce the above
694+ * copyright notice, this list of conditions and the following disclaimer
695+ * in the documentation and/or other materials provided with the
696+ * distribution.
697+ *
698+ * * The names of its contributors may not be used to endorse or
699+ * promote products derived from this software without specific prior
700+ * written permission.
701+ *
702+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
703+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
704+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
705+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
706+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
707+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
708+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
709+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
710+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
711+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
712+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
713+ *
714+ */
715+
716+#pragma once
717+
718+struct drizzle_datetime_st
719+{
720+ uint16_t year;
721+ uint8_t month;
722+ uint32_t day;
723+ uint16_t hour;
724+ uint8_t minute;
725+ uint8_t second;
726+ uint32_t microsecond;
727+ bool negative;
728+};
729+
730+
731
732=== modified file 'libdrizzle/drizzle.cc'
733--- libdrizzle/drizzle.cc 2012-12-22 13:07:06 +0000
734+++ libdrizzle/drizzle.cc 2012-12-30 02:26:20 +0000
735@@ -174,6 +174,7 @@
736 return NULL;
737 }
738
739+ con->flags.is_shutdown= false;
740 con->options= DRIZZLE_CON_NONE;
741 con->packet_number= 0;
742 con->protocol_version= 0;
743@@ -331,13 +332,11 @@
744 */
745
746 drizzle_st *drizzle_create_tcp(const char *host, in_port_t port,
747- const char *user, const char *password,
748- const char *db,
749- drizzle_options_t options)
750+ const char *user, const char *password,
751+ const char *db,
752+ drizzle_options_t options)
753 {
754- drizzle_st *con;
755-
756- con= drizzle_create();
757+ drizzle_st *con= drizzle_create();
758 if (con == NULL)
759 {
760 return NULL;
761@@ -376,7 +375,7 @@
762 */
763
764 void drizzle_set_error(drizzle_st *con, const char *function,
765- const char *format, ...)
766+ const char *format, ...)
767 {
768 if (con == NULL)
769 {
770
771=== modified file 'libdrizzle/include.am'
772--- libdrizzle/include.am 2012-12-29 17:31:57 +0000
773+++ libdrizzle/include.am 2012-12-30 02:26:20 +0000
774@@ -5,9 +5,11 @@
775 noinst_HEADERS+= libdrizzle/common.h
776 noinst_HEADERS+= libdrizzle/conn_local.h
777 noinst_HEADERS+= libdrizzle/drizzle_local.h
778+noinst_HEADERS+= libdrizzle/pack.h
779 noinst_HEADERS+= libdrizzle/sha1.h
780 noinst_HEADERS+= libdrizzle/state.h
781 noinst_HEADERS+= libdrizzle/structs.h
782+noinst_HEADERS+= libdrizzle/datetime.h
783
784 lib_LTLIBRARIES+= libdrizzle/libdrizzle.la
785 libdrizzle_libdrizzle_la_SOURCES=
786
787=== renamed file 'libdrizzle-5.1/pack.h' => 'libdrizzle/pack.h'
788--- libdrizzle-5.1/pack.h 2012-12-23 01:05:57 +0000
789+++ libdrizzle/pack.h 2012-12-30 02:26:20 +0000
790@@ -57,47 +57,40 @@
791 /**
792 * Pack length-encoded number.
793 */
794-DRIZZLE_API
795+
796 uint8_t *drizzle_pack_length(uint64_t number, uint8_t *ptr);
797
798 /**
799 * Unpack length-encoded number.
800 */
801-DRIZZLE_API
802+
803 uint64_t drizzle_unpack_length(drizzle_st *con, drizzle_return_t *ret_ptr);
804
805 /**
806 * Pack length-encoded string.
807 */
808-DRIZZLE_API
809+
810 uint8_t *drizzle_pack_string(char *string, uint8_t *ptr);
811
812-DRIZZLE_API
813 uint8_t *drizzle_pack_binary(uint8_t *data, size_t len, uint8_t *ptr);
814
815-DRIZZLE_API
816 uint8_t *drizzle_pack_time(drizzle_datetime_st *time, uint8_t *ptr);
817
818-DRIZZLE_API
819 uint8_t *drizzle_pack_datetime(drizzle_datetime_st *datetime, uint8_t *ptr);
820
821-DRIZZLE_API
822 void drizzle_unpack_time(drizzle_field_t field, size_t length, uint8_t *data);
823
824-DRIZZLE_API
825 void drizzle_unpack_datetime(drizzle_field_t field, size_t length, uint8_t *data);
826
827 /**
828 * Unpack length-encoded string.
829 */
830-DRIZZLE_API
831 drizzle_return_t drizzle_unpack_string(drizzle_st *con, char *buffer,
832 uint64_t max_size);
833
834 /**
835 * Pack user, scramble, and db.
836 */
837-DRIZZLE_API
838 uint8_t *drizzle_pack_auth(drizzle_st *con, uint8_t *ptr,
839 drizzle_return_t *ret_ptr);
840
841
842=== modified file 'libdrizzle/structs.h'
843--- libdrizzle/structs.h 2012-12-29 21:44:53 +0000
844+++ libdrizzle/structs.h 2012-12-30 02:26:20 +0000
845@@ -60,6 +60,8 @@
846 extern "C" {
847 #endif
848
849+#include "libdrizzle/datetime.h"
850+
851 /**
852 * @ingroup drizzle_command
853 * Commands for drizzle_command functions.
854@@ -139,6 +141,9 @@
855 */
856 struct drizzle_st
857 {
858+ struct {
859+ bool is_shutdown;
860+ } flags;
861 uint8_t packet_number;
862 uint8_t protocol_version;
863 uint8_t state_current;
864
865=== modified file 'tests/unit/binlog.c'
866--- tests/unit/binlog.c 2012-12-29 11:43:03 +0000
867+++ tests/unit/binlog.c 2012-12-30 02:26:20 +0000
868@@ -48,20 +48,23 @@
869 {
870 (void) argc;
871 (void) argv;
872- drizzle_result_st *result;
873
874- drizzle_st *con= drizzle_create_tcp("localhost", 3306, "root", "", "", 0);
875+ drizzle_st *con= drizzle_create_tcp("localhost", DRIZZLE_DEFAULT_TCP_PORT, "root", NULL, NULL, 0);
876 ASSERT_NOT_NULL_(con, "Drizzle connection object creation error");
877
878- drizzle_return_t ret = drizzle_connect(con);
879- if (ret != DRIZZLE_RETURN_OK)
880+ drizzle_return_t ret= drizzle_connect(con);
881+ if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT)
882 {
883+ const char *error= drizzle_error(con);
884 drizzle_quit(con);
885- SKIP_IF_(ret != DRIZZLE_RETURN_OK, "Drizzle connection failure");
886+ SKIP_IF_(ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", error, drizzle_strerror(ret));
887 }
888+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s(%s)", drizzle_error(con), drizzle_strerror(ret));
889
890- result= drizzle_start_binlog(con, 0, "", 0, &ret);
891- ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "Drizzle binlog start failure");
892+ drizzle_result_st *result= drizzle_start_binlog(con, 0, "", 0, &ret);
893+ ASSERT_TRUE(result);
894+ SKIP_IF_(ret == DRIZZLE_RETURN_ERROR_CODE, "Binlog is not open?: %s(%s)", drizzle_error(con), drizzle_strerror(ret));
895+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "Drizzle binlog start failure: %s(%s)", drizzle_error(con), drizzle_strerror(ret));
896
897 while (ret == DRIZZLE_RETURN_OK)
898 {
899@@ -84,7 +87,8 @@
900 ASSERT_FALSE_((drizzle_binlog_event_type(result) >= DRIZZLE_EVENT_TYPE_END), "Bad event type: %d", drizzle_binlog_event_type(result));
901 }
902
903- drizzle_quit(con);
904+ ret= drizzle_quit(con);
905+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_strerror(ret));
906
907 return EXIT_SUCCESS;
908 }
909
910=== modified file 'tests/unit/column.c'
911--- tests/unit/column.c 2012-12-29 10:49:09 +0000
912+++ tests/unit/column.c 2012-12-30 02:26:20 +0000
913@@ -46,20 +46,29 @@
914 {
915 (void) argc;
916 (void) argv;
917- drizzle_return_t ret;
918- drizzle_result_st *result;
919 drizzle_row_t row;
920 int num_fields;
921
922- drizzle_st *con= drizzle_create_tcp("localhost", 3306, "root", "", "libdrizzle", 0);
923+ drizzle_st *con= drizzle_create_tcp("localhost", DRIZZLE_DEFAULT_TCP_PORT, "root", NULL, NULL, 0);
924 ASSERT_NOT_NULL_(con, "Drizzle connection object creation error");
925
926- ret = drizzle_connect(con);
927- if (ret != DRIZZLE_RETURN_OK)
928+ drizzle_return_t ret= drizzle_connect(con);
929+ if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT)
930 {
931+ const char *error= drizzle_error(con);
932 drizzle_quit(con);
933- SKIP_IF_(ret != DRIZZLE_RETURN_OK, "Drizzle connection failure");
934+ SKIP_IF_(ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", error, drizzle_strerror(ret));
935 }
936+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s(%s)", drizzle_error(con), strerror(ret));
937+
938+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
939+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
940+
941+ drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
942+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
943+
944+ drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
945+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
946
947 drizzle_query_str(con, "create table libdrizzle.t1 (a int primary key auto_increment, b varchar(255), c timestamp default current_timestamp)", &ret);
948 ASSERT_TRUE_(ret == DRIZZLE_RETURN_OK, "create table libdrizzle.t1 (a int primary key auto_increment, b varchar(255), c timestamp default current_timestamp)");
949@@ -102,9 +111,14 @@
950
951 drizzle_result_free(result);
952
953- drizzle_query_str(con, "drop table libdrizzle.t1", &ret);
954- ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "drop table libdrizzle.t1");
955-
956- drizzle_quit(con);
957+ drizzle_query_str(con, "DROP TABLE libdrizzle.t1", &ret);
958+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP TABLE libdrizzle.t1");
959+
960+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
961+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP SCHEMA libdrizzle (%s)", drizzle_error(con));
962+
963+ ret= drizzle_quit(con);
964+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_strerror(ret));
965+
966 return EXIT_SUCCESS;
967 }
968
969=== modified file 'tests/unit/connect.c'
970--- tests/unit/connect.c 2012-12-29 10:49:09 +0000
971+++ tests/unit/connect.c 2012-12-30 02:26:20 +0000
972@@ -46,22 +46,21 @@
973 {
974 (void) argc;
975 (void) argv;
976- drizzle_st *con;
977- drizzle_return_t ret;
978-
979- con = drizzle_create_tcp("localhost", 3306, "root", "", "", 0);
980- if (con == NULL)
981- {
982- printf("Drizzle connection object creation error\n");
983- return EXIT_FAILURE;
984- }
985- ret = drizzle_connect(con);
986- if (ret != DRIZZLE_RETURN_OK)
987- {
988+
989+ drizzle_st *con= drizzle_create_tcp("localhost", DRIZZLE_DEFAULT_TCP_PORT, "root", NULL, NULL, 0);
990+ ASSERT_NOT_NULL_(con, "Drizzle connection object creation error");
991+
992+ drizzle_return_t ret= drizzle_connect(con);
993+ if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT)
994+ {
995+ const char *error= drizzle_error(con);
996 drizzle_quit(con);
997- SKIP_IF_(ret != DRIZZLE_RETURN_OK, "Drizzle connection failure");
998+ SKIP_IF_(ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", error, drizzle_strerror(ret));
999 }
1000-
1001- drizzle_quit(con);
1002+ ASSERT_EQ(DRIZZLE_RETURN_OK, ret);
1003+
1004+ ret= drizzle_quit(con);
1005+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_strerror(ret));
1006+
1007 return EXIT_SUCCESS;
1008 }
1009
1010=== modified file 'tests/unit/insert_id.c'
1011--- tests/unit/insert_id.c 2012-12-29 10:49:09 +0000
1012+++ tests/unit/insert_id.c 2012-12-30 02:26:20 +0000
1013@@ -48,20 +48,31 @@
1014 (void) argc;
1015 (void) argv;
1016
1017- drizzle_st *con= drizzle_create_tcp("localhost", 3306, "root", "", "libdrizzle", 0);
1018+ drizzle_st *con= drizzle_create_tcp("localhost", DRIZZLE_DEFAULT_TCP_PORT, "root", NULL, NULL, 0);
1019 ASSERT_NOT_NULL_(con, "Drizzle connection object creation error");
1020
1021 drizzle_return_t ret= drizzle_connect(con);
1022- if (ret != DRIZZLE_RETURN_OK)
1023+ if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT)
1024 {
1025+ const char *error= drizzle_error(con);
1026 drizzle_quit(con);
1027- SKIP_IF_(ret != DRIZZLE_RETURN_OK, "Drizzle connection failure");
1028+ SKIP_IF_(ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", error, drizzle_strerror(ret));
1029 }
1030+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_error(con));
1031+
1032+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
1033+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
1034+
1035+ drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
1036+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
1037+
1038+ drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
1039+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
1040
1041 drizzle_query_str(con, "create table libdrizzle.t1 (a int primary key auto_increment, b int)", &ret);
1042 ASSERT_EQ_(ret, DRIZZLE_RETURN_OK, "create table libdrizzle.t1 (a int primary key auto_increment, b int)");
1043
1044- drizzle_result_st *result= drizzle_query_str(con, "insert into libdrizzle.t1 (b) values (1),(2),(3)", &ret);
1045+ result= drizzle_query_str(con, "insert into libdrizzle.t1 (b) values (1),(2),(3)", &ret);
1046 ASSERT_EQ_(ret, DRIZZLE_RETURN_OK, "insert into libdrizzle.t1 (b) values (1),(2),(3)");
1047 ASSERT_TRUE(result);
1048
1049@@ -77,6 +88,11 @@
1050 drizzle_query_str(con, "DROP TABLE libdrizzle.t1", &ret);
1051 ASSERT_EQ_(ret, DRIZZLE_RETURN_OK, "dROP TABLE failure");
1052
1053- drizzle_quit(con);
1054+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
1055+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP SCHEMA libdrizzle (%s)", drizzle_error(con));
1056+
1057+ ret= drizzle_quit(con);
1058+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_strerror(ret));
1059+
1060 return EXIT_SUCCESS;
1061 }
1062
1063=== modified file 'tests/unit/query.c'
1064--- tests/unit/query.c 2012-12-29 10:49:09 +0000
1065+++ tests/unit/query.c 2012-12-30 02:26:20 +0000
1066@@ -46,24 +46,29 @@
1067 {
1068 (void) argc;
1069 (void) argv;
1070- drizzle_st *con;
1071- drizzle_return_t ret;
1072- drizzle_result_st *result;
1073 drizzle_row_t row;
1074 int num_fields;
1075
1076- con = drizzle_create_tcp("localhost", 3306, "root", "", "libdrizzle", 0);
1077- if (con == NULL)
1078- {
1079- printf("Drizzle connection object creation error\n");
1080- return EXIT_FAILURE;
1081- }
1082- ret = drizzle_connect(con);
1083- if (ret != DRIZZLE_RETURN_OK)
1084- {
1085+ drizzle_st *con= drizzle_create_tcp("localhost", DRIZZLE_DEFAULT_TCP_PORT, "root", NULL, NULL, 0);
1086+ ASSERT_NOT_NULL_(con, "Drizzle connection object creation error");
1087+
1088+ drizzle_return_t ret= drizzle_connect(con);
1089+ if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT)
1090+ {
1091+ const char *error= drizzle_error(con);
1092 drizzle_quit(con);
1093- SKIP_IF_(ret != DRIZZLE_RETURN_OK, "Drizzle connection failure");
1094+ SKIP_IF_(ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", error, drizzle_strerror(ret));
1095 }
1096+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "drizzle_connect(): %s(%s)", drizzle_error(con), drizzle_strerror(ret));
1097+
1098+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
1099+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
1100+
1101+ drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
1102+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
1103+
1104+ drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
1105+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
1106
1107 drizzle_query_str(con, "create table libdrizzle.t1 (a int)", &ret);
1108 if (ret != DRIZZLE_RETURN_OK)
1109@@ -114,14 +119,14 @@
1110
1111 drizzle_result_free(result);
1112
1113- drizzle_query_str(con, "drop table libdrizzle.t1", &ret);
1114- if (ret != DRIZZLE_RETURN_OK)
1115- {
1116- printf("Drop table failure\n");
1117- return EXIT_FAILURE;
1118- }
1119-
1120-
1121- drizzle_quit(con);
1122+ drizzle_query_str(con, "DROP TABLE libdrizzle.t1", &ret);
1123+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP TABLE libdrizzle.t1");
1124+
1125+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
1126+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP SCHEMA libdrizzle (%s)", drizzle_error(con));
1127+
1128+ ret= drizzle_quit(con);
1129+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_strerror(ret));
1130+
1131 return EXIT_SUCCESS;
1132 }
1133
1134=== modified file 'tests/unit/row.c'
1135--- tests/unit/row.c 2012-12-29 10:49:09 +0000
1136+++ tests/unit/row.c 2012-12-30 02:26:20 +0000
1137@@ -46,24 +46,29 @@
1138 {
1139 (void) argc;
1140 (void) argv;
1141- drizzle_st *con;
1142- drizzle_return_t ret;
1143- drizzle_result_st *result;
1144 drizzle_row_t row;
1145 int num_fields;
1146
1147- con = drizzle_create_tcp("localhost", 3306, "root", "", "libdrizzle", 0);
1148- if (con == NULL)
1149- {
1150- printf("Drizzle connection object creation error\n");
1151- return EXIT_FAILURE;
1152- }
1153- ret = drizzle_connect(con);
1154- if (ret != DRIZZLE_RETURN_OK)
1155- {
1156+ drizzle_st *con= drizzle_create_tcp("localhost", DRIZZLE_DEFAULT_TCP_PORT, "root", NULL, NULL, 0);
1157+ ASSERT_NOT_NULL_(con, "Drizzle connection object creation error");
1158+
1159+ drizzle_return_t ret= drizzle_connect(con);
1160+ if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT)
1161+ {
1162+ const char *error= drizzle_error(con);
1163 drizzle_quit(con);
1164- SKIP_IF_(ret != DRIZZLE_RETURN_OK, "Drizzle connection failure");
1165+ SKIP_IF_(ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", error, drizzle_strerror(ret));
1166 }
1167+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "drizzle_connect(): %s(%s)", drizzle_error(con), drizzle_strerror(ret));
1168+
1169+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
1170+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
1171+
1172+ drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
1173+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
1174+
1175+ drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
1176+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
1177
1178 drizzle_query_str(con, "create table libdrizzle.t1 (a int)", &ret);
1179 if (ret != DRIZZLE_RETURN_OK)
1180@@ -142,14 +147,14 @@
1181
1182 drizzle_result_free(result);
1183
1184- drizzle_query_str(con, "drop table libdrizzle.t1", &ret);
1185- if (ret != DRIZZLE_RETURN_OK)
1186- {
1187- printf("Drop table failure\n");
1188- return EXIT_FAILURE;
1189- }
1190-
1191-
1192- drizzle_quit(con);
1193+ drizzle_query_str(con, "DROP TABLE libdrizzle.t1", &ret);
1194+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP TABLE libdrizzle.t1");
1195+
1196+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
1197+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP SCHEMA libdrizzle (%s)", drizzle_error(con));
1198+
1199+ ret= drizzle_quit(con);
1200+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_strerror(ret));
1201+
1202 return EXIT_SUCCESS;
1203 }
1204
1205=== modified file 'tests/unit/statement.c'
1206--- tests/unit/statement.c 2012-12-29 10:49:09 +0000
1207+++ tests/unit/statement.c 2012-12-30 02:26:20 +0000
1208@@ -49,50 +49,42 @@
1209 {
1210 (void) argc;
1211 (void) argv;
1212- drizzle_st *con;
1213- drizzle_return_t ret;
1214 drizzle_stmt_st *stmt;
1215
1216- con = drizzle_create_tcp("localhost", 3306, "root", "", "libdrizzle", 0);
1217- if (con == NULL)
1218- {
1219- printf("Drizzle connection object creation error\n");
1220- return EXIT_FAILURE;
1221- }
1222- ret = drizzle_connect(con);
1223- if (ret != DRIZZLE_RETURN_OK)
1224- {
1225+ drizzle_st *con= drizzle_create_tcp("localhost", DRIZZLE_DEFAULT_TCP_PORT, "root", NULL, NULL, 0);
1226+ ASSERT_NOT_NULL_(con, "Drizzle connection object creation error");
1227+
1228+ drizzle_return_t ret= drizzle_connect(con);
1229+ if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT)
1230+ {
1231+ const char *error= drizzle_error(con);
1232 drizzle_quit(con);
1233- SKIP_IF_(ret != DRIZZLE_RETURN_OK, "Drizzle connection failure");
1234+ SKIP_IF_(ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", error, drizzle_strerror(ret));
1235 }
1236+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "drizzle_connect(): %s(%s)", drizzle_error(con), drizzle_strerror(ret));
1237+
1238+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
1239+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
1240+
1241+ drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
1242+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
1243+
1244+ drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
1245+ ASSERT_TRUE(result);
1246+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
1247
1248 drizzle_query_str(con, "create table libdrizzle.t1 (a int)", &ret);
1249- if (ret != DRIZZLE_RETURN_OK)
1250- {
1251- printf("Create table failure\n");
1252- return EXIT_FAILURE;
1253- }
1254+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "create table libdrizzle.t1 (a int): %s", drizzle_error(con));
1255
1256 drizzle_query_str(con, "insert into libdrizzle.t1 values (1),(2),(3)", &ret);
1257- if (ret != DRIZZLE_RETURN_OK)
1258- {
1259- printf("Insert failure\n");
1260- return EXIT_FAILURE;
1261- }
1262+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_error(con));
1263
1264 const char *query= "select * from libdrizzle.t1 where a > ?";
1265 stmt= drizzle_stmt_prepare(con, query, strlen(query), &ret);
1266- if (ret != DRIZZLE_RETURN_OK)
1267- {
1268- printf("Prepare failure\n");
1269- return EXIT_FAILURE;
1270- }
1271+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_error(con));
1272+
1273 /* Query should have 1 param */
1274- if (drizzle_stmt_param_count(stmt) != 1)
1275- {
1276- printf("Retrieved bad param count\n");
1277- return EXIT_FAILURE;
1278- }
1279+ ASSERT_EQ_(1, drizzle_stmt_param_count(stmt), "Retrieved bad param count");
1280
1281 uint32_t val= 1;
1282 ret = drizzle_stmt_bind_param(stmt, 0, DRIZZLE_COLUMN_TYPE_LONG, &val, 4, DRIZZLE_BIND_OPTION_NONE);
1283@@ -145,14 +137,14 @@
1284 return EXIT_FAILURE;
1285 }
1286
1287- drizzle_query_str(con, "drop table libdrizzle.t1", &ret);
1288- if (ret != DRIZZLE_RETURN_OK)
1289- {
1290- printf("Drop table failure\n");
1291- return EXIT_FAILURE;
1292- }
1293-
1294-
1295- drizzle_quit(con);
1296+ drizzle_query_str(con, "DROP TABLE libdrizzle.t1", &ret);
1297+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP TABLE libdrizzle.t1");
1298+
1299+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
1300+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP SCHEMA libdrizzle (%s)", drizzle_error(con));
1301+
1302+ ret= drizzle_quit(con);
1303+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_strerror(ret));
1304+
1305 return EXIT_SUCCESS;
1306 }
1307
1308=== modified file 'tests/unit/unbuffered_query.c'
1309--- tests/unit/unbuffered_query.c 2012-12-29 10:49:09 +0000
1310+++ tests/unit/unbuffered_query.c 2012-12-30 02:26:20 +0000
1311@@ -46,24 +46,29 @@
1312 {
1313 (void) argc;
1314 (void) argv;
1315- drizzle_st *con;
1316- drizzle_return_t ret;
1317- drizzle_result_st *result;
1318 drizzle_row_t row;
1319 int num_fields;
1320
1321- con = drizzle_create_tcp("localhost", 3306, "root", "", "libdrizzle", 0);
1322- if (con == NULL)
1323- {
1324- printf("Drizzle connection object creation error\n");
1325- return EXIT_FAILURE;
1326- }
1327- ret = drizzle_connect(con);
1328- if (ret != DRIZZLE_RETURN_OK)
1329- {
1330+ drizzle_st *con= drizzle_create_tcp("localhost", DRIZZLE_DEFAULT_TCP_PORT, "root", NULL, NULL, 0);
1331+ ASSERT_NOT_NULL_(con, "Drizzle connection object creation error");
1332+
1333+ drizzle_return_t ret= drizzle_connect(con);
1334+ if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT)
1335+ {
1336+ const char *error= drizzle_error(con);
1337 drizzle_quit(con);
1338- SKIP_IF_(ret != DRIZZLE_RETURN_OK, "Drizzle connection failure");
1339+ SKIP_IF_(ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", error, drizzle_strerror(ret));
1340 }
1341+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "drizzle_connect(): %s(%s)", drizzle_error(con), drizzle_strerror(ret));
1342+
1343+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
1344+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
1345+
1346+ drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
1347+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
1348+
1349+ drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
1350+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
1351
1352 drizzle_query_str(con, "create table libdrizzle.t1 (a int)", &ret);
1353 if (ret != DRIZZLE_RETURN_OK)
1354@@ -132,14 +137,14 @@
1355
1356 drizzle_result_free(result);
1357
1358- drizzle_query_str(con, "drop table libdrizzle.t1", &ret);
1359- if (ret != DRIZZLE_RETURN_OK)
1360- {
1361- printf("Drop table failure\n");
1362- return EXIT_FAILURE;
1363- }
1364-
1365-
1366- drizzle_quit(con);
1367+ drizzle_query_str(con, "DROP TABLE libdrizzle.t1", &ret);
1368+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP TABLE libdrizzle.t1");
1369+
1370+ drizzle_query_str(con, "DROP SCHEMA IF EXISTS libdrizzle", &ret);
1371+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "DROP SCHEMA libdrizzle (%s)", drizzle_error(con));
1372+
1373+ ret= drizzle_quit(con);
1374+ ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s", drizzle_strerror(ret));
1375+
1376 return EXIT_SUCCESS;
1377 }

Subscribers

People subscribed via source and target branches

to all changes:
to status/vote changes: