]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/iodbc/execute.c
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Added OLE automation sample, changed BC++ makefiles
[wxWidgets.git] / src / iodbc / execute.c
... / ...
CommitLineData
1/** Invoke 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
30static void do_cursoropen(STMT_t FAR* pstmt)
31{
32 RETCODE retcode;
33 SWORD ncol;
34
35 pstmt->state = en_stmt_executed;
36
37 retcode = SQLNumResultCols( pstmt, &ncol );
38
39 if( retcode == SQL_SUCCESS
40 || retcode == SQL_SUCCESS_WITH_INFO )
41 {
42 if( ncol )
43 {
44 pstmt->state = en_stmt_cursoropen;
45 pstmt->cursor_state = en_stmt_cursor_opened;
46 }
47 else
48 {
49 pstmt->state = en_stmt_executed;
50 pstmt->cursor_state = en_stmt_cursor_no;
51 }
52 }
53}
54
55RETCODE SQL_API SQLExecute ( HSTMT hstmt )
56{
57 STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
58 HPROC hproc = SQL_NULL_HPROC;
59 RETCODE retcode;
60
61 int sqlstat = en_00000;
62
63 if( hstmt == SQL_NULL_HSTMT
64 || pstmt->hdbc == SQL_NULL_HDBC )
65 {
66 return SQL_INVALID_HANDLE;
67 }
68
69 /* check state */
70 if( pstmt->asyn_on == en_NullProc )
71 {
72 switch( pstmt->state )
73 {
74 case en_stmt_allocated:
75 sqlstat = en_S1010;
76 break;
77
78 case en_stmt_executed:
79 if( ! pstmt->prep_state )
80 {
81 sqlstat = en_S1010;
82 }
83 break;
84
85 case en_stmt_cursoropen:
86 if( ! pstmt->prep_state )
87 {
88 sqlstat = en_S1010;
89 }
90 break;
91
92 case en_stmt_fetched:
93 case en_stmt_xfetched:
94 if( ! pstmt->prep_state )
95 {
96 sqlstat = en_S1010;
97 }
98 else
99 {
100 sqlstat = en_24000;
101 }
102 break;
103
104 case en_stmt_needdata:
105 case en_stmt_mustput:
106 case en_stmt_canput:
107 sqlstat = en_S1010;
108 break;
109
110 default:
111 break;
112 }
113 }
114 else if( pstmt->asyn_on != en_Execute )
115 {
116 sqlstat = en_S1010;
117 }
118
119 if( sqlstat == en_00000 )
120 {
121 hproc = _iodbcdm_getproc( pstmt->hdbc, en_Execute );
122
123 if( hproc == SQL_NULL_HPROC )
124 {
125 sqlstat = en_IM001;
126 }
127 }
128
129 if( sqlstat != en_00000 )
130 {
131 PUSHSQLERR ( pstmt->herr, sqlstat );
132
133 return SQL_ERROR;
134 }
135
136 CALL_DRIVER ( pstmt->hdbc, retcode, hproc,
137 en_Execute, ( pstmt->dhstmt ) )
138
139#if 0
140 retcode = hproc ( pstmt->dhstmt );
141#endif
142
143 /* stmt state transition */
144 if( pstmt->asyn_on == en_Execute )
145 {
146 switch ( retcode )
147 {
148 case SQL_SUCCESS:
149 case SQL_SUCCESS_WITH_INFO:
150 case SQL_NEED_DATA:
151 case SQL_ERROR:
152 pstmt->asyn_on = en_NullProc;
153 break;
154
155 case SQL_STILL_EXECUTING:
156 default:
157 return retcode;
158 }
159 }
160
161 switch( pstmt->state )
162 {
163 case en_stmt_prepared:
164 switch( retcode )
165 {
166 case SQL_SUCCESS:
167 case SQL_SUCCESS_WITH_INFO:
168 do_cursoropen(hstmt);
169 break;
170
171 case SQL_NEED_DATA:
172 pstmt->state = en_stmt_needdata;
173 pstmt->need_on = en_Execute;
174 break;
175
176 case SQL_STILL_EXECUTING:
177 pstmt->asyn_on = en_Execute;
178 break;
179
180 default:
181 break;
182 }
183 break;
184
185 case en_stmt_executed:
186 switch( retcode )
187 {
188 case SQL_ERROR:
189 pstmt->state = en_stmt_allocated;
190 pstmt->cursor_state = en_stmt_cursor_no;
191 pstmt->prep_state = 0;
192 break;
193
194 case SQL_NEED_DATA:
195 pstmt->state = en_stmt_needdata;
196 pstmt->need_on = en_Execute;
197 break;
198
199 case SQL_STILL_EXECUTING:
200 pstmt->asyn_on = en_Execute;
201 break;
202
203 default:
204 break;
205 }
206 break;
207
208 default:
209 break;
210 }
211
212 return retcode;
213}
214
215RETCODE SQL_API SQLExecDirect (
216 HSTMT hstmt,
217 UCHAR FAR* szSqlStr,
218 SDWORD cbSqlStr )
219{
220 STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
221 HPROC hproc = SQL_NULL_HPROC;
222
223 int sqlstat = en_00000;
224 RETCODE retcode = SQL_SUCCESS;
225
226 if( hstmt == SQL_NULL_HSTMT
227 || pstmt->hdbc == SQL_NULL_HDBC )
228 {
229 return SQL_INVALID_HANDLE;
230 }
231
232 /* check arguments */
233 if( szSqlStr == NULL )
234 {
235 sqlstat = en_S1009;
236 }
237 else if( cbSqlStr < 0 && cbSqlStr != SQL_NTS )
238 {
239 sqlstat = en_S1090;
240 }
241
242 if( sqlstat != en_00000 )
243 {
244 PUSHSQLERR ( pstmt->herr, sqlstat );
245
246 return SQL_ERROR;
247 }
248
249 /* check state */
250 if( pstmt->asyn_on == en_NullProc )
251 {
252 switch ( pstmt->state )
253 {
254 case en_stmt_fetched:
255 case en_stmt_xfetched:
256 sqlstat = en_24000;
257 break;
258
259 case en_stmt_needdata:
260 case en_stmt_mustput:
261 case en_stmt_canput:
262 sqlstat = en_S1010;
263 break;
264
265 default:
266 break;
267 }
268 }
269 else if( pstmt->asyn_on != en_ExecDirect )
270 {
271 sqlstat = en_S1010;
272 }
273
274 if( sqlstat != en_00000 )
275 {
276 PUSHSQLERR ( pstmt->herr, sqlstat );
277
278 return SQL_ERROR;
279 }
280
281 hproc = _iodbcdm_getproc( pstmt->hdbc, en_ExecDirect);
282
283 if( hproc == SQL_NULL_HPROC )
284 {
285 PUSHSQLERR ( pstmt->herr, en_IM001 );
286
287 return SQL_ERROR;
288 }
289
290 CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_ExecDirect, (
291 pstmt->dhstmt, szSqlStr, cbSqlStr) )
292
293
294#if 0
295 retcode = hproc ( pstmt->dhstmt, szSqlStr, cbSqlStr );
296#endif
297
298 /* stmt state transition */
299 if( pstmt->asyn_on == en_ExecDirect )
300 {
301 switch ( retcode )
302 {
303 case SQL_SUCCESS:
304 case SQL_SUCCESS_WITH_INFO:
305 case SQL_NEED_DATA:
306 case SQL_ERROR:
307 pstmt->asyn_on = en_NullProc;
308 break;
309
310 case SQL_STILL_EXECUTING:
311 default:
312 return retcode;
313 }
314 }
315
316 if( pstmt->state <= en_stmt_executed )
317 {
318 switch( retcode )
319 {
320 case SQL_SUCCESS:
321 case SQL_SUCCESS_WITH_INFO:
322 do_cursoropen(hstmt);
323 break;
324
325 case SQL_NEED_DATA:
326 pstmt->state = en_stmt_needdata;
327 pstmt->need_on = en_ExecDirect;
328 break;
329
330 case SQL_STILL_EXECUTING:
331 pstmt->asyn_on = en_ExecDirect;
332 break;
333
334 case SQL_ERROR:
335 pstmt->state = en_stmt_allocated;
336 pstmt->cursor_state = en_stmt_cursor_no;
337 pstmt->prep_state = 0;
338 break;
339
340 default:
341 break;
342 }
343 }
344
345 return retcode;
346}
347
348RETCODE SQL_API SQLPutData(
349 HSTMT hstmt,
350 PTR rgbValue,
351 SDWORD cbValue )
352{
353 STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
354 HPROC hproc;
355 RETCODE retcode;
356
357 if( hstmt == SQL_NULL_HSTMT
358 || pstmt->hdbc == SQL_NULL_HDBC )
359 {
360 return SQL_INVALID_HANDLE;
361 }
362
363 /* check argument value */
364 if( rgbValue == NULL
365 && ( cbValue != SQL_DEFAULT_PARAM
366 && cbValue != SQL_NULL_DATA ) )
367 {
368 PUSHSQLERR ( pstmt->herr, en_S1009 );
369
370 return SQL_ERROR;
371 }
372
373 /* check state */
374 if( pstmt->asyn_on == en_NullProc )
375 {
376 if( pstmt->state <= en_stmt_xfetched )
377 {
378 PUSHSQLERR( pstmt->herr, en_S1010 );
379
380 return SQL_ERROR;
381 }
382 }
383 else if( pstmt->asyn_on != en_PutData )
384 {
385 PUSHSQLERR ( pstmt->herr, en_S1010 );
386
387 return SQL_ERROR;
388 }
389
390 /* call driver */
391 hproc = _iodbcdm_getproc( pstmt->hdbc, en_PutData );
392
393 if( hproc == SQL_NULL_HPROC )
394 {
395 PUSHSQLERR ( pstmt->herr, en_IM001 );
396
397 return SQL_ERROR;
398 }
399
400 CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_PutData, (
401 pstmt->dhstmt, rgbValue, cbValue ) )
402
403#if 0
404 retcode = hproc(pstmt->dhstmt, rgbValue, cbValue );
405#endif
406
407 /* state transition */
408 if( pstmt->asyn_on == en_PutData )
409 {
410 switch( retcode )
411 {
412 case SQL_SUCCESS:
413 case SQL_SUCCESS_WITH_INFO:
414 case SQL_ERROR:
415 pstmt->asyn_on = en_NullProc;
416 break;
417
418 case SQL_STILL_EXECUTING:
419 default:
420 return retcode;
421 }
422 }
423
424 /* must in mustput or canput states */
425 switch( retcode )
426 {
427 case SQL_SUCCESS:
428 case SQL_SUCCESS_WITH_INFO:
429 pstmt->state = en_stmt_canput;
430 break;
431
432 case SQL_ERROR:
433 switch( pstmt->need_on )
434 {
435 case en_ExecDirect:
436 pstmt->state = en_stmt_allocated;
437 pstmt->need_on = en_NullProc;
438 break;
439
440 case en_Execute:
441 if( pstmt->prep_state )
442 {
443 pstmt->state = en_stmt_prepared;
444 pstmt->need_on = en_NullProc;
445 }
446 break;
447
448 case en_SetPos:
449 /* Is this possible ???? */
450 pstmt->state = en_stmt_xfetched;
451 break;
452
453 default:
454 break;
455 }
456 break;
457
458 case SQL_STILL_EXECUTING:
459 pstmt->asyn_on = en_PutData;
460 break;
461
462 default:
463 break;
464 }
465
466 return retcode;
467}
468
469RETCODE SQL_API SQLParamData (
470 HSTMT hstmt,
471 PTR FAR* prgbValue )
472{
473 STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
474 HPROC hproc;
475 RETCODE retcode;
476
477 if( hstmt == SQL_NULL_HSTMT
478 || pstmt->hdbc == SQL_NULL_HDBC )
479 {
480 return SQL_INVALID_HANDLE;
481 }
482
483 /* check argument */
484
485 /* check state */
486 if( pstmt->asyn_on == en_NullProc )
487 {
488 if( pstmt->state <= en_stmt_xfetched )
489 {
490 PUSHSQLERR ( pstmt->herr, en_S1010 );
491
492 return SQL_ERROR;
493 }
494 }
495 else if( pstmt->asyn_on != en_ParamData )
496 {
497 PUSHSQLERR ( pstmt->herr, en_S1010 );
498
499 return SQL_ERROR;
500 }
501
502 /* call driver */
503 hproc = _iodbcdm_getproc( pstmt->hdbc, en_ParamData );
504
505 if( hproc == SQL_NULL_HPROC )
506 {
507 PUSHSQLERR ( pstmt->herr, en_IM001 );
508
509 return SQL_ERROR;
510 }
511
512 CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_ParamData, (
513 pstmt->dhstmt, prgbValue ) )
514
515#if 0
516 retcode = hproc ( pstmt->dhstmt, prgbValue );
517#endif
518
519 /* state transition */
520 if( pstmt->asyn_on == en_ParamData )
521 {
522 switch( retcode )
523 {
524 case SQL_SUCCESS:
525 case SQL_SUCCESS_WITH_INFO:
526 case SQL_ERROR:
527 pstmt->asyn_on = en_NullProc;
528 break;
529
530 case SQL_STILL_EXECUTING:
531 default:
532 return retcode;
533 }
534 }
535
536 if( pstmt->state < en_stmt_needdata )
537 {
538 return retcode;
539 }
540
541 switch( retcode )
542 {
543 case SQL_ERROR:
544 switch( pstmt->need_on )
545 {
546 case en_ExecDirect:
547 pstmt->state = en_stmt_allocated;
548 break;
549
550 case en_Execute:
551 pstmt->state = en_stmt_prepared;
552 break;
553
554 case en_SetPos:
555 pstmt->state = en_stmt_xfetched;
556 pstmt->cursor_state
557 = en_stmt_cursor_xfetched;
558 break;
559
560 default:
561 break;
562 }
563 pstmt->need_on = en_NullProc;
564 break;
565
566 case SQL_SUCCESS:
567 case SQL_SUCCESS_WITH_INFO:
568 switch( pstmt->state )
569 {
570 case en_stmt_needdata:
571 pstmt->state = en_stmt_mustput;
572 break;
573
574 case en_stmt_canput:
575 switch( pstmt->need_on )
576 {
577 case en_SetPos:
578 pstmt->state
579 = en_stmt_xfetched;
580 pstmt->cursor_state
581 = en_stmt_cursor_xfetched;
582 break;
583
584 case en_ExecDirect:
585 case en_Execute:
586 do_cursoropen(hstmt);
587 break;
588
589 default:
590 break;
591 }
592 break;
593
594 default:
595 break;
596 }
597 pstmt->need_on = en_NullProc;
598 break;
599
600 case SQL_NEED_DATA:
601 pstmt->state = en_stmt_mustput;
602 break;
603
604 default:
605 break;
606 }
607
608 return retcode;
609}
610
611
612RETCODE SQL_API SQLNumParams (
613 HSTMT hstmt,
614 SWORD FAR* pcpar )
615{
616 STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
617 HPROC hproc;
618 RETCODE retcode;
619
620 if( hstmt == SQL_NULL_HSTMT
621 || pstmt->hdbc == SQL_NULL_HDBC )
622 {
623 return SQL_INVALID_HANDLE;
624 }
625
626 /* check argument */
627
628 /* check state */
629 if( pstmt->asyn_on == en_NullProc )
630 {
631 switch( pstmt->state )
632 {
633 case en_stmt_allocated:
634 case en_stmt_needdata:
635 case en_stmt_mustput:
636 case en_stmt_canput:
637 PUSHSQLERR ( pstmt->herr, en_S1010 );
638 return SQL_ERROR;
639
640 default:
641 break;
642 }
643 }
644 else if( pstmt->asyn_on != en_NumParams )
645 {
646 PUSHSQLERR ( pstmt->herr, en_S1010 );
647
648 return SQL_ERROR;
649 }
650
651 /* call driver */
652 hproc = _iodbcdm_getproc ( pstmt->hdbc, en_NumParams );
653
654 if( hproc == SQL_NULL_HPROC )
655 {
656 PUSHSQLERR ( pstmt->herr, en_IM001 );
657
658 return SQL_ERROR;
659 }
660
661 CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_NumParams, (
662 pstmt->dhstmt, pcpar) )
663
664
665#if 0
666 retcode = hproc ( pstmt->dhstmt, pcpar );
667#endif
668
669 /* state transition */
670 if( pstmt->asyn_on == en_NumParams )
671 {
672 switch ( retcode )
673 {
674 case SQL_SUCCESS:
675 case SQL_SUCCESS_WITH_INFO:
676 case SQL_ERROR:
677 break;
678
679 default:
680 return retcode;
681 }
682 }
683
684 if( retcode == SQL_STILL_EXECUTING )
685 {
686 pstmt->asyn_on = en_NumParams;
687 }
688
689 return retcode;
690}
691
692RETCODE SQL_API SQLDescribeParam (
693 HSTMT hstmt,
694 UWORD ipar,
695 SWORD FAR* pfSqlType,
696 UDWORD FAR* pcbColDef,
697 SWORD FAR* pibScale,
698 SWORD FAR* pfNullable )
699{
700 STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
701 HPROC hproc;
702 RETCODE retcode;
703
704 if( hstmt == SQL_NULL_HSTMT
705 || pstmt->hdbc == SQL_NULL_HDBC )
706 {
707 return SQL_INVALID_HANDLE;
708 }
709
710 /* check argument */
711 if( ipar == 0 )
712 {
713 PUSHSQLERR ( pstmt->herr, en_S1093 );
714
715 return SQL_ERROR;
716 }
717
718 /* check state */
719 if( pstmt->asyn_on == en_NullProc )
720 {
721 switch( pstmt->state )
722 {
723 case en_stmt_allocated:
724 case en_stmt_needdata:
725 case en_stmt_mustput:
726 case en_stmt_canput:
727 PUSHSQLERR ( pstmt->herr, en_S1010 );
728 return SQL_ERROR;
729
730 default:
731 break;
732 }
733 }
734 else if( pstmt->asyn_on != en_DescribeParam )
735 {
736 PUSHSQLERR ( pstmt->herr, en_S1010 );
737
738 return SQL_ERROR;
739 }
740
741 /* call driver */
742 hproc = _iodbcdm_getproc ( pstmt->hdbc, en_DescribeParam );
743
744 if( hproc == SQL_NULL_HPROC )
745 {
746 PUSHSQLERR ( pstmt->herr, en_IM001 );
747
748 return SQL_ERROR;
749 }
750
751 CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_DescribeParam, (
752 pstmt->dhstmt,
753 ipar,
754 pfSqlType,
755 pcbColDef,
756 pibScale,
757 pfNullable ) )
758
759#if 0
760 retcode = hproc(pstmt->dhstmt,
761 ipar,
762 pfSqlType,
763 pcbColDef,
764 pibScale,
765 pfNullable );
766#endif
767
768 /* state transition */
769 if( pstmt->asyn_on == en_DescribeParam )
770 {
771 switch ( retcode )
772 {
773 case SQL_SUCCESS:
774 case SQL_SUCCESS_WITH_INFO:
775 case SQL_ERROR:
776 break;
777
778 default:
779 return retcode;
780 }
781 }
782
783 if( retcode == SQL_STILL_EXECUTING )
784 {
785 pstmt->asyn_on = en_DescribeParam;
786 }
787
788 return retcode;
789}
wxWidgets (Impactor)