Line data Source code
1 : #include "common.h"
2 :
3 : static int update_second_table(CS_COMMAND * cmd2, char *value);
4 :
5 : int
6 8 : main(void)
7 : {
8 : CS_CONTEXT *ctx;
9 : CS_CONNECTION *conn;
10 : CS_COMMAND *cmd;
11 : CS_COMMAND *cmd2;
12 : CS_RETCODE ret;
13 : CS_RETCODE results_ret;
14 : CS_INT result_type;
15 8 : CS_INT count, row_count = 0;
16 : CS_DATAFMT datafmt;
17 : CS_SMALLINT ind;
18 8 : int verbose = 1;
19 : CS_CHAR name[3];
20 : CS_CHAR col1[6];
21 : CS_INT datalength;
22 : CS_CHAR text[128];
23 : CS_INT num_cols, i, j;
24 : CS_INT props_value;
25 :
26 8 : printf("%s: Testing ct_cursor()\n", __FILE__);
27 :
28 : if (verbose) {
29 8 : printf("Trying login\n");
30 : }
31 8 : check_call(try_ctlogin, (&ctx, &conn, &cmd, verbose));
32 :
33 8 : check_call(ct_cmd_alloc, (conn, &cmd2));
34 :
35 8 : check_call(run_command, (cmd, "CREATE TABLE #test_table (col1 char(4))"));
36 8 : check_call(run_command, (cmd, "INSERT #test_table (col1) VALUES ('AAA')"));
37 8 : check_call(run_command, (cmd, "INSERT #test_table (col1) VALUES ('BBB')"));
38 8 : check_call(run_command, (cmd, "INSERT #test_table (col1) VALUES ('CCC')"));
39 :
40 8 : check_call(run_command, (cmd2, "CREATE TABLE #test_table2 (col1 char(4))"));
41 8 : check_call(run_command, (cmd2, "INSERT #test_table2 (col1) VALUES ('---')"));
42 :
43 : if (verbose) {
44 8 : printf("Trying declare, rows , open in one SEND\n");
45 : }
46 :
47 8 : strcpy(text, "select col1 from #test_table where 1 = 1");
48 8 : strcpy(name, "c1");
49 :
50 8 : check_call(ct_cursor, (cmd, CS_CURSOR_DECLARE, name, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED));
51 :
52 8 : check_call(ct_cursor, (cmd, CS_CURSOR_ROWS, name, CS_NULLTERM, NULL, CS_UNUSED, (CS_INT) 1));
53 :
54 8 : check_call(ct_cursor, (cmd, CS_CURSOR_OPEN, name, CS_NULLTERM, text, CS_NULLTERM, CS_UNUSED));
55 :
56 8 : check_call(ct_send, (cmd));
57 :
58 48 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
59 32 : switch ((int) result_type) {
60 :
61 : case CS_CMD_SUCCEED:
62 : case CS_CMD_DONE:
63 : case CS_CMD_FAIL:
64 : case CS_STATUS_RESULT:
65 : break;
66 :
67 8 : case CS_CURSOR_RESULT:
68 :
69 8 : check_call(ct_cmd_props, (cmd, CS_GET, CS_CUR_STATUS, &props_value, sizeof(CS_INT), NULL));
70 8 : if (props_value & CS_CURSTAT_DECLARED) {
71 0 : fprintf(stderr, "ct_cmd_props claims cursor is in DECLARED state when it should be OPEN\n");
72 0 : return 1;
73 : }
74 8 : if (!(props_value & CS_CURSTAT_OPEN)) {
75 0 : fprintf(stderr, "ct_cmd_props claims cursor is not in OPEN state when it should be \n");
76 0 : return 1;
77 : }
78 8 : if (props_value & CS_CURSTAT_CLOSED) {
79 0 : fprintf(stderr, "ct_cmd_props claims cursor is in CLOSED state when it should be OPEN\n");
80 0 : return 1;
81 : }
82 :
83 8 : check_call(ct_res_info, (cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL));
84 :
85 8 : if (num_cols != 1) {
86 0 : fprintf(stderr, "unexpected num of columns = %d \n", num_cols);
87 0 : return 1;
88 : }
89 :
90 8 : for (i = 0; i < num_cols; i++) {
91 :
92 : /* here we can finally test for the return status column */
93 8 : check_call(ct_describe, (cmd, i + 1, &datafmt));
94 :
95 8 : if (datafmt.status & CS_RETURN) {
96 0 : printf("ct_describe() column %d \n", i);
97 : }
98 :
99 8 : datafmt.datatype = CS_CHAR_TYPE;
100 8 : datafmt.format = CS_FMT_NULLTERM;
101 8 : datafmt.maxlength = 6;
102 8 : datafmt.count = 1;
103 8 : datafmt.locale = NULL;
104 8 : check_call(ct_bind, (cmd, 1, &datafmt, col1, &datalength, &ind));
105 : }
106 : row_count = 0;
107 32 : while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
108 8 : || (ret == CS_ROW_FAIL)) {
109 :
110 24 : if (row_count == 0) {
111 8 : for (j = 0; j < num_cols; j++) {
112 8 : printf("\n%s\n", datafmt.name);
113 : }
114 8 : printf("------\n\n");
115 : }
116 :
117 24 : for (j = 0; j < num_cols; j++) {
118 24 : printf("%s\n\n", col1);
119 24 : row_count++;
120 : }
121 :
122 24 : ret = update_second_table(cmd2, col1);
123 24 : if (ret)
124 : return ret;
125 : }
126 :
127 8 : switch ((int) ret) {
128 : case CS_END_DATA:
129 : break;
130 0 : case CS_ROW_FAIL:
131 0 : fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
132 0 : return 1;
133 0 : case CS_FAIL:
134 0 : fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
135 0 : return 1;
136 0 : default:
137 0 : fprintf(stderr, "ct_fetch() unexpected return. %d\n", ret);
138 0 : return 1;
139 : }
140 : break;
141 :
142 0 : case CS_COMPUTE_RESULT:
143 0 : fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
144 0 : return 1;
145 0 : default:
146 0 : fprintf(stderr, "ct_results() unexpected result_type.\n");
147 0 : return 1;
148 : }
149 : }
150 :
151 :
152 8 : check_call(ct_cursor, (cmd, CS_CURSOR_CLOSE, name, CS_NULLTERM, NULL, CS_UNUSED, CS_DEALLOC));
153 :
154 8 : check_call(ct_send, (cmd));
155 :
156 20 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
157 4 : if (result_type == CS_CMD_FAIL) {
158 0 : fprintf(stderr, "ct_results(2) result_type CS_CMD_FAIL.\n");
159 0 : return 1;
160 : }
161 : }
162 8 : if (results_ret != CS_END_RESULTS) {
163 0 : fprintf(stderr, "ct_results() returned BAD.\n");
164 0 : return 1;
165 : }
166 :
167 8 : check_call(ct_cmd_props, (cmd, CS_GET, CS_CUR_STATUS, &props_value, sizeof(CS_INT), NULL));
168 :
169 8 : if (props_value != CS_CURSTAT_NONE) {
170 0 : fprintf(stderr, "ct_cmd_props() CS_CUR_STATUS != CS_CURSTAT_NONE \n");
171 0 : return 1;
172 : }
173 :
174 : if (verbose) {
175 8 : printf("Trying declare, rows, open one at a time \n");
176 : }
177 :
178 8 : strcpy(text, "select col1 from #test_table where 2 = 2");
179 :
180 8 : check_call(ct_cursor, (cmd, CS_CURSOR_DECLARE, name, 3, text, CS_NULLTERM, CS_UNUSED));
181 :
182 8 : check_call(ct_send, (cmd));
183 :
184 20 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
185 4 : if (result_type == CS_CMD_FAIL) {
186 0 : fprintf(stderr, "ct_results(4) result_type CS_CMD_FAIL.\n");
187 0 : return 1;
188 : }
189 : }
190 8 : if (results_ret != CS_END_RESULTS) {
191 0 : fprintf(stderr, "ct_results() returned BAD.\n");
192 0 : return 1;
193 : }
194 :
195 8 : check_call(ct_cursor, (cmd, CS_CURSOR_ROWS, name, 3, NULL, CS_UNUSED, (CS_INT) 1));
196 :
197 8 : check_call(ct_send, (cmd));
198 :
199 20 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
200 4 : if (result_type == CS_CMD_FAIL) {
201 0 : fprintf(stderr, "ct_results(5) result_type CS_CMD_FAIL.\n");
202 0 : return 1;
203 : }
204 : }
205 8 : if (results_ret != CS_END_RESULTS) {
206 0 : fprintf(stderr, "ct_results() returned BAD.\n");
207 0 : return 1;
208 : }
209 :
210 8 : check_call(ct_cursor, (cmd, CS_CURSOR_OPEN, name, 3, text, 26, CS_UNUSED));
211 :
212 8 : check_call(ct_send, (cmd));
213 :
214 40 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
215 24 : switch ((int) result_type) {
216 :
217 : case CS_CMD_SUCCEED:
218 : break;
219 : case CS_CMD_DONE:
220 : break;
221 0 : case CS_CMD_FAIL:
222 0 : fprintf(stderr, "ct_results(6) result_type CS_CMD_FAIL.\n");
223 0 : break;
224 0 : case CS_STATUS_RESULT:
225 0 : printf("ct_results: CS_STATUS_RESULT detected for sp_who\n");
226 :
227 8 : case CS_CURSOR_RESULT:
228 8 : check_call(ct_res_info, (cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL));
229 :
230 8 : if (num_cols != 1) {
231 0 : fprintf(stderr, "unexpected num of columns = %d \n", num_cols);
232 0 : return 1;
233 : }
234 :
235 8 : for (i = 0; i < num_cols; i++) {
236 :
237 : /* here we can finally test for the return status column */
238 8 : check_call(ct_describe, (cmd, i + 1, &datafmt));
239 :
240 8 : if (datafmt.status & CS_RETURN) {
241 0 : printf("ct_describe() column %d \n", i);
242 : }
243 :
244 8 : datafmt.datatype = CS_CHAR_TYPE;
245 8 : datafmt.format = CS_FMT_NULLTERM;
246 8 : datafmt.maxlength = 6;
247 8 : datafmt.count = 1;
248 8 : datafmt.locale = NULL;
249 8 : check_call(ct_bind, (cmd, 1, &datafmt, col1, &datalength, &ind));
250 : }
251 : row_count = 0;
252 32 : while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
253 8 : || (ret == CS_ROW_FAIL)) {
254 :
255 24 : if (row_count == 0) {
256 8 : for (j = 0; j < num_cols; j++) {
257 8 : printf("\n%s\n", datafmt.name);
258 : }
259 8 : printf("------\n\n");
260 : }
261 :
262 24 : for (j = 0; j < num_cols; j++) {
263 24 : printf("%s\n\n", col1);
264 24 : row_count++;
265 : }
266 : }
267 :
268 :
269 8 : switch ((int) ret) {
270 : case CS_END_DATA:
271 : break;
272 0 : case CS_ROW_FAIL:
273 0 : fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
274 0 : return 1;
275 0 : case CS_FAIL:
276 0 : fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
277 0 : return 1;
278 0 : default:
279 0 : fprintf(stderr, "ct_fetch() unexpected return. %d\n", ret);
280 0 : return 1;
281 : }
282 : break;
283 :
284 0 : case CS_COMPUTE_RESULT:
285 0 : fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
286 0 : return 1;
287 0 : default:
288 0 : fprintf(stderr, "ct_results() unexpected result_type.\n");
289 0 : return 1;
290 : }
291 : }
292 :
293 :
294 8 : check_call(ct_cursor, (cmd, CS_CURSOR_CLOSE, name, 3, NULL, CS_UNUSED, CS_UNUSED));
295 :
296 8 : check_call(ct_send, (cmd));
297 :
298 20 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
299 4 : if (result_type == CS_CMD_FAIL) {
300 0 : fprintf(stderr, "ct_results(7) result_type CS_CMD_FAIL.\n");
301 0 : return 1;
302 : }
303 : }
304 8 : if (results_ret != CS_END_RESULTS) {
305 0 : fprintf(stderr, "ct_results() returned BAD.\n");
306 0 : return 1;
307 : }
308 8 : check_call(ct_cursor, (cmd, CS_CURSOR_DEALLOC, name, 3, NULL, CS_UNUSED, CS_UNUSED));
309 :
310 8 : check_call(ct_send, (cmd));
311 :
312 20 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
313 4 : if (result_type == CS_CMD_FAIL) {
314 0 : fprintf(stderr, "ct_results(8) result_type CS_CMD_FAIL.\n");
315 0 : return 1;
316 : }
317 : }
318 8 : if (results_ret != CS_END_RESULTS) {
319 0 : fprintf(stderr, "ct_results() returned BAD.\n");
320 0 : return 1;
321 : }
322 :
323 : if (verbose) {
324 8 : printf("Running normal select command after cursor operations\n");
325 : }
326 :
327 8 : check_call(ct_command, (cmd, CS_LANG_CMD, "select col1 from #test_table", CS_NULLTERM, CS_UNUSED));
328 8 : check_call(ct_send, (cmd));
329 32 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
330 16 : switch ((int) result_type) {
331 : case CS_CMD_SUCCEED:
332 : break;
333 : case CS_CMD_DONE:
334 : break;
335 0 : case CS_CMD_FAIL:
336 0 : fprintf(stderr, "ct_results() result_type CS_CMD_FAIL.\n");
337 0 : return 1;
338 8 : case CS_ROW_RESULT:
339 8 : datafmt.datatype = CS_CHAR_TYPE;
340 8 : datafmt.format = CS_FMT_NULLTERM;
341 8 : datafmt.maxlength = 6;
342 8 : datafmt.count = 1;
343 8 : datafmt.locale = NULL;
344 8 : check_call(ct_bind, (cmd, 1, &datafmt, col1, &datalength, &ind));
345 :
346 40 : while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
347 8 : || (ret == CS_ROW_FAIL)) {
348 24 : row_count += count;
349 24 : if (ret == CS_ROW_FAIL) {
350 0 : fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
351 0 : return 1;
352 24 : } else if (ret == CS_SUCCEED) {
353 : ;
354 : } else {
355 : break;
356 : }
357 : }
358 8 : switch ((int) ret) {
359 : case CS_END_DATA:
360 : break;
361 0 : case CS_FAIL:
362 0 : fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
363 0 : return 1;
364 0 : default:
365 0 : fprintf(stderr, "ct_fetch() unexpected return.%d\n", ret);
366 0 : return 1;
367 : }
368 : break;
369 0 : case CS_COMPUTE_RESULT:
370 0 : fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
371 0 : return 1;
372 0 : default:
373 0 : fprintf(stderr, "ct_results() unexpected result_type. %d\n", result_type);
374 0 : return 1;
375 : }
376 : }
377 8 : switch ((int) results_ret) {
378 : case CS_END_RESULTS:
379 : break;
380 0 : case CS_FAIL:
381 0 : fprintf(stderr, "ct_results() failed.\n");
382 0 : return 1;
383 : break;
384 0 : default:
385 0 : fprintf(stderr, "ct_results() unexpected return.\n");
386 0 : return 1;
387 : }
388 : if (verbose) {
389 8 : printf("Trying logout\n");
390 : }
391 :
392 8 : ct_cmd_drop(cmd2);
393 :
394 8 : check_call(try_ctlogout, (ctx, conn, cmd, verbose));
395 :
396 : if (verbose) {
397 8 : printf("Test suceeded\n");
398 : }
399 8 : return 0;
400 : }
401 :
402 : static int
403 24 : update_second_table(CS_COMMAND * cmd2, char *value)
404 : {
405 :
406 : CS_RETCODE ret;
407 : CS_RETCODE results_ret;
408 : CS_INT result_type;
409 24 : CS_INT count, row_count = 0;
410 : CS_DATAFMT datafmt;
411 : CS_SMALLINT ind;
412 : CS_CHAR col1[6];
413 : CS_INT datalength;
414 : CS_CHAR text[128];
415 :
416 24 : sprintf(text, "update #test_table2 set col1 = '%s' ", value);
417 24 : ret = run_command(cmd2, text);
418 24 : if (ret != CS_SUCCEED)
419 : return 1;
420 :
421 24 : ret = ct_command(cmd2, CS_LANG_CMD, "select col1 from #test_table2", CS_NULLTERM, CS_UNUSED);
422 24 : if (ret != CS_SUCCEED) {
423 0 : fprintf(stderr, "ct_command() failed\n");
424 0 : return 1;
425 : }
426 24 : ret = ct_send(cmd2);
427 24 : if (ret != CS_SUCCEED) {
428 0 : fprintf(stderr, "ct_send() failed\n");
429 0 : return 1;
430 : }
431 72 : while ((results_ret = ct_results(cmd2, &result_type)) == CS_SUCCEED) {
432 48 : switch ((int) result_type) {
433 : case CS_CMD_SUCCEED:
434 : break;
435 : case CS_CMD_DONE:
436 : break;
437 0 : case CS_CMD_FAIL:
438 0 : fprintf(stderr, "ct_results() result_type CS_CMD_FAIL.\n");
439 0 : return 1;
440 24 : case CS_ROW_RESULT:
441 24 : datafmt.datatype = CS_CHAR_TYPE;
442 24 : datafmt.format = CS_FMT_NULLTERM;
443 24 : datafmt.maxlength = 6;
444 24 : datafmt.count = 1;
445 24 : datafmt.locale = NULL;
446 24 : ret = ct_bind(cmd2, 1, &datafmt, col1, &datalength, &ind);
447 24 : if (ret != CS_SUCCEED) {
448 0 : fprintf(stderr, "ct_bind() failed\n");
449 0 : return 1;
450 : }
451 :
452 48 : while (((ret = ct_fetch(cmd2, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
453 24 : || (ret == CS_ROW_FAIL)) {
454 24 : row_count += count;
455 24 : if (ret == CS_ROW_FAIL) {
456 0 : fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
457 0 : return 1;
458 24 : } else if (ret == CS_SUCCEED) {
459 : ;
460 : } else {
461 : break;
462 : }
463 : }
464 24 : switch ((int) ret) {
465 : case CS_END_DATA:
466 : break;
467 0 : case CS_FAIL:
468 0 : fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
469 0 : return 1;
470 0 : default:
471 0 : fprintf(stderr, "ct_fetch() unexpected return.%d\n", ret);
472 0 : return 1;
473 : }
474 : break;
475 0 : case CS_COMPUTE_RESULT:
476 0 : fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
477 0 : return 1;
478 0 : default:
479 0 : fprintf(stderr, "ct_results() unexpected result_type. %d\n", result_type);
480 0 : return 1;
481 : }
482 : }
483 24 : switch ((int) results_ret) {
484 : case CS_END_RESULTS:
485 : break;
486 0 : case CS_FAIL:
487 0 : fprintf(stderr, "ct_results() failed.\n");
488 0 : return 1;
489 : break;
490 0 : default:
491 0 : fprintf(stderr, "ct_results() unexpected return.\n");
492 0 : return 1;
493 : }
494 : return 0;
495 : }
496 :
|
