Line data Source code
1 : #include "common.h"
2 :
3 : static int sp_who(CS_COMMAND *cmd);
4 :
5 : /*
6 : * ct_send SQL |select name = @@servername|
7 : * ct_bind variable
8 : * ct_fetch and print results
9 : */
10 : int
11 8 : main(void)
12 : {
13 : CS_CONTEXT *ctx;
14 : CS_CONNECTION *conn;
15 : CS_COMMAND *cmd;
16 8 : int verbose = 0;
17 :
18 : CS_RETCODE ret;
19 : CS_RETCODE results_ret;
20 : CS_DATAFMT datafmt;
21 : CS_INT datalength;
22 : CS_SMALLINT ind;
23 8 : CS_INT count, row_count = 0;
24 : CS_INT result_type;
25 : CS_CHAR name[256];
26 :
27 8 : printf("%s: Testing bind & select\n", __FILE__);
28 : if (verbose) {
29 : printf("Trying login\n");
30 : }
31 8 : check_call(try_ctlogin, (&ctx, &conn, &cmd, verbose));
32 :
33 8 : check_call(ct_command, (cmd, CS_LANG_CMD, "select name = @@servername", CS_NULLTERM, CS_UNUSED));
34 8 : check_call(ct_send, (cmd));
35 32 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
36 16 : switch ((int) result_type) {
37 : case CS_CMD_SUCCEED:
38 : break;
39 : case CS_CMD_DONE:
40 : break;
41 0 : case CS_CMD_FAIL:
42 0 : fprintf(stderr, "ct_results() result_type CS_CMD_FAIL.\n");
43 0 : return 1;
44 8 : case CS_ROW_RESULT:
45 8 : datafmt.datatype = CS_CHAR_TYPE;
46 8 : datafmt.format = CS_FMT_NULLTERM;
47 8 : datafmt.maxlength = 256;
48 8 : datafmt.count = 1;
49 8 : datafmt.locale = NULL;
50 8 : check_call(ct_bind, (cmd, 1, &datafmt, name, &datalength, &ind));
51 :
52 24 : while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
53 8 : || (ret == CS_ROW_FAIL)) {
54 8 : row_count += count;
55 8 : if (ret == CS_ROW_FAIL) {
56 0 : fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
57 0 : return 1;
58 8 : } else if (ret == CS_SUCCEED) {
59 : if (verbose) {
60 : printf("server name = %s\n", name);
61 : }
62 : } else {
63 : break;
64 : }
65 : }
66 8 : switch ((int) ret) {
67 : case CS_END_DATA:
68 : break;
69 0 : case CS_FAIL:
70 0 : fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
71 0 : return 1;
72 0 : default:
73 0 : fprintf(stderr, "ct_fetch() unexpected return.\n");
74 0 : return 1;
75 : }
76 : break;
77 0 : case CS_COMPUTE_RESULT:
78 0 : fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
79 0 : return 1;
80 0 : default:
81 0 : fprintf(stderr, "ct_results() unexpected result_type.\n");
82 0 : return 1;
83 : }
84 : }
85 8 : switch ((int) results_ret) {
86 : case CS_END_RESULTS:
87 : break;
88 0 : case CS_FAIL:
89 0 : fprintf(stderr, "ct_results() failed.\n");
90 0 : return 1;
91 : break;
92 0 : default:
93 0 : fprintf(stderr, "ct_results() unexpected return.\n");
94 0 : return 1;
95 : }
96 :
97 : /*
98 : * test parameter return code processing with sp_who
99 : */
100 8 : sp_who(cmd);
101 :
102 : if (verbose) {
103 : printf("Trying logout\n");
104 : }
105 8 : check_call(try_ctlogout, (ctx, conn, cmd, verbose));
106 :
107 8 : return 0;
108 : }
109 :
110 : int
111 8 : sp_who(CS_COMMAND *cmd)
112 : {
113 : enum {maxcol=10, colsize=260};
114 :
115 : struct _col {
116 : CS_DATAFMT datafmt;
117 : CS_INT datalength;
118 : CS_SMALLINT ind;
119 : CS_CHAR data[colsize];
120 : } col[maxcol];
121 :
122 : CS_INT num_cols;
123 8 : CS_INT count, row_count = 0;
124 : CS_INT result_type;
125 : CS_RETCODE ret;
126 : CS_RETCODE results_ret;
127 : int i;
128 8 : int is_status_result=0;
129 :
130 8 : ret = ct_command(cmd, CS_LANG_CMD, "exec sp_who", CS_NULLTERM, CS_UNUSED);
131 8 : if (ret != CS_SUCCEED) {
132 0 : fprintf(stderr, "ct_command: \"exec sp_who\" failed with %d\n", ret);
133 0 : return 1;
134 : }
135 8 : ret = ct_send(cmd);
136 8 : if (ret != CS_SUCCEED) {
137 0 : fprintf(stderr, "ct_send: \"exec sp_who\" failed with %d\n", ret);
138 0 : return 1;
139 : }
140 56 : while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
141 48 : is_status_result = 0;
142 48 : switch ((int) result_type) {
143 : case CS_CMD_SUCCEED:
144 : break;
145 : case CS_CMD_DONE:
146 : break;
147 0 : case CS_CMD_FAIL:
148 0 : fprintf(stderr, "ct_results() result_type CS_CMD_FAIL.\n");
149 0 : return 1;
150 8 : case CS_STATUS_RESULT:
151 8 : printf("ct_results: CS_STATUS_RESULT detected for sp_who\n");
152 8 : is_status_result = 1;
153 : /* fall through */
154 16 : case CS_ROW_RESULT:
155 16 : ret = ct_res_info(cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
156 16 : if (ret != CS_SUCCEED || num_cols > maxcol) {
157 0 : fprintf(stderr, "ct_res_info() failed\n");
158 0 : return 1;
159 : }
160 :
161 16 : if (num_cols <= 0) {
162 0 : fprintf(stderr, "ct_res_info() return strange values\n");
163 0 : return 1;
164 : }
165 :
166 16 : if (is_status_result && num_cols != 1) {
167 0 : fprintf(stderr, "CS_STATUS_RESULT return more than 1 column\n");
168 0 : return 1;
169 : }
170 :
171 96 : for (i=0; i < num_cols; i++) {
172 :
173 : /* here we can finally test for the return status column */
174 80 : ret = ct_describe(cmd, i+1, &col[i].datafmt);
175 :
176 80 : if (ret != CS_SUCCEED) {
177 0 : fprintf(stderr, "ct_describe() failed for column %d\n", i);
178 0 : return 1;
179 : }
180 :
181 80 : if (col[i].datafmt.status & CS_RETURN) {
182 0 : printf("ct_describe() indicates a return code in column %d for sp_who\n", i);
183 :
184 : /*
185 : * other possible values:
186 : * CS_CANBENULL
187 : * CS_HIDDEN
188 : * CS_IDENTITY
189 : * CS_KEY
190 : * CS_VERSION_KEY
191 : * CS_TIMESTAMP
192 : * CS_UPDATABLE
193 : * CS_UPDATECOL
194 : */
195 : }
196 :
197 80 : col[i].datafmt.datatype = CS_CHAR_TYPE;
198 80 : col[i].datafmt.format = CS_FMT_NULLTERM;
199 80 : col[i].datafmt.maxlength = colsize;
200 80 : col[i].datafmt.count = 1;
201 80 : col[i].datafmt.locale = NULL;
202 :
203 80 : ret = ct_bind(cmd, i+1, &col[i].datafmt, &col[i].data, &col[i].datalength, &col[i].ind);
204 80 : if (ret != CS_SUCCEED) {
205 0 : fprintf(stderr, "ct_bind() failed\n");
206 0 : return 1;
207 : }
208 :
209 : }
210 :
211 : row_count = 0;
212 180 : while ((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED) {
213 164 : if( row_count == 0) { /* titles */
214 80 : for (i=0; i < num_cols; i++) {
215 : char fmt[40];
216 80 : if (col[i].datafmt.namelen == 0) {
217 8 : printf("unnamed%d ",i+1);
218 8 : continue;
219 : }
220 72 : sprintf(fmt, "%%-%d.%ds ", col[i].datafmt.namelen, col[i].datafmt.maxlength);
221 72 : printf(fmt, col[i].datafmt.name);
222 : }
223 16 : printf("\n");
224 : }
225 :
226 1405 : for (i=0; i < num_cols; i++) { /* data */
227 : char fmt[40];
228 1405 : if (col[i].ind)
229 82 : continue;
230 1323 : sprintf(fmt, "%%-%d.%ds ", col[i].datalength, col[i].datafmt.maxlength);
231 1323 : printf(fmt, col[i].data);
232 1323 : if (is_status_result && strcmp(col[i].data,"0")) {
233 0 : fprintf(stderr, "CS_STATUS_RESULT should return 0 as result\n");
234 0 : return 1;
235 : }
236 : }
237 :
238 164 : printf("\n");
239 :
240 164 : row_count += count;
241 : }
242 16 : if (is_status_result && row_count != 1) {
243 0 : fprintf(stderr, "CS_STATUS_RESULT should return a row\n");
244 0 : return 1;
245 : }
246 :
247 16 : switch ((int) ret) {
248 16 : case CS_END_DATA:
249 16 : printf("ct_results fetched %d rows.\n", row_count);
250 : break;
251 0 : case CS_ROW_FAIL:
252 0 : fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
253 0 : return 1;
254 0 : case CS_FAIL:
255 0 : fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
256 0 : return 1;
257 0 : default:
258 0 : fprintf(stderr, "ct_fetch() unexpected return.\n");
259 0 : return 1;
260 : }
261 16 : break;
262 0 : case CS_COMPUTE_RESULT:
263 0 : fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
264 0 : return 1;
265 0 : default:
266 0 : fprintf(stderr, "ct_results() unexpected result_type.\n");
267 0 : return 1;
268 : }
269 : }
270 :
271 8 : switch ((int) results_ret) {
272 : case CS_END_RESULTS:
273 : break;
274 0 : case CS_FAIL:
275 0 : fprintf(stderr, "ct_results() failed.\n");
276 0 : return 1;
277 : break;
278 0 : default:
279 0 : fprintf(stderr, "ct_results() unexpected return.\n");
280 0 : return 1;
281 : }
282 :
283 : return 0;
284 : }
|
