Line data Source code
1 : #include "common.h"
2 :
3 : static char software_version[] = "$Id: done_handling.c,v 1.11 2010-09-22 07:03:59 freddy77 Exp $";
4 : static void *no_unused_var_warn[] = { software_version, no_unused_var_warn };
5 :
6 : /*
7 : * This test try do discovery how dblib process token looking for state
8 : * at every iteration. It issue a query to server and check
9 : * - row count (valid number means DONE processed)
10 : * - if possible to send another query (means state IDLE)
11 : * - if error readed (means ERROR token readed)
12 : * - if status present (PARAMRESULT token readed)
13 : * - if parameter present (PARAM token readed)
14 : * It try these query types:
15 : * - normal row
16 : * - normal row with no count
17 : * - normal row without rows
18 : * - error query
19 : * - store procedure call with output parameters
20 : */
21 :
22 : /* Forward declarations of the error handler and message handler. */
23 : static int err_handler(DBPROCESS * dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr);
24 : static int msg_handler(DBPROCESS * dbproc, DBINT msgno, int msgstate, int severity, char *msgtext, char *srvname, char *procname,
25 : int line);
26 :
27 : static DBPROCESS *dbproc;
28 : static int silent = 0;
29 : static int check_idle = 0;
30 :
31 : /* print functions adapted from src/dblib/dblib.c */
32 : static const char *
33 204 : prdbretcode(int retcode)
34 : {
35 : static char unknown[24];
36 204 : switch(retcode) {
37 : case REG_ROW: return "REG_ROW/MORE_ROWS";
38 172 : case NO_MORE_ROWS: return "NO_MORE_ROWS";
39 0 : case BUF_FULL: return "BUF_FULL";
40 0 : case NO_MORE_RESULTS: return "NO_MORE_RESULTS";
41 0 : case SUCCEED: return "SUCCEED";
42 0 : case FAIL: return "FAIL";
43 0 : default:
44 0 : sprintf(unknown, "oops: %u ??", retcode);
45 : }
46 0 : return unknown;
47 : }
48 :
49 : static const char *
50 202 : prretcode(int retcode)
51 : {
52 : static char unknown[24];
53 202 : switch(retcode) {
54 : case SUCCEED: return "SUCCEED";
55 8 : case FAIL: return "FAIL";
56 110 : case NO_MORE_RESULTS: return "NO_MORE_RESULTS";
57 0 : default:
58 0 : sprintf(unknown, "oops: %u ??", retcode);
59 : }
60 0 : return unknown;
61 : }
62 :
63 : static void
64 80 : query(const char comment[])
65 : {
66 80 : if (comment)
67 32 : printf("%s\n", comment);
68 80 : sql_cmd(dbproc);
69 80 : dbsqlexec(dbproc);
70 80 : while (dbresults(dbproc) == SUCCEED) {
71 : /* nop */
72 : }
73 80 : }
74 :
75 : typedef const char* (*prfunc)(int);
76 :
77 : static void
78 406 : check_state(const char name[], prfunc print, int erc)
79 : {
80 406 : printf("State %-15s %-20s ", name, print(erc));
81 406 : if (dbnumcols(dbproc) > 0)
82 302 : printf("COLS(%d) ", dbnumcols(dbproc));
83 : /* row count */
84 406 : if (dbcount(dbproc) >= 0)
85 70 : printf("ROWS(%d) ", (int) dbcount(dbproc));
86 406 : silent = 1;
87 406 : if (dbdata(dbproc, 1))
88 104 : printf("DATA ");
89 406 : silent = 0;
90 : /* if status present */
91 406 : if (dbretstatus(dbproc) == TRUE)
92 0 : printf("STATUS %d ", (int) dbretstatus(dbproc));
93 : /* if parameter present */
94 406 : if (dbnumrets(dbproc) > 0)
95 8 : printf("PARAMS ");
96 : /*
97 : * if possible to send another query
98 : * NOTE this must be the last
99 : */
100 406 : if (check_idle) {
101 48 : silent = 1;
102 48 : dbcmd(dbproc, "declare @i int ");
103 48 : if (FAIL != dbsqlexec(dbproc))
104 16 : printf("IDLE ");
105 48 : silent = 0;
106 : }
107 406 : printf("\n");
108 406 : }
109 :
110 : static void
111 48 : do_test(const char comment[])
112 : {
113 : int ret;
114 48 : prfunc print_with = NULL;
115 :
116 48 : if (comment)
117 48 : printf("%s\n", comment);
118 48 : sql_cmd(dbproc);
119 :
120 48 : check_state("sqlexec ", prretcode, dbsqlexec(dbproc));
121 :
122 48 : check_state("nextrow ", prdbretcode, dbnextrow(dbproc));
123 48 : check_state("nextrow ", prdbretcode, dbnextrow(dbproc));
124 48 : check_state("results ", prretcode, dbresults(dbproc));
125 48 : check_state("nextrow ", prdbretcode, dbnextrow(dbproc));
126 48 : check_state("nextrow ", prdbretcode, dbnextrow(dbproc));
127 :
128 48 : check_idle = 0;
129 : for (;;) {
130 58 : ret = dbresults(dbproc);
131 58 : check_state("results ", prretcode, ret);
132 58 : if (ret != SUCCEED) {
133 48 : print_with = prretcode;
134 : break;
135 : }
136 :
137 : do {
138 12 : ret = dbnextrow(dbproc);
139 12 : check_state("nextrow ", prdbretcode, ret);
140 12 : } while (ret == REG_ROW);
141 : print_with = prdbretcode;
142 : }
143 48 : check_state("more results?", print_with, ret);
144 48 : }
145 :
146 : int
147 8 : main(int argc, char *argv[])
148 : {
149 : const static int invalid_column_name = 207;
150 : LOGINREC *login; /* Our login information. */
151 : int i;
152 :
153 8 : setbuf(stdout, NULL);
154 8 : read_login_info(argc, argv);
155 :
156 8 : if (dbinit() == FAIL)
157 0 : exit(1);
158 :
159 8 : dberrhandle(err_handler);
160 8 : dbmsghandle(msg_handler);
161 :
162 : #if 0
163 : /*
164 : * FIXME: Should be able to use the common err/msg handlers, but something about
165 : * the IDLE checking causes them to fail. Not sure about purpose of IDLE checking.
166 : * -- jkl January 2009
167 : */
168 : dberrhandle(syb_err_handler);
169 : dbmsghandle(syb_msg_handler);
170 : #endif
171 :
172 8 : login = dblogin();
173 8 : DBSETLUSER(login, USER);
174 8 : DBSETLPWD(login, PASSWORD);
175 8 : DBSETLAPP(login, __FILE__);
176 :
177 8 : dbproc = dbopen(login, SERVER);
178 8 : dbloginfree(login);
179 8 : if (!dbproc)
180 0 : exit(1);
181 8 : if (strlen(DATABASE))
182 8 : dbuse(dbproc, DATABASE);
183 :
184 48 : for (i=0; i < 6; i++)
185 48 : query(NULL);
186 : #if 0
187 : check_state("setup done ", prretcode, erc);
188 :
189 : printf("wasting results\n");
190 : while ((erc = dbresults(dbproc)) == SUCCEED) {
191 : while (dbnextrow(dbproc) == REG_ROW); /* no-op */
192 : }
193 : #endif
194 8 : check_idle = 1;
195 :
196 8 : do_test("normal row with rowcount on");
197 8 : query("turn rowcount off");
198 8 : do_test("normal row with rowcount off");
199 8 : query("turn rowcount back on");
200 8 : do_test("normal row without rows");
201 8 : dbsetuserdata(dbproc, (BYTE*) &invalid_column_name);
202 8 : do_test("error query");
203 8 : do_test("stored procedure call with output parameters");
204 :
205 8 : do_test("execute done2");
206 :
207 8 : query("drop done_test");
208 :
209 8 : query("drop done_test2");
210 :
211 8 : dbexit();
212 : return 0;
213 : }
214 :
215 : static int
216 40 : err_handler(DBPROCESS * dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr)
217 : {
218 40 : if (silent)
219 : return INT_CANCEL;
220 :
221 8 : fflush(stdout);
222 8 : fprintf(stderr, "DB-Library error (severity %d):\n\t%s\n", severity, dberrstr);
223 :
224 8 : if (oserr != DBNOERR)
225 0 : fprintf(stderr, "Operating-system error:\n\t%s\n", oserrstr ? oserrstr : "(null)");
226 8 : fflush(stderr);
227 :
228 8 : return INT_CANCEL;
229 : }
230 :
231 : static int
232 30 : msg_handler(DBPROCESS * dbproc, DBINT msgno, int msgstate, int severity, char *msgtext, char *srvname, char *procname, int line)
233 : {
234 30 : if (silent)
235 : return 0;
236 :
237 30 : fflush(stdout);
238 30 : fprintf(stderr, "Msg %d, Level %d, State %d\n", (int) msgno, severity, msgstate);
239 :
240 30 : if (strlen(srvname) > 0)
241 30 : fprintf(stderr, "Server '%s', ", srvname);
242 30 : if (procname && strlen(procname) > 0) {
243 0 : fprintf(stderr, "Procedure '%s', ", procname);
244 0 : if (line > 0)
245 0 : fprintf(stderr, "Line %d", line);
246 : }
247 :
248 30 : fprintf(stderr, "\n\t%s\n", msgtext);
249 30 : fflush(stderr);
250 :
251 30 : return 0;
252 : }
|
