]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/iodbc/hdbc.c
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
minValue and maxValue are interpreted correctly in SetRange() (were inversed)
[wxWidgets.git] / src / iodbc / hdbc.c
... / ...
CommitLineData
1/** data source connect object management functions
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#include <stdio.h>
30
31extern RETCODE _iodbcdm_driverunload();
32
33RETCODE SQL_API SQLAllocConnect(
34 HENV henv,
35 HDBC FAR* phdbc )
36{
37 GENV_t FAR* genv = (GENV_t FAR*)henv;
38 DBC_t FAR* pdbc;
39
40#if (ODBCVER >= 0x0300)
41 if( henv == SQL_NULL_HENV
42 || genv->type != SQL_HANDLE_ENV )
43#else
44 if( henv == SQL_NULL_HENV )
45#endif
46 {
47 return SQL_INVALID_HANDLE;
48 }
49
50 if( phdbc == NULL )
51 {
52 PUSHSQLERR ( genv->herr, en_S1009 );
53
54 return SQL_ERROR;
55 }
56
57 pdbc = (DBC_t FAR*)MEM_ALLOC (sizeof(DBC_t));
58
59 if( pdbc == NULL )
60 {
61 *phdbc = SQL_NULL_HDBC;
62
63 PUSHSQLERR ( genv->herr, en_S1001 );
64
65 return SQL_ERROR;
66 }
67
68#if (ODBCVER >= 0x0300)
69 pdbc->type = SQL_HANDLE_DBC;
70#endif
71 /* insert this dbc entry into the link list */
72 pdbc->next = genv->hdbc;
73 genv->hdbc = pdbc;
74 pdbc->genv = henv;
75
76 pdbc->henv = SQL_NULL_HENV;
77 pdbc->hstmt= SQL_NULL_HSTMT;
78 pdbc->herr = SQL_NULL_HERR;
79 pdbc->dhdbc= SQL_NULL_HDBC;
80 pdbc->state= en_dbc_allocated;
81 pdbc->trace = 0;
82 pdbc->tstm = NULL;
83 pdbc->tfile = NULL;
84
85 /* set connect options to default values */
86 pdbc->access_mode = SQL_MODE_DEFAULT;
87 pdbc->autocommit = SQL_AUTOCOMMIT_DEFAULT;
88 pdbc->current_qualifier = NULL;
89 pdbc->login_timeout = 0UL;
90 pdbc->odbc_cursors = SQL_CUR_DEFAULT;
91 pdbc->packet_size = 0UL;
92 pdbc->quiet_mode = (UDWORD)NULL;
93 pdbc->txn_isolation = SQL_TXN_READ_UNCOMMITTED;
94 pdbc->cb_commit = (SWORD)SQL_CB_DELETE;
95 pdbc->cb_rollback = (SWORD)SQL_CB_DELETE;
96
97 *phdbc = (HDBC)pdbc;
98
99 return SQL_SUCCESS;
100}
101
102RETCODE SQL_API SQLFreeConnect( HDBC hdbc )
103{
104 GENV_t FAR* genv;
105 DBC_t FAR* pdbc = (DBC_t FAR*)hdbc;
106 DBC_t FAR* tpdbc;
107
108 if( hdbc == SQL_NULL_HDBC )
109 {
110 return SQL_INVALID_HANDLE;
111 }
112
113 /* check state */
114 if( pdbc->state != en_dbc_allocated )
115 {
116 PUSHSQLERR ( pdbc->herr, en_S1010 );
117
118 return SQL_ERROR;
119 }
120
121 genv = (GENV_t FAR*)pdbc->genv;
122
123 for( tpdbc = (DBC_t FAR*)genv->hdbc;
124 tpdbc != NULL;
125 tpdbc = tpdbc->next )
126 {
127 if( pdbc == tpdbc )
128 {
129 genv->hdbc = pdbc->next;
130 break;
131 }
132
133 if( pdbc == tpdbc->next )
134 {
135 tpdbc->next = pdbc->next;
136 break;
137 }
138 }
139
140 /* free this dbc */
141 _iodbcdm_driverunload(pdbc);
142 _iodbcdm_freesqlerrlist( pdbc->herr );
143
144 if( pdbc->tfile )
145 {
146 MEM_FREE( pdbc->tfile );
147 }
148
149 SQLSetConnectOption( pdbc, SQL_OPT_TRACE, SQL_OPT_TRACE_OFF);
150
151 MEM_FREE ( pdbc );
152
153 return SQL_SUCCESS;
154}
155
156RETCODE SQL_API SQLSetConnectOption(
157 HDBC hdbc,
158 UWORD fOption,
159 UDWORD vParam )
160{
161/* GENV_t FAR* genv; */
162 DBC_t FAR* pdbc = (DBC_t FAR*)hdbc;
163 STMT_t FAR* pstmt;
164 HPROC hproc = SQL_NULL_HPROC;
165 int sqlstat = en_00000;
166 RETCODE retcode = SQL_SUCCESS;
167
168 if( hdbc == SQL_NULL_HDBC )
169 {
170 return SQL_INVALID_HANDLE;
171 }
172
173 /* check option */
174 if( fOption < SQL_CONN_OPT_MIN
175 || ( fOption > SQL_CONN_OPT_MAX
176 && fOption < SQL_CONNECT_OPT_DRVR_START ) )
177 {
178 PUSHSQLERR ( pdbc->herr, en_S1092 );
179
180 return SQL_ERROR;
181 }
182
183 /* check state of connection handle */
184 switch( pdbc->state )
185 {
186 case en_dbc_allocated:
187 if( fOption == SQL_TRANSLATE_DLL
188 || fOption == SQL_TRANSLATE_OPTION )
189 {
190 /* This two options are only meaningful
191 * for specified driver. So, has to be
192 * set after a dirver has been loaded.
193 */
194 sqlstat = en_08003;
195 break;
196 }
197
198 if( fOption >= SQL_CONNECT_OPT_DRVR_START
199 && pdbc->henv == SQL_NULL_HENV )
200 /* An option only meaningful for drivers
201 * is passed before loading a driver.
202 * We classify this as an invalid option error.
203 * This is not documented by MS SDK guide.
204 */
205 {
206 sqlstat = en_S1092;
207 break;
208 }
209 break;
210
211 case en_dbc_needdata:
212 sqlstat = en_S1010;
213 break;
214
215 case en_dbc_connected:
216 case en_dbc_hstmt:
217 if( fOption == SQL_ODBC_CURSORS )
218 {
219 sqlstat = en_08002;
220 }
221 break;
222
223 default:
224 break;
225 }
226
227 /* check state of statement handle(s) */
228 for( pstmt = (STMT_t FAR*)pdbc->hstmt;
229 pstmt != NULL && sqlstat == en_00000;
230 pstmt = (STMT_t FAR*)pstmt->next )
231 {
232 if( pstmt->state >= en_stmt_needdata
233 || pstmt->asyn_on != en_NullProc )
234 {
235 sqlstat = en_S1010;
236 }
237 }
238
239 if( sqlstat != en_00000 )
240 {
241 PUSHSQLERR ( pdbc->herr, sqlstat );
242
243 return SQL_ERROR;
244 }
245
246 if( fOption == SQL_OPT_TRACE )
247 /* tracing flag can be set before and after connect
248 * and only meaningful for driver manager(actually
249 * there is only one tracing file under one global
250 * environment).
251 */
252 {
253 switch( vParam )
254 {
255 case SQL_OPT_TRACE_ON:
256 if( pdbc->tfile == NULL )
257 {
258 pdbc->tfile = (char FAR*)MEM_ALLOC( 1 +
259 STRLEN(SQL_OPT_TRACE_FILE_DEFAULT) );
260
261 if( pdbc->tfile == NULL )
262 {
263 PUSHSQLERR( pdbc->herr, en_S1001 );
264
265 return SQL_ERROR;
266 }
267
268 STRCPY( pdbc->tfile, SQL_OPT_TRACE_FILE_DEFAULT );
269 }
270
271 if( pdbc->tstm == NULL )
272 {
273#if defined(stderr) && defined(stdout)
274 if(STREQ( pdbc->tfile, "stderr"))
275 {
276 pdbc->tstm = stderr;
277 }
278 else
279 if(STREQ(pdbc->tfile, "stdout"))
280 {
281 pdbc->tstm = stdout;
282 }
283 else
284#endif
285 {
286 pdbc->tstm
287 = fopen(pdbc->tfile, "a+");
288 }
289
290 if(pdbc->tstm )
291 {
292 pdbc->trace = 1;
293 }
294 else
295 {
296 pdbc->trace = 0;
297
298 sqlstat = en_IM013;
299 retcode = SQL_ERROR;
300 }
301 }
302 break;
303
304 case SQL_OPT_TRACE_OFF:
305 if( pdbc->trace && pdbc->tstm )
306 {
307#if defined(stderr) && defined(stdout)
308 if( stderr != (FILE FAR*)(pdbc->tstm)
309 && stdout != (FILE FAR*)(pdbc->tstm) )
310#endif
311 {
312 fclose(pdbc->tstm);
313 }
314 }
315 pdbc->tstm = NULL;
316 pdbc->trace = 0;
317 break;
318
319 default:
320 PUSHSQLERR (pdbc->herr, en_S1009);
321 retcode = SQL_ERROR;
322 }
323
324 if( sqlstat != en_00000 )
325 {
326 PUSHSQLERR ( pdbc->herr, sqlstat );
327 }
328
329 return retcode;
330 }
331
332 if( fOption == SQL_OPT_TRACEFILE )
333 /* Tracing file can be set before and after connect
334 * and only meaningful for driver manager.
335 */
336 {
337 if( vParam == 0UL
338 || ((char FAR*)vParam)[0] == 0 )
339 {
340 PUSHSQLERR ( pdbc->herr, en_S1009 );
341
342 return SQL_ERROR;
343 }
344
345 if( pdbc->tfile && STREQ (pdbc->tfile, vParam) )
346 {
347 return SQL_SUCCESS;
348 }
349
350 if( pdbc->trace )
351 {
352 PUSHSQLERR ( pdbc->herr, en_IM014 );
353
354 return SQL_ERROR;
355 }
356
357 if( pdbc->tfile )
358 {
359 MEM_FREE( pdbc->tfile );
360 }
361
362 pdbc->tfile = (char FAR*)MEM_ALLOC( 1 + STRLEN( vParam ) );
363
364 if( pdbc->tfile == NULL )
365 {
366 PUSHSQLERR( pdbc->herr, en_S1001 );
367
368 return SQL_ERROR;
369 }
370
371 STRCPY ( pdbc->tfile, vParam );
372
373 return SQL_SUCCESS;
374 }
375
376 if( pdbc->state != en_dbc_allocated )
377 {
378 /* If already connected, then, driver's odbc call
379 * will be invoked. Otherwise, we only save the options
380 * and delay the setting process until the connection
381 * been established.
382 */
383 hproc = _iodbcdm_getproc( hdbc, en_SetConnectOption );
384
385 if( hproc == SQL_NULL_HPROC )
386 {
387 PUSHSQLERR ( pdbc->herr, en_IM001 );
388
389 return SQL_ERROR;
390 }
391
392 CALL_DRIVER ( hdbc, retcode, hproc, en_SetConnectOption, (
393 pdbc->dhdbc, fOption, vParam ) )
394
395#if 0
396 retcode = hproc( pdbc->dhdbc, fOption, vParam);
397#endif
398
399 if( retcode != SQL_SUCCESS
400 && retcode != SQL_SUCCESS_WITH_INFO )
401 {
402 return retcode;
403 }
404 }
405
406 /*
407 * Now, either driver's odbc call was successed or
408 * driver has not been loaded yet. In the first case, we
409 * need flip flag for(such as access_mode, autocommit, ...)
410 * for our finit state machine. While in the second case,
411 * we need save option values(such as current_qualifier, ...)
412 * for delaied setting. So, ...
413 */
414
415 /* No matter what state we are(i.e. allocated or connected, ..)
416 * we need to flip the flag.
417 */
418 switch( fOption )
419 {
420 case SQL_ACCESS_MODE:
421 pdbc->access_mode = vParam;
422 break;
423
424 case SQL_AUTOCOMMIT:
425 pdbc->autocommit = vParam;
426 break;
427 }
428
429 /* state transition */
430 if( pdbc->state != en_dbc_allocated )
431 {
432 return retcode;
433 }
434
435 /* Only 'allocated' state is possible here, and we need to
436 * save the options for delaied setting.
437 */
438 switch( fOption )
439 {
440 case SQL_CURRENT_QUALIFIER:
441 if( pdbc->current_qualifier != NULL )
442 {
443 MEM_FREE ( pdbc->current_qualifier );
444 }
445
446 if( vParam == 0UL )
447 {
448 pdbc->current_qualifier = NULL;
449
450 break;
451 }
452
453 pdbc->current_qualifier
454 = (char FAR*)MEM_ALLOC (
455 STRLEN (vParam) + 1 );
456
457 if( pdbc->current_qualifier == NULL )
458 {
459 PUSHSQLERR ( pdbc->herr, en_S1001 );
460 return SQL_ERROR;
461 }
462
463 STRCPY ( pdbc->current_qualifier, vParam );
464 break;
465
466 case SQL_LOGIN_TIMEOUT:
467 pdbc->login_timeout = vParam;
468 break;
469
470 case SQL_ODBC_CURSORS:
471 pdbc->odbc_cursors = vParam;
472 break;
473
474 case SQL_PACKET_SIZE:
475 pdbc->packet_size = vParam;
476 break;
477
478 case SQL_QUIET_MODE:
479 pdbc->quiet_mode = vParam;
480 break;
481
482 case SQL_TXN_ISOLATION:
483 pdbc->txn_isolation = vParam;
484 break;
485
486 default:
487 /* Since we didn't save the option value for delaied
488 * setting, we should raise an error here.
489 */
490 break;
491 }
492
493 return retcode;
494}
495
496RETCODE SQL_API SQLGetConnectOption(
497 HDBC hdbc,
498 UWORD fOption,
499 PTR pvParam )
500{
501/* GENV_t FAR* genv; */
502 DBC_t FAR* pdbc = (DBC_t FAR*)hdbc;
503 int sqlstat = en_00000;
504 HPROC hproc = SQL_NULL_HPROC;
505 RETCODE retcode;
506
507 if( hdbc == SQL_NULL_HDBC )
508 {
509 return SQL_INVALID_HANDLE;
510 }
511
512 /* check option */
513 if( fOption < SQL_CONN_OPT_MIN
514 || ( fOption > SQL_CONN_OPT_MAX
515 && fOption < SQL_CONNECT_OPT_DRVR_START ) )
516 {
517 PUSHSQLERR ( pdbc->herr, en_S1092 );
518
519 return SQL_ERROR;
520 }
521
522 /* check state */
523 switch( pdbc->state )
524 {
525 case en_dbc_allocated:
526 if( fOption != SQL_ACCESS_MODE
527 && fOption != SQL_AUTOCOMMIT
528 && fOption != SQL_LOGIN_TIMEOUT
529 && fOption != SQL_OPT_TRACE
530 && fOption != SQL_OPT_TRACEFILE )
531 {
532 sqlstat = en_08003;
533 }
534 /* MS ODBC SDK document only
535 * allows SQL_ACCESS_MODE
536 * and SQL_AUTOCOMMIT in this
537 * dbc state. We allow another
538 * two options, because they
539 * are only meaningful for driver
540 * manager.
541 */
542 break;
543
544 case en_dbc_needdata:
545 sqlstat = en_S1010;
546 break;
547
548 default:
549 break;
550 }
551
552 if( sqlstat != en_00000 )
553 {
554 PUSHSQLERR ( pdbc->herr, sqlstat );
555
556 return SQL_ERROR;
557 }
558
559 /* Tracing and tracing file options are only
560 * meaningful for driver manager
561 */
562 if( fOption == SQL_OPT_TRACE )
563 {
564 if( pdbc->trace )
565 *((UDWORD*)pvParam) = (UDWORD)SQL_OPT_TRACE_ON;
566 else
567 *((UDWORD*)pvParam) = (UDWORD)SQL_OPT_TRACE_OFF;
568
569 return SQL_SUCCESS;
570 }
571
572 if( fOption == SQL_OPT_TRACEFILE )
573 {
574 STRCPY (pvParam, pdbc->tfile );
575
576 return SQL_ERROR;
577 }
578
579 if( pdbc->state != en_dbc_allocated )
580 /* if already connected, we will invoke driver's function */
581 {
582 hproc = _iodbcdm_getproc( hdbc, en_GetConnectOption );
583
584 if( hproc == SQL_NULL_HPROC )
585 {
586 PUSHSQLERR( pdbc->herr, en_IM001 );
587
588 return SQL_ERROR;
589 }
590
591 CALL_DRIVER ( hdbc, retcode, hproc, en_GetConnectOption, (
592 pdbc->dhdbc, fOption, pvParam ) )
593
594#if 0
595 retcode = hproc(pdbc->dhdbc, fOption, pvParam);
596#endif
597
598 return retcode;
599 }
600
601 /* We needn't to handle options which are not allowed
602 * to be *get* at a allocated dbc state(and two tracing
603 * options which has been handled and returned). Thus,
604 * there are only two possible cases.
605 */
606 switch( fOption )
607 {
608 case SQL_ACCESS_MODE:
609 *((UDWORD*)pvParam) = pdbc->access_mode;
610 break;
611
612 case SQL_AUTOCOMMIT:
613 *((UDWORD*)pvParam) = pdbc->autocommit;
614 break;
615
616 case SQL_LOGIN_TIMEOUT:
617 *((UDWORD*)pvParam) = pdbc->login_timeout;
618 break;
619
620 default:
621 break;
622 }
623
624 return SQL_SUCCESS;
625}
626
627static RETCODE _iodbcdm_transact(
628 HDBC hdbc,
629 UWORD fType )
630{
631 DBC_t FAR* pdbc = (DBC_t FAR*)hdbc;
632 STMT_t FAR* pstmt;
633 HPROC hproc;
634 RETCODE retcode;
635
636 /* check state */
637 switch( pdbc->state )
638 {
639 case en_dbc_allocated:
640 case en_dbc_needdata:
641 PUSHSQLERR ( pdbc->herr, en_08003 );
642 return SQL_ERROR;
643
644 case en_dbc_connected:
645 return SQL_SUCCESS;
646
647 case en_dbc_hstmt:
648 default:
649 break;
650 }
651
652 for( pstmt = (STMT_t FAR*)(pdbc->hstmt);
653 pstmt != NULL;
654 pstmt = pstmt->next )
655 {
656 if( pstmt->state >= en_stmt_needdata
657 || pstmt->asyn_on != en_NullProc )
658 {
659 PUSHSQLERR ( pdbc->herr, en_S1010 );
660
661 return SQL_ERROR;
662 }
663 }
664
665 hproc = _iodbcdm_getproc( hdbc, en_Transact );
666
667 if( hproc == SQL_NULL_HPROC )
668 {
669 PUSHSQLERR ( pdbc->herr, en_IM001 );
670
671 return SQL_ERROR;
672 }
673
674 CALL_DRIVER ( hdbc, retcode, hproc, en_Transact, (
675 SQL_NULL_HENV, pdbc->dhdbc, fType ) )
676
677#if 0
678 retcode = hproc( SQL_NULL_HENV, pdbc->dhdbc, fType );
679#endif
680
681 /* state transition */
682 if( retcode != SQL_SUCCESS
683 && retcode != SQL_SUCCESS_WITH_INFO )
684 {
685 return retcode;
686 }
687
688 pdbc->state = en_dbc_hstmt;
689
690 for( pstmt = (STMT_t FAR*)(pdbc->hstmt);
691 pstmt != NULL;
692 pstmt = pstmt->next )
693 {
694 switch( pstmt->state )
695 {
696 case en_stmt_prepared:
697 if( pdbc->cb_commit == SQL_CB_DELETE
698 || pdbc->cb_rollback == SQL_CB_DELETE )
699 {
700 pstmt->state = en_stmt_allocated;
701 pstmt->prep_state = 0;
702 break;
703 }
704 break;
705
706 case en_stmt_executed:
707 case en_stmt_cursoropen:
708 case en_stmt_fetched:
709 case en_stmt_xfetched:
710 if( ! pstmt->prep_state
711 && pdbc->cb_commit != SQL_CB_PRESERVE
712 && pdbc->cb_rollback != SQL_CB_PRESERVE )
713 {
714 pstmt->state = en_stmt_allocated;
715 pstmt->prep_state = 0;
716 pstmt->cursor_state = en_stmt_cursor_no;
717 break;
718 }
719
720 if( pstmt->prep_state )
721 {
722 if( pdbc->cb_commit == SQL_CB_DELETE
723 || pdbc->cb_rollback== SQL_CB_DELETE )
724 {
725 pstmt->state = en_stmt_allocated;
726 pstmt->prep_state = 0;
727 pstmt->cursor_state = en_stmt_cursor_no;
728 break;
729 }
730
731 if( pdbc->cb_commit == SQL_CB_CLOSE
732 || pdbc->cb_rollback== SQL_CB_CLOSE )
733 {
734 pstmt->state
735 = en_stmt_prepared;
736 pstmt->cursor_state
737 = en_stmt_cursor_no;
738 break;
739 }
740 break;
741 }
742 break;
743
744 default:
745 break;
746 }
747 }
748
749 return retcode;
750}
751
752RETCODE SQL_API SQLTransact(
753 HENV henv,
754 HDBC hdbc,
755 UWORD fType )
756{
757 GENV_t FAR* genv = (GENV_t FAR*)henv;
758 DBC_t FAR* pdbc = (DBC_t FAR*)hdbc;
759 HERR herr;
760 RETCODE retcode = 0;
761
762 if( hdbc != SQL_NULL_HDBC )
763 {
764 herr = pdbc->herr;
765 }
766 else if( henv != SQL_NULL_HENV )
767 {
768 herr = genv->herr;
769 }
770 else
771 {
772 return SQL_INVALID_HANDLE;
773 }
774
775 /* check argument */
776 if( fType != SQL_COMMIT
777 && fType != SQL_ROLLBACK )
778 {
779 PUSHSQLERR ( herr, en_S1012 );
780
781 return SQL_ERROR;
782 }
783
784 if( hdbc != SQL_NULL_HDBC )
785 {
786 retcode = _iodbcdm_transact( hdbc, fType );
787 }
788 else
789 {
790 for( pdbc = (DBC_t FAR*)(genv->hdbc);
791 pdbc != NULL;
792 pdbc = pdbc->next )
793 {
794 retcode |= _iodbcdm_transact( hdbc, fType );
795 }
796 }
797
798 if( retcode != SQL_SUCCESS
799 && retcode != SQL_SUCCESS_WITH_INFO )
800 {
801 /* fail on one of the connection */
802 return SQL_ERROR;
803 }
804
805 return retcode;
806}
wxWidgets (Impactor)