]> git.saurik.com Git - wxWidgets.git/blame - src/iodbc/prepare.c
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fixes
[wxWidgets.git] / src / iodbc / prepare.c
CommitLineData
1a6944fd
RR		 1/** Prepare a query
2
3 Copyright (C) 1995 by Ke Jin <kejin@empress.com>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14**/
15
16#include <../iodbc/iodbc.h>
17
18#include <../iodbc/isql.h>
19#include <../iodbc/isqlext.h>
20
21#include <../iodbc/dlproc.h>
22
23#include <../iodbc/herr.h>
24#include <../iodbc/henv.h>
25#include <../iodbc/hdbc.h>
26#include <../iodbc/hstmt.h>
27
28#include <../iodbc/itrace.h>
29
0d73e5a1 30RETCODE SQL_API SQLPrepare (
1a6944fd
RR		 31 HSTMT hstmt,
32 UCHAR FAR* szSqlStr,
33 SDWORD cbSqlStr )
34{
35 STMT_t FAR* pstmt = (STMT_t*)hstmt;
36
37 HPROC hproc = SQL_NULL_HPROC;
38 RETCODE retcode = SQL_SUCCESS;
39 int sqlstat = en_00000;
40
41 if( hstmt == SQL_NULL_HSTMT
42 || pstmt->hdbc == SQL_NULL_HDBC )
43 {
44 return SQL_INVALID_HANDLE;
45 }
46
47 /* check state */
48 if( pstmt->asyn_on == en_NullProc )
49 {
50 /* not on asyn state */
51 switch( pstmt->state )
52 {
53 case en_stmt_fetched:
54 case en_stmt_xfetched:
55 sqlstat = en_24000;
56 break;
57
58 case en_stmt_needdata:
59 case en_stmt_mustput:
60 case en_stmt_canput:
61 sqlstat = en_S1010;
62 break;
63
64 default:
65 break;
66 }
67 }
68 else if( pstmt->asyn_on != en_Prepare )
69 {
70 /* asyn on other */
71 sqlstat = en_S1010;
72 }
73
74 if( sqlstat != en_00000 )
75 {
76 PUSHSQLERR ( pstmt->herr, sqlstat );
77
78 return SQL_ERROR;
79 }
80
81 if( szSqlStr == NULL )
82 {
83 PUSHSQLERR ( pstmt->herr, en_S1009 );
84
85 return SQL_ERROR;
86 }
87
88 if( cbSqlStr < 0 && cbSqlStr != SQL_NTS )
89 {
90 PUSHSQLERR ( pstmt->herr, en_S1090 );
91
92 return SQL_ERROR;
93 }
94
95 hproc = _iodbcdm_getproc( pstmt->hdbc, en_Prepare );
96
97 if( hproc == SQL_NULL_HPROC )
98 {
99 PUSHSQLERR ( pstmt->herr, en_IM001 );
100 return SQL_ERROR;
101 }
102
103 CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_Prepare, (
104 pstmt->dhstmt, szSqlStr, cbSqlStr) )
105
106#if 0
107 retcode = hproc ( pstmt->dhstmt, szSqlStr, cbSqlStr );
108#endif
109
110 /* stmt state transition */
111 if( pstmt->asyn_on == en_Prepare )
112 {
113 switch( retcode )
114 {
115 case SQL_SUCCESS:
116 case SQL_SUCCESS_WITH_INFO:
117 case SQL_ERROR:
118 pstmt->asyn_on = en_NullProc;
119 return retcode;
120
121 case SQL_STILL_EXECUTING:
122 default:
123 return retcode;
124 }
125 }
126
127 switch( retcode )
128 {
129 case SQL_STILL_EXECUTING:
130 pstmt->asyn_on = en_Prepare;
131 break;
132
133 case SQL_SUCCESS:
134 case SQL_SUCCESS_WITH_INFO:
135 pstmt->state = en_stmt_prepared;
136 pstmt->prep_state = 1;
137 break;
138
139 case SQL_ERROR:
140 switch( pstmt->state )
141 {
142 case en_stmt_prepared:
143 case en_stmt_executed:
144 pstmt->state = en_stmt_allocated;
145 pstmt->prep_state = 0;
146 break;
147
148 default:
149 break;
150 }
151
152 default:
153 break;
154 }
155
156 return retcode;
157}
158
159RETCODE SQL_API SQLSetCursorName (
160 HSTMT hstmt,
161 UCHAR FAR* szCursor,
162 SWORD cbCursor )
163{
164 STMT_t FAR* pstmt = (STMT_t*)hstmt;
165 HPROC hproc = SQL_NULL_HPROC;
166
167 RETCODE retcode = SQL_SUCCESS;
168 int sqlstat = en_00000;
169
170 if( hstmt == SQL_NULL_HSTMT
171 || pstmt->hdbc == SQL_NULL_HDBC )
172 {
173 return SQL_INVALID_HANDLE;
174 }
175
176 if( szCursor == NULL )
177 {
178 PUSHSQLERR ( pstmt->herr, en_S1009 );
179
180 return SQL_ERROR;
181 }
182
183 if( cbCursor < 0 && cbCursor != SQL_NTS )
184 {
185 PUSHSQLERR ( pstmt->herr, en_S1090 );
186
187 return SQL_ERROR;
188 }
189
190 /* check state */
191 if( pstmt->asyn_on != en_NullProc )
192 {
193 sqlstat = en_S1010;
194 }
195 else
196 {
197 switch( pstmt->state )
198 {
199 case en_stmt_executed:
200 case en_stmt_cursoropen:
201 case en_stmt_fetched:
202 case en_stmt_xfetched:
203 sqlstat = en_24000;
204 break;
205
206 case en_stmt_needdata:
207 case en_stmt_mustput:
208 case en_stmt_canput:
209 sqlstat = en_S1010;
210 break;
211
212 default:
213 break;
214 }
215 }
216
217 if( sqlstat != en_00000 )
218 {
219 PUSHSQLERR ( pstmt->herr, sqlstat );
220
221 return SQL_ERROR;
222 }
223
224 hproc = _iodbcdm_getproc( pstmt->hdbc, en_SetCursorName);
225
226 if( hproc == SQL_NULL_HPROC )
227 {
228 PUSHSQLERR ( pstmt->herr, en_IM001 );
229
230 return SQL_ERROR;
231 }
232
233 CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_SetCursorName, (
234 pstmt->dhstmt, szCursor, cbCursor ) )
235
236#if 0
237 retcode = hproc ( pstmt->dhstmt, szCursor, cbCursor );
238#endif
239
240 if( retcode == SQL_SUCCESS
241 || retcode == SQL_SUCCESS_WITH_INFO )
242 {
243 pstmt->cursor_state = en_stmt_cursor_named;
244 }
245
246 return retcode;
247}
248
249RETCODE SQL_API SQLBindParameter (
250 HSTMT hstmt,
251 UWORD ipar,
252 SWORD fParamType,
253 SWORD fCType,
254 SWORD fSqlType,
255 UDWORD cbColDef,
256 SWORD ibScale,
257 PTR rgbValue,
258 SDWORD cbValueMax,
259 SDWORD FAR* pcbValue )
260{
261 STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
262 HPROC hproc = SQL_NULL_HPROC;
263
264 int sqlstat = en_00000;
265 RETCODE retcode = SQL_SUCCESS;
266
267 if( hstmt == SQL_NULL_HSTMT
268 || pstmt->hdbc == SQL_NULL_HDBC )
269 {
270 return SQL_INVALID_HANDLE;
271 }
272
273 /* check param */
274 if( fSqlType > SQL_TYPE_MAX
275 || ( fSqlType < SQL_TYPE_MIN
276 && fSqlType > SQL_TYPE_DRIVER_START ) )
277 /* Note: SQL_TYPE_DRIVER_START is a nagtive number
278 * So, we use ">" */
279 {
280 sqlstat = en_S1004;
281 }
282 else if ( ipar < 1 )
283 {
284 sqlstat = en_S1093;
285 }
286 else if( (rgbValue == NULL && pcbValue == NULL)
287 && fParamType != SQL_PARAM_OUTPUT )
288 {
289 sqlstat = en_S1009;
290 /* This means, I allow output to nowhere
291 * (i.e. * junk output result). But I can't
292 * allow input from nowhere.
293 */
294 }
295/**********
296 else if( cbValueMax < 0L && cbValueMax != SQL_SETPARAM_VALUE_MAX )
297 {
298 sqlstat = en_S1090;
299 }
300**********/
301 else if( fParamType != SQL_PARAM_INPUT
302 && fParamType != SQL_PARAM_OUTPUT
303 && fParamType != SQL_PARAM_INPUT_OUTPUT )
304 {
305 sqlstat = en_S1105;
306 }
307 else
308 {
309 switch( fCType )
310 {
311 case SQL_C_DEFAULT:
312 case SQL_C_CHAR:
313 case SQL_C_BINARY:
314 case SQL_C_BIT:
315 case SQL_C_TINYINT:
316 case SQL_C_STINYINT:
317 case SQL_C_UTINYINT:
318 case SQL_C_SHORT:
319 case SQL_C_SSHORT:
320 case SQL_C_USHORT:
321 case SQL_C_LONG:
322 case SQL_C_SLONG:
323 case SQL_C_ULONG:
324 case SQL_C_FLOAT:
325 case SQL_C_DOUBLE:
326 case SQL_C_DATE:
327 case SQL_C_TIME:
328 case SQL_C_TIMESTAMP:
329 break;
330
331 default:
332 sqlstat = en_S1003;
333 break;
334 }
335 }
336
337 if(sqlstat != en_00000 )
338 {
339 PUSHSQLERR ( pstmt->herr, sqlstat );
340
341 return SQL_ERROR;
342 }
343
344 /* check state */
345 if( pstmt->state >= en_stmt_needdata
346 || pstmt->asyn_on != en_NullProc )
347 {
348 PUSHSQLERR ( pstmt->herr, en_S1010 );
349
350 retcode = SQL_ERROR;
351 }
352
353 hproc = _iodbcdm_getproc( pstmt->hdbc, en_BindParameter );
354
355 if( hproc == SQL_NULL_HPROC )
356 {
357 PUSHSQLERR ( pstmt->herr, en_IM001 );
358
359 return SQL_ERROR;
360 }
361
362 CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_BindParameter, (
363 pstmt->dhstmt, ipar, fParamType, fCType, fSqlType,
364 cbColDef, ibScale, rgbValue, cbValueMax, pcbValue ) )
365
366#if 0
367 retcode = hproc(pstmt->dhstmt, ipar, fParamType, fCType, fSqlType,
368 cbColDef, ibScale, rgbValue, cbValueMax, pcbValue );
369#endif
370
371 return retcode;
372}
373
374RETCODE SQL_API SQLParamOptions(
375 HSTMT hstmt,
376 UDWORD crow,
377 UDWORD FAR* pirow )
378{
379 STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
380 HPROC hproc;
381 RETCODE retcode;
382
383 if( hstmt == SQL_NULL_HSTMT
384 || pstmt->hdbc == SQL_NULL_HDBC )
385 {
386 return SQL_INVALID_HANDLE;
387 }
388
389 if( crow == (UDWORD)0UL )
390 {
391 PUSHSQLERR ( pstmt->herr, en_S1107 );
392
393 return SQL_ERROR;
394 }
395
396 if( pstmt->state >= en_stmt_needdata
397 || pstmt->asyn_on != en_NullProc )
398 {
399 PUSHSQLERR ( pstmt->herr, en_S1010 );
400
401 return SQL_ERROR;
402 }
403
404 hproc = _iodbcdm_getproc ( pstmt->hdbc, en_ParamOptions );
405
406 if( hproc == SQL_NULL_HPROC )
407 {
408 PUSHSQLERR ( pstmt->herr, en_IM001 );
409
410 return SQL_ERROR;
411 }
412
413 CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_ParamOptions, (
414 pstmt->dhstmt, crow, pirow) )
415
416#if 0
417 retcode = hproc ( pstmt->dhstmt, crow, pirow );
418#endif
419
420 return retcode;
421}
422
423RETCODE SQL_API SQLSetScrollOptions(
424 HSTMT hstmt,
425 UWORD fConcurrency,
426 SDWORD crowKeyset,
427 UWORD crowRowset )
428{
429 STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
430 HPROC hproc;
431 int sqlstat = en_00000;
432 RETCODE retcode;
433
434 if( hstmt == SQL_NULL_HSTMT
435 || pstmt->hdbc == SQL_NULL_HDBC )
436 {
437 return SQL_INVALID_HANDLE;
438 }
439
440 for(;;)
441 {
442 if( crowRowset == (UWORD)0 )
443 {
444 sqlstat = en_S1107;
445 break;
446 }
447
448 if( crowKeyset > (SDWORD)0L && crowKeyset < (SDWORD)crowRowset )
449 {
450 sqlstat = en_S1107;
451 break;
452 }
453
454 if( crowKeyset < 1 )
455 {
456 if( crowKeyset != SQL_SCROLL_FORWARD_ONLY
457 && crowKeyset != SQL_SCROLL_STATIC
458 && crowKeyset != SQL_SCROLL_KEYSET_DRIVEN
459 && crowKeyset != SQL_SCROLL_DYNAMIC )
460 {
461 sqlstat = en_S1107;
462 break;
463 }
464 }
465
466 if( fConcurrency != SQL_CONCUR_READ_ONLY
467 && fConcurrency != SQL_CONCUR_LOCK
468 && fConcurrency != SQL_CONCUR_ROWVER
469 && fConcurrency != SQL_CONCUR_VALUES )
470 {
471 sqlstat = en_S1108;
472 break;
473 }
474
475 if( pstmt->state != en_stmt_allocated )
476 {
477 sqlstat = en_S1010;
478 break;
479 }
480
481 hproc = _iodbcdm_getproc( pstmt->hdbc, en_SetScrollOptions );
482
483 if( hproc == SQL_NULL_HPROC )
484 {
485 sqlstat = en_IM001;
486 break;
487 }
488
489 sqlstat = en_00000;
490 if( 1 ) /* turn off solaris warning message */
491 break;
492 }
493
494 if( sqlstat != en_00000 )
495 {
496 PUSHSQLERR ( pstmt->herr, sqlstat );
497
498 return SQL_ERROR;
499 }
500
501 CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_SetScrollOptions, (
502 pstmt->dhstmt,
503 fConcurrency,
504 crowKeyset,
505 crowRowset ) )
506
507#if 0
508 retcode = hproc(pstmt->dhstmt,
509 fConcurrency,
510 crowKeyset,
511 crowRowset );
512#endif
513
514 return retcode;
515}
516
517RETCODE SQL_API SQLSetParam (
518 HSTMT hstmt,
519 UWORD ipar,
520 SWORD fCType,
521 SWORD fSqlType,
522 UDWORD cbColDef,
523 SWORD ibScale,
524 PTR rgbValue,
525 SDWORD FAR *pcbValue)
526{
527 return SQLBindParameter(hstmt,
528 ipar,
529 (SWORD)SQL_PARAM_INPUT_OUTPUT,
530 fCType,
531 fSqlType,
532 cbColDef,
533 ibScale,
534 rgbValue,
535 SQL_SETPARAM_VALUE_MAX,
536 pcbValue );
537}
wxWidgets (Impactor)