Line data Source code
1 : /* test win64 consistency */
2 : #include "common.h"
3 :
4 : /*
5 : set ipd processed_ptr with
6 : SQLParamOptions/SQLSetDescField/SQL_ATTR_PARAMS_PROCESSED_PTR
7 : check always same value IPD->processed_ptr attr
8 : */
9 :
10 : static void
11 : prepare_something(void)
12 : {
13 : /* Some DM requires something to be prepared, so do it */
14 : #ifndef TDS_NO_DM
15 : CHKPrepare(T("select * from #tmp1"), SQL_NTS, "S");
16 : #endif
17 : }
18 :
19 : static void
20 60 : check_ipd_params(void)
21 : {
22 : void *ptr, *ptr2;
23 : SQLHDESC desc;
24 : SQLINTEGER ind;
25 :
26 60 : CHKGetStmtAttr(SQL_ATTR_PARAMS_PROCESSED_PTR, &ptr, sizeof(ptr), NULL, "S");
27 :
28 : /* get IPD */
29 60 : CHKGetStmtAttr(SQL_ATTR_IMP_PARAM_DESC, &desc, sizeof(desc), &ind, "S");
30 :
31 60 : CHKGetDescField(desc, 0, SQL_DESC_ROWS_PROCESSED_PTR, &ptr2, sizeof(ptr2), &ind, "S");
32 :
33 60 : if (ptr != ptr2) {
34 0 : fprintf(stderr, "IPD inconsistency ptr %p ptr2 %p\n", ptr, ptr2);
35 0 : exit(1);
36 : }
37 60 : }
38 :
39 : static void
40 20 : set_ipd_params1(SQLULEN *ptr)
41 : {
42 20 : CHKSetStmtAttr(SQL_ATTR_PARAMS_PROCESSED_PTR, ptr, 0, "S");
43 20 : }
44 :
45 : static void
46 20 : set_ipd_params2(SQLULEN *ptr)
47 : {
48 : SQLHDESC desc;
49 : SQLINTEGER ind;
50 :
51 : /* get IPD */
52 20 : CHKGetStmtAttr(SQL_ATTR_IMP_PARAM_DESC, &desc, sizeof(desc), &ind, "S");
53 :
54 20 : CHKSetDescField(desc, 1, SQL_DESC_ROWS_PROCESSED_PTR, ptr, 0, "S");
55 20 : }
56 :
57 : static void
58 20 : set_ipd_params3(SQLULEN *ptr)
59 : {
60 20 : CHKParamOptions(2, ptr, "S");
61 20 : }
62 :
63 : typedef void (*rows_set_t)(SQLULEN*);
64 :
65 : static const rows_set_t param_set[] = {
66 : set_ipd_params1,
67 : set_ipd_params2,
68 : set_ipd_params3,
69 : NULL
70 : };
71 :
72 : #define MALLOC_N(t, n) (t*) malloc(n*sizeof(t))
73 :
74 : static void
75 10 : test_params(void)
76 : {
77 : #define ARRAY_SIZE 2
78 : const rows_set_t *p;
79 : SQLULEN len;
80 10 : SQLUINTEGER *ids = MALLOC_N(SQLUINTEGER,ARRAY_SIZE);
81 10 : SQLLEN *id_lens = MALLOC_N(SQLLEN,ARRAY_SIZE);
82 : unsigned long int h, l;
83 : unsigned int n;
84 :
85 : prepare_something();
86 :
87 30 : for (n = 0; n < ARRAY_SIZE; ++n) {
88 20 : ids[n] = n;
89 20 : id_lens[n] = 0;
90 : }
91 :
92 : /* test setting just some test pointers */
93 10 : set_ipd_params1((SQLULEN *) TDS_INT2PTR(0x01020304));
94 10 : check_ipd_params();
95 10 : set_ipd_params2((SQLULEN *) TDS_INT2PTR(0xabcdef12));
96 10 : check_ipd_params();
97 10 : set_ipd_params3((SQLULEN *) TDS_INT2PTR(0x87654321));
98 10 : check_ipd_params();
99 :
100 : /* now see results */
101 40 : for (p = param_set; *p != NULL; ++p) {
102 30 : odbc_reset_statement();
103 : len = 0xdeadbeef;
104 : len <<= 16;
105 : len <<= 16;
106 30 : len |= 12345678;
107 :
108 30 : (*p)(&len);
109 30 : check_ipd_params();
110 :
111 30 : CHKSetStmtAttr(SQL_ATTR_PARAMSET_SIZE, (void *) TDS_INT2PTR(ARRAY_SIZE), 0, "S");
112 30 : CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 5, 0, ids, 0, id_lens, "S");
113 :
114 30 : odbc_command("INSERT INTO #tmp1(i) VALUES(?)");
115 30 : SQLMoreResults(odbc_stmt);
116 90 : for (n = 0; n < ARRAY_SIZE; ++n)
117 60 : SQLMoreResults(odbc_stmt);
118 30 : l = (unsigned long int) (len & 0xfffffffflu);
119 30 : len >>= 16;
120 30 : h = (unsigned long int) (len >> 16);
121 30 : if (h != 0 || l != ARRAY_SIZE) {
122 0 : fprintf(stderr, "Wrong number returned in param rows high %lu low %lu\n", h, l);
123 0 : exit(1);
124 : }
125 : }
126 :
127 10 : free(ids);
128 10 : free(id_lens);
129 10 : }
130 :
131 : /*
132 : set ird processed_ptr with
133 : SQLExtendedFetch/SQLSetDescField/SQL_ATTR_ROWS_FETCHED_PTR
134 : check always same value IRD->processed_ptr attr
135 : */
136 :
137 : static void
138 50 : check_ird_params(void)
139 : {
140 : void *ptr, *ptr2;
141 : SQLHDESC desc;
142 : SQLINTEGER ind;
143 :
144 50 : CHKGetStmtAttr(SQL_ATTR_ROWS_FETCHED_PTR, &ptr, sizeof(ptr), NULL, "S");
145 :
146 : /* get IRD */
147 50 : CHKGetStmtAttr(SQL_ATTR_IMP_ROW_DESC, &desc, sizeof(desc), &ind, "S");
148 :
149 50 : CHKGetDescField(desc, 0, SQL_DESC_ROWS_PROCESSED_PTR, &ptr2, sizeof(ptr2), &ind, "S");
150 :
151 50 : if (ptr != ptr2) {
152 0 : fprintf(stderr, "IRD inconsistency ptr %p ptr2 %p\n", ptr, ptr2);
153 0 : exit(1);
154 : }
155 50 : }
156 :
157 : static void
158 20 : set_ird_params1(SQLULEN *ptr)
159 : {
160 20 : CHKSetStmtAttr(SQL_ATTR_ROWS_FETCHED_PTR, ptr, 0, "S");
161 20 : }
162 :
163 : static void
164 20 : set_ird_params2(SQLULEN *ptr)
165 : {
166 : SQLHDESC desc;
167 : SQLINTEGER ind;
168 :
169 : /* get IRD */
170 20 : CHKGetStmtAttr(SQL_ATTR_IMP_ROW_DESC, &desc, sizeof(desc), &ind, "S");
171 :
172 20 : CHKSetDescField(desc, 1, SQL_DESC_ROWS_PROCESSED_PTR, ptr, 0, "S");
173 20 : }
174 :
175 : static const rows_set_t row_set[] = {
176 : set_ird_params1,
177 : set_ird_params2,
178 : NULL
179 : };
180 :
181 : #define MALLOC_N(t, n) (t*) malloc(n*sizeof(t))
182 :
183 : static void
184 10 : test_rows(void)
185 : {
186 : const rows_set_t *p;
187 : SQLULEN len;
188 10 : SQLUINTEGER *ids = MALLOC_N(SQLUINTEGER,ARRAY_SIZE);
189 10 : SQLLEN *id_lens = MALLOC_N(SQLLEN,ARRAY_SIZE);
190 : unsigned long int h, l;
191 : unsigned int n;
192 :
193 : prepare_something();
194 :
195 30 : for (n = 0; n < ARRAY_SIZE; ++n) {
196 20 : ids[n] = n;
197 20 : id_lens[n] = 0;
198 : }
199 :
200 : /* test setting just some test pointers */
201 10 : set_ird_params1((SQLULEN *) TDS_INT2PTR(0x01020304));
202 10 : check_ird_params();
203 10 : set_ird_params2((SQLULEN *) TDS_INT2PTR(0xabcdef12));
204 10 : check_ird_params();
205 :
206 : /* now see results */
207 30 : for (p = row_set; ; ++p) {
208 30 : const char *test_name = NULL;
209 :
210 30 : odbc_reset_statement();
211 : prepare_something();
212 : len = 0xdeadbeef;
213 : len <<= 16;
214 : len <<= 16;
215 30 : len |= 12345678;
216 30 : if (*p)
217 20 : (*p)(&len);
218 30 : check_ird_params();
219 :
220 : #if 0
221 : CHKSetStmtAttr(SQL_ATTR_PARAMSET_SIZE, (void *) TDS_INT2PTR(ARRAY_SIZE), 0, "S");
222 : CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 5, 0, ids, 0, id_lens, "S");
223 : #endif
224 :
225 30 : CHKBindCol(1, SQL_C_ULONG, ids, 0, id_lens, "S");
226 30 : if (*p) {
227 20 : CHKSetStmtAttr(SQL_ATTR_ROW_ARRAY_SIZE, (void *) TDS_INT2PTR(ARRAY_SIZE), 0, "S");
228 :
229 20 : odbc_command("SELECT DISTINCT i FROM #tmp1");
230 20 : SQLFetch(odbc_stmt);
231 20 : test_name = "SQLSetStmtAttr";
232 : } else {
233 10 : CHKSetStmtAttr(SQL_ROWSET_SIZE, (void *) TDS_INT2PTR(ARRAY_SIZE), 0, "S");
234 10 : odbc_command("SELECT DISTINCT i FROM #tmp1");
235 10 : CHKExtendedFetch(SQL_FETCH_NEXT, 0, &len, NULL, "S");
236 10 : test_name = "SQLExtendedFetch";
237 : }
238 30 : SQLMoreResults(odbc_stmt);
239 :
240 30 : l = (unsigned long int) (len & 0xfffffffflu);
241 30 : len >>= 16;
242 30 : h = (unsigned long int) (len >> 16);
243 30 : if (h != 0 || l != ARRAY_SIZE) {
244 0 : fprintf(stderr, "Wrong number returned in rows high %lu(0x%lx) low %lu(0x%lx) test %s\n", h, h, l, l, test_name);
245 0 : exit(1);
246 : }
247 :
248 30 : if (!*p)
249 : break;
250 : }
251 :
252 10 : free(ids);
253 10 : free(id_lens);
254 10 : }
255 :
256 : int
257 10 : main(void)
258 : {
259 : /* this test is specifically testing for 64 bit platforms where SQLLEN is 64 bit */
260 : if (sizeof(SQLLEN) != 8) {
261 : printf("Not possible for this platform.\n");
262 : odbc_test_skipped();
263 : return 0;
264 : }
265 :
266 10 : odbc_use_version3 = 1;
267 10 : odbc_connect();
268 :
269 10 : odbc_command("create table #tmp1 (i int)");
270 :
271 10 : test_params();
272 10 : test_rows();
273 :
274 10 : odbc_disconnect();
275 10 : printf("Done\n");
276 : return 0;
277 : }
278 :
|
