Line data Source code
1 : #include <config.h>
2 :
3 : #include <stdio.h>
4 :
5 : #ifdef HAVE_STRING_H
6 : #include <string.h>
7 : #endif
8 :
9 : #include <ctpublic.h>
10 : #include "common.h"
11 :
12 : int
13 8 : main(int argc, char **argv)
14 : {
15 : CS_CONTEXT *ctx;
16 : CS_CONNECTION *conn;
17 : CS_COMMAND *cmd;
18 : CS_COMMAND *cmd2;
19 : CS_COMMAND *cmd3;
20 : CS_RETCODE ret;
21 : CS_RETCODE ret2;
22 : CS_RETCODE results_ret;
23 : CS_INT result_type;
24 8 : CS_INT count, count2, row_count = 0;
25 : CS_DATAFMT datafmt;
26 : CS_DATAFMT datafmt2;
27 : CS_SMALLINT ind;
28 8 : int verbose = 1;
29 8 : CS_CHAR *name = "c1";
30 8 : CS_CHAR *name2 = "c2";
31 : CS_CHAR col1[6];
32 : CS_CHAR col2[6];
33 : CS_INT datalength;
34 : CS_CHAR text[128];
35 : CS_INT num_cols, i;
36 :
37 8 : memset(col1, 0, sizeof(col1));
38 8 : memset(col2, 0, sizeof(col2));
39 :
40 8 : printf("%s: use multiple cursors on the same connection\n", __FILE__);
41 :
42 : if (verbose) {
43 8 : printf("Trying login\n");
44 : }
45 8 : ret = try_ctlogin(&ctx, &conn, &cmd, verbose);
46 8 : if (ret != CS_SUCCEED) {
47 0 : fprintf(stderr, "Login failed\n");
48 0 : return 1;
49 : }
50 :
51 8 : ret = ct_cmd_alloc(conn, &cmd2);
52 8 : if (ret != CS_SUCCEED) {
53 : if (verbose) {
54 0 : fprintf(stderr, "Command Alloc failed!\n");
55 : }
56 0 : return ret;
57 : }
58 :
59 8 : ret = ct_cmd_alloc(conn, &cmd3);
60 8 : if (ret != CS_SUCCEED) {
61 : if (verbose) {
62 0 : fprintf(stderr, "Command Alloc failed!\n");
63 : }
64 0 : return ret;
65 : }
66 :
67 8 : ret = run_command(cmd, "CREATE TABLE #test_table (col1 char(4))");
68 8 : if (ret != CS_SUCCEED)
69 : return 1;
70 :
71 8 : ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('AAA')");
72 8 : if (ret != CS_SUCCEED)
73 : return 1;
74 8 : ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('BBB')");
75 8 : if (ret != CS_SUCCEED)
76 : return 1;
77 8 : ret = run_command(cmd, "INSERT #test_table (col1) VALUES ('CCC')");
78 8 : if (ret != CS_SUCCEED)
79 : return 1;
80 :
81 8 : ret = run_command(cmd, "CREATE TABLE #test_table2 (col1 char(4))");
82 8 : if (ret != CS_SUCCEED)
83 : return 1;
84 :
85 8 : ret = run_command(cmd, "INSERT #test_table2 (col1) VALUES ('XXX')");
86 8 : if (ret != CS_SUCCEED)
87 : return 1;
88 :
89 8 : ret = run_command(cmd, "INSERT #test_table2 (col1) VALUES ('YYY')");
90 8 : if (ret != CS_SUCCEED)
91 : return 1;
92 :
93 8 : ret = run_command(cmd, "INSERT #test_table2 (col1) VALUES ('ZZZ')");
94 :
95 :
96 8 : if (ret != CS_SUCCEED)
97 : return 1;
98 :
99 :
100 : if (verbose) {
101 8 : printf("opening first cursor on connection\n");
102 : }
103 :
104 8 : strcpy(text, "select col1 from #test_table order by col1");
105 :
106 8 : ret = ct_cursor(cmd, CS_CURSOR_DECLARE, name, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
107 :
108 8 : if (ret != CS_SUCCEED) {
109 0 : fprintf(stderr, "ct_cursor declare failed\n");
110 0 : return 1;
111 : }
112 :
113 8 : ret = ct_cursor(cmd, CS_CURSOR_ROWS, name, CS_NULLTERM, NULL, CS_UNUSED, (CS_INT) 1);
114 8 : if (ret != CS_SUCCEED) {
115 0 : fprintf(stderr, "ct_cursor set cursor rows failed");
116 0 : return 1;
117 : }
118 :
119 8 : ret = ct_cursor(cmd, CS_CURSOR_OPEN, name, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
120 :
121 8 : if (ret != CS_SUCCEED) {
122 0 : fprintf(stderr, "ct_cursor open failed\n");
123 0 : return 1;
124 : }
125 :
126 8 : ret = ct_send(cmd);
127 :
128 8 : if (ret != CS_SUCCEED) {
129 0 : fprintf(stderr, "ct_send failed\n");
130 0 : return 1;
131 : }
132 :
133 24 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
134 16 : switch ((int) result_type) {
135 :
136 0 : case CS_CMD_FAIL:
137 0 : fprintf(stderr, "ct_results failed\n");
138 0 : return 1;
139 : case CS_CMD_SUCCEED:
140 : case CS_CMD_DONE:
141 : case CS_STATUS_RESULT:
142 : break;
143 :
144 8 : case CS_CURSOR_RESULT:
145 8 : ret = ct_res_info(cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
146 :
147 8 : if (ret != CS_SUCCEED) {
148 0 : fprintf(stderr, "ct_res_info() failed");
149 0 : return 1;
150 : }
151 :
152 8 : if (num_cols != 1) {
153 0 : fprintf(stderr, "unexpected num of columns = %d \n", num_cols);
154 0 : return 1;
155 : }
156 :
157 16 : for (i = 0; i < num_cols; i++) {
158 :
159 : /* here we can finally test for the return status column */
160 8 : ret = ct_describe(cmd, i + 1, &datafmt);
161 :
162 8 : if (ret != CS_SUCCEED) {
163 0 : fprintf(stderr, "ct_describe() failed for column %d\n", i);
164 0 : return 1;
165 : }
166 :
167 8 : if (datafmt.status & CS_RETURN) {
168 0 : printf("ct_describe() column %d \n", i);
169 : }
170 :
171 8 : datafmt.datatype = CS_CHAR_TYPE;
172 8 : datafmt.format = CS_FMT_NULLTERM;
173 8 : datafmt.maxlength = 6;
174 8 : datafmt.count = 1;
175 8 : datafmt.locale = NULL;
176 8 : ret = ct_bind(cmd, 1, &datafmt, col1, &datalength, &ind);
177 8 : if (ret != CS_SUCCEED) {
178 0 : fprintf(stderr, "ct_bind() failed\n");
179 0 : return 1;
180 : }
181 :
182 : }
183 : break;
184 :
185 0 : case CS_COMPUTE_RESULT:
186 0 : fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
187 0 : return 1;
188 0 : default:
189 0 : fprintf(stderr, "ct_results() unexpected result_type.\n");
190 0 : return 1;
191 : }
192 : }
193 :
194 : if (verbose) {
195 8 : printf("opening second cursor on connection\n");
196 : }
197 :
198 8 : strcpy(text, "select col1 from #test_table2 order by col1");
199 :
200 8 : ret = ct_cursor(cmd2, CS_CURSOR_DECLARE, name2, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
201 :
202 8 : if (ret != CS_SUCCEED) {
203 0 : fprintf(stderr, "ct_cursor declare failed\n");
204 0 : return 1;
205 : }
206 :
207 8 : ret = ct_cursor(cmd2, CS_CURSOR_ROWS, name2, CS_NULLTERM, NULL, CS_UNUSED, (CS_INT) 1);
208 8 : if (ret != CS_SUCCEED) {
209 0 : fprintf(stderr, "ct_cursor set cursor rows failed");
210 0 : return 1;
211 : }
212 :
213 8 : ret = ct_cursor(cmd2, CS_CURSOR_OPEN, name2, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED);
214 :
215 8 : if (ret != CS_SUCCEED) {
216 0 : fprintf(stderr, "ct_cursor open failed\n");
217 0 : return 1;
218 : }
219 :
220 8 : ret = ct_send(cmd2);
221 :
222 8 : if (ret != CS_SUCCEED) {
223 0 : fprintf(stderr, "ct_send failed\n");
224 0 : return 1;
225 : }
226 :
227 24 : while ((results_ret = ct_results(cmd2, &result_type)) == CS_SUCCEED) {
228 16 : switch ((int) result_type) {
229 :
230 0 : case CS_CMD_FAIL:
231 0 : fprintf(stderr, "ct_results failed\n");
232 0 : return 1;
233 : case CS_CMD_SUCCEED:
234 : case CS_CMD_DONE:
235 : case CS_STATUS_RESULT:
236 : break;
237 :
238 8 : case CS_CURSOR_RESULT:
239 8 : ret = ct_res_info(cmd2, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
240 :
241 8 : if (ret != CS_SUCCEED) {
242 0 : fprintf(stderr, "ct_res_info() failed");
243 0 : return 1;
244 : }
245 :
246 8 : if (num_cols != 1) {
247 0 : fprintf(stderr, "unexpected num of columns = %d \n", num_cols);
248 0 : return 1;
249 : }
250 :
251 16 : for (i = 0; i < num_cols; i++) {
252 :
253 : /* here we can finally test for the return status column */
254 8 : ret = ct_describe(cmd2, i + 1, &datafmt2);
255 :
256 8 : if (ret != CS_SUCCEED) {
257 0 : fprintf(stderr, "ct_describe() failed for column %d\n", i);
258 0 : return 1;
259 : }
260 :
261 8 : if (datafmt2.status & CS_RETURN) {
262 0 : printf("ct_describe() column %d \n", i);
263 : }
264 :
265 8 : datafmt2.datatype = CS_CHAR_TYPE;
266 8 : datafmt2.format = CS_FMT_NULLTERM;
267 8 : datafmt2.maxlength = 6;
268 8 : datafmt2.count = 1;
269 8 : datafmt2.locale = NULL;
270 8 : ret = ct_bind(cmd2, 1, &datafmt2, col2, &datalength, &ind);
271 8 : if (ret != CS_SUCCEED) {
272 0 : fprintf(stderr, "ct_bind() failed\n");
273 0 : return 1;
274 : }
275 :
276 : }
277 : break;
278 :
279 0 : case CS_COMPUTE_RESULT:
280 0 : fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
281 0 : return 1;
282 0 : default:
283 0 : fprintf(stderr, "ct_results() unexpected result_type.\n");
284 0 : return 1;
285 : }
286 : }
287 :
288 : row_count = 0;
289 :
290 32 : while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
291 8 : || (ret == CS_ROW_FAIL)) {
292 :
293 24 : ret2 = ct_fetch(cmd2, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count2);
294 24 : if (ret == CS_SUCCEED && ret2 == CS_SUCCEED) {
295 24 : printf("%s\t\t\t%s\n", col1, col2);
296 : }
297 : }
298 :
299 8 : switch ((int) ret) {
300 : case CS_END_DATA:
301 : break;
302 0 : case CS_ROW_FAIL:
303 0 : fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
304 0 : return 1;
305 0 : case CS_FAIL:
306 0 : fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
307 0 : return 1;
308 0 : default:
309 0 : fprintf(stderr, "ct_fetch() unexpected return.\n");
310 0 : return 1;
311 : }
312 :
313 : if (verbose) {
314 8 : printf("closing first cursor on connection\n");
315 : }
316 :
317 8 : ret = ct_cursor(cmd, CS_CURSOR_CLOSE, name, CS_NULLTERM, NULL, CS_UNUSED, CS_UNUSED);
318 :
319 8 : if (ret != CS_SUCCEED) {
320 0 : fprintf(stderr, "ct_cursor(close) failed\n");
321 0 : return ret;
322 : }
323 :
324 8 : if ((ret = ct_send(cmd)) != CS_SUCCEED) {
325 0 : fprintf(stderr, "BILL ct_send() failed\n");
326 0 : return ret;
327 : }
328 :
329 12 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
330 4 : if (result_type == CS_CMD_FAIL) {
331 0 : fprintf(stderr, "ct_results(2) result_type CS_CMD_FAIL.\n");
332 0 : return 1;
333 : }
334 : }
335 8 : if (results_ret != CS_END_RESULTS) {
336 0 : fprintf(stderr, "ct_results() returned BAD.\n");
337 0 : return 1;
338 : }
339 :
340 8 : ret = ct_cursor(cmd, CS_CURSOR_DEALLOC, name, CS_NULLTERM, NULL, CS_UNUSED, CS_UNUSED);
341 :
342 8 : if (ret != CS_SUCCEED) {
343 0 : fprintf(stderr, "ct_cursor(dealloc) failed\n");
344 0 : return ret;
345 : }
346 :
347 8 : if ((ret = ct_send(cmd)) != CS_SUCCEED) {
348 0 : fprintf(stderr, "ct_send() failed\n");
349 0 : return ret;
350 : }
351 :
352 12 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
353 4 : if (result_type == CS_CMD_FAIL) {
354 0 : fprintf(stderr, "ct_results(3) result_type CS_CMD_FAIL.\n");
355 0 : return 1;
356 : }
357 : }
358 8 : if (results_ret != CS_END_RESULTS) {
359 0 : fprintf(stderr, "ct_results() returned BAD.\n");
360 0 : return 1;
361 : }
362 :
363 : if (verbose) {
364 8 : printf("closing second cursor on connection\n");
365 : }
366 :
367 8 : ret = ct_cursor(cmd2, CS_CURSOR_CLOSE, name2, CS_NULLTERM, NULL, CS_UNUSED, CS_UNUSED);
368 :
369 8 : if (ret != CS_SUCCEED) {
370 0 : fprintf(stderr, "ct_cursor(close) failed\n");
371 0 : return ret;
372 : }
373 :
374 8 : if ((ret = ct_send(cmd2)) != CS_SUCCEED) {
375 0 : fprintf(stderr, "BILL ct_send() failed\n");
376 0 : return ret;
377 : }
378 :
379 12 : while ((results_ret = ct_results(cmd2, &result_type)) == CS_SUCCEED) {
380 4 : if (result_type == CS_CMD_FAIL) {
381 0 : fprintf(stderr, "ct_results(2) result_type CS_CMD_FAIL.\n");
382 0 : return 1;
383 : }
384 : }
385 8 : if (results_ret != CS_END_RESULTS) {
386 0 : fprintf(stderr, "ct_results() returned BAD.\n");
387 0 : return 1;
388 : }
389 :
390 8 : ret = ct_cursor(cmd2, CS_CURSOR_DEALLOC, name2, CS_NULLTERM, NULL, CS_UNUSED, CS_UNUSED);
391 :
392 8 : if (ret != CS_SUCCEED) {
393 0 : fprintf(stderr, "ct_cursor(dealloc) failed\n");
394 0 : return ret;
395 : }
396 :
397 8 : if ((ret = ct_send(cmd2)) != CS_SUCCEED) {
398 0 : fprintf(stderr, "ct_send() failed\n");
399 0 : return ret;
400 : }
401 :
402 12 : while ((results_ret = ct_results(cmd2, &result_type)) == CS_SUCCEED) {
403 4 : if (result_type == CS_CMD_FAIL) {
404 0 : fprintf(stderr, "ct_results(3) result_type CS_CMD_FAIL.\n");
405 0 : return 1;
406 : }
407 : }
408 8 : if (results_ret != CS_END_RESULTS) {
409 0 : fprintf(stderr, "ct_results() returned BAD.\n");
410 0 : return 1;
411 : }
412 :
413 8 : ct_cmd_drop(cmd2);
414 8 : ct_cmd_drop(cmd3);
415 :
416 : if (verbose) {
417 8 : printf("Trying logout\n");
418 : }
419 8 : ret = try_ctlogout(ctx, conn, cmd, verbose);
420 8 : if (ret != CS_SUCCEED) {
421 0 : fprintf(stderr, "Logout failed\n");
422 0 : return 2;
423 : }
424 :
425 : if (verbose) {
426 8 : printf("Test succeded\n");
427 : }
428 8 : return 0;
429 : }
|
