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 48 : check_ipd_params(void)
21 : {
22 : void *ptr, *ptr2;
23 : SQLHDESC desc;
24 : SQLINTEGER ind;
25 :
26 48 : CHKGetStmtAttr(SQL_ATTR_PARAMS_PROCESSED_PTR, &ptr, sizeof(ptr), NULL, "S");
27 :
28 : /* get IPD */
29 48 : CHKGetStmtAttr(SQL_ATTR_IMP_PARAM_DESC, &desc, sizeof(desc), &ind, "S");
30 :
31 48 : CHKGetDescField(desc, 0, SQL_DESC_ROWS_PROCESSED_PTR, &ptr2, sizeof(ptr2), &ind, "S");
32 :
33 48 : if (ptr != ptr2) {
34 0 : fprintf(stderr, "IPD inconsistency ptr %p ptr2 %p\n", ptr, ptr2);
35 0 : exit(1);
36 : }
37 48 : }
38 :
39 : static void
40 16 : set_ipd_params1(SQLULEN *ptr)
41 : {
42 16 : CHKSetStmtAttr(SQL_ATTR_PARAMS_PROCESSED_PTR, ptr, 0, "S");
43 16 : }
44 :
45 : static void
46 16 : set_ipd_params2(SQLULEN *ptr)
47 : {
48 : SQLHDESC desc;
49 : SQLINTEGER ind;
50 :
51 : /* get IPD */
52 16 : CHKGetStmtAttr(SQL_ATTR_IMP_PARAM_DESC, &desc, sizeof(desc), &ind, "S");
53 :
54 16 : CHKSetDescField(desc, 1, SQL_DESC_ROWS_PROCESSED_PTR, ptr, 0, "S");
55 16 : }
56 :
57 : static void
58 16 : set_ipd_params3(SQLULEN *ptr)
59 : {
60 16 : CHKParamOptions(2, ptr, "S");
61 16 : }
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 8 : test_params(void)
76 : {
77 : #define ARRAY_SIZE 2
78 : const rows_set_t *p;
79 : SQLULEN len;
80 8 : SQLUINTEGER *ids = MALLOC_N(SQLUINTEGER,ARRAY_SIZE);
81 8 : SQLLEN *id_lens = MALLOC_N(SQLLEN,ARRAY_SIZE);
82 : unsigned long int h, l;
83 : unsigned int n;
84 :
85 : prepare_something();
86 :
87 24 : for (n = 0; n < ARRAY_SIZE; ++n) {
88 16 : ids[n] = n;
89 16 : id_lens[n] = 0;
90 : }
91 :
92 : /* test setting just some test pointers */
93 8 : set_ipd_params1((SQLULEN *) TDS_INT2PTR(0x01020304));
94 8 : check_ipd_params();
95 8 : set_ipd_params2((SQLULEN *) TDS_INT2PTR(0xabcdef12));
96 8 : check_ipd_params();
97 8 : set_ipd_params3((SQLULEN *) TDS_INT2PTR(0x87654321));
98 8 : check_ipd_params();
99 :
100 : /* now see results */
101 32 : for (p = param_set; *p != NULL; ++p) {
102 24 : odbc_reset_statement();
103 : len = 0xdeadbeef;
104 : len <<= 16;
105 : len <<= 16;
106 24 : len |= 12345678;
107 :
108 24 : (*p)(&len);
109 24 : check_ipd_params();
110 :
111 24 : CHKSetStmtAttr(SQL_ATTR_PARAMSET_SIZE, (void *) TDS_INT2PTR(ARRAY_SIZE), 0, "S");
112 24 : CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 5, 0, ids, 0, id_lens, "S");
113 :
114 24 : odbc_command("INSERT INTO #tmp1(i) VALUES(?)");
115 24 : SQLMoreResults(odbc_stmt);
116 72 : for (n = 0; n < ARRAY_SIZE; ++n)
117 48 : SQLMoreResults(odbc_stmt);
118 24 : l = (unsigned long int) (len & 0xfffffffflu);
119 24 : len >>= 16;
120 24 : h = (unsigned long int) (len >> 16);
121 24 : 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 8 : free(ids);
128 8 : free(id_lens);
129 8 : }
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 40 : check_ird_params(void)
139 : {
140 : void *ptr, *ptr2;
141 : SQLHDESC desc;
142 : SQLINTEGER ind;
143 :
144 40 : CHKGetStmtAttr(SQL_ATTR_ROWS_FETCHED_PTR, &ptr, sizeof(ptr), NULL, "S");
145 :
146 : /* get IRD */
147 40 : CHKGetStmtAttr(SQL_ATTR_IMP_ROW_DESC, &desc, sizeof(desc), &ind, "S");
148 :
149 40 : CHKGetDescField(desc, 0, SQL_DESC_ROWS_PROCESSED_PTR, &ptr2, sizeof(ptr2), &ind, "S");
150 :
151 40 : if (ptr != ptr2) {
152 0 : fprintf(stderr, "IRD inconsistency ptr %p ptr2 %p\n", ptr, ptr2);
153 0 : exit(1);
154 : }
155 40 : }
156 :
157 : static void
158 16 : set_ird_params1(SQLULEN *ptr)
159 : {
160 16 : CHKSetStmtAttr(SQL_ATTR_ROWS_FETCHED_PTR, ptr, 0, "S");
161 16 : }
162 :
163 : static void
164 16 : set_ird_params2(SQLULEN *ptr)
165 : {
166 : SQLHDESC desc;
167 : SQLINTEGER ind;
168 :
169 : /* get IRD */
170 16 : CHKGetStmtAttr(SQL_ATTR_IMP_ROW_DESC, &desc, sizeof(desc), &ind, "S");
171 :
172 16 : CHKSetDescField(desc, 1, SQL_DESC_ROWS_PROCESSED_PTR, ptr, 0, "S");
173 16 : }
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 8 : test_rows(void)
185 : {
186 : const rows_set_t *p;
187 : SQLULEN len;
188 8 : SQLUINTEGER *ids = MALLOC_N(SQLUINTEGER,ARRAY_SIZE);
189 8 : SQLLEN *id_lens = MALLOC_N(SQLLEN,ARRAY_SIZE);
190 : unsigned long int h, l;
191 : unsigned int n;
192 :
193 : prepare_something();
194 :
195 24 : for (n = 0; n < ARRAY_SIZE; ++n) {
196 16 : ids[n] = n;
197 16 : id_lens[n] = 0;
198 : }
199 :
200 : /* test setting just some test pointers */
201 8 : set_ird_params1((SQLULEN *) TDS_INT2PTR(0x01020304));
202 8 : check_ird_params();
203 8 : set_ird_params2((SQLULEN *) TDS_INT2PTR(0xabcdef12));
204 8 : check_ird_params();
205 :
206 : /* now see results */
207 24 : for (p = row_set; ; ++p) {
208 24 : const char *test_name = NULL;
209 :
210 24 : odbc_reset_statement();
211 : prepare_something();
212 : len = 0xdeadbeef;
213 : len <<= 16;
214 : len <<= 16;
215 24 : len |= 12345678;
216 24 : if (*p)
217 16 : (*p)(&len);
218 24 : 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 24 : CHKBindCol(1, SQL_C_ULONG, ids, 0, id_lens, "S");
226 24 : if (*p) {
227 16 : CHKSetStmtAttr(SQL_ATTR_ROW_ARRAY_SIZE, (void *) TDS_INT2PTR(ARRAY_SIZE), 0, "S");
228 :
229 16 : odbc_command("SELECT DISTINCT i FROM #tmp1");
230 16 : SQLFetch(odbc_stmt);
231 16 : test_name = "SQLSetStmtAttr";
232 : } else {
233 8 : CHKSetStmtAttr(SQL_ROWSET_SIZE, (void *) TDS_INT2PTR(ARRAY_SIZE), 0, "S");
234 8 : odbc_command("SELECT DISTINCT i FROM #tmp1");
235 8 : CHKExtendedFetch(SQL_FETCH_NEXT, 0, &len, NULL, "S");
236 8 : test_name = "SQLExtendedFetch";
237 : }
238 24 : SQLMoreResults(odbc_stmt);
239 :
240 24 : l = (unsigned long int) (len & 0xfffffffflu);
241 24 : len >>= 16;
242 24 : h = (unsigned long int) (len >> 16);
243 24 : 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 24 : if (!*p)
249 : break;
250 : }
251 :
252 8 : free(ids);
253 8 : free(id_lens);
254 8 : }
255 :
256 : int
257 8 : 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 8 : odbc_use_version3 = 1;
267 8 : odbc_connect();
268 :
269 8 : odbc_command("create table #tmp1 (i int)");
270 :
271 8 : test_params();
272 8 : test_rows();
273 :
274 8 : odbc_disconnect();
275 8 : printf("Done\n");
276 : return 0;
277 : }
278 :
|
