1/*
2 *  catalog.c
3 *
4 *  $Id: catalog.c 2613 1999-06-01 15:32:12Z VZ $
5 *
6 *  Catalog functions
7 *
8 *  The iODBC driver manager.
9 *
10 *  Copyright (C) 1995 by Ke Jin <kejin@empress.com>
11 *
12 *  This library is free software; you can redistribute it and/or
13 *  modify it under the terms of the GNU Library General Public
14 *  License as published by the Free Software Foundation; either
15 *  version 2 of the License, or (at your option) any later version.
16 *
17 *  This library is distributed in the hope that it will be useful,
18 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
19 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20 *  Library General Public License for more details.
21 *
22 *  You should have received a copy of the GNU Library General Public
23 *  License along with this library; if not, write to the Free
24 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 */
26
27#include	"config.h"
28
29#include	"isql.h"
30#include	"isqlext.h"
31
32#include	"dlproc.h"
33
34#include	"herr.h"
35#include	"henv.h"
36#include	"hdbc.h"
37#include	"hstmt.h"
38
39#include	"itrace.h"
40
41#ifndef NULL
42#define NULL 0
43#endif
44
45static RETCODE
46_iodbcdm_cata_state_ok (
47    HSTMT hstmt,
48    int fidx)
49/* check state for executing catalog functions */
50{
51  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
52  int sqlstat = en_00000;
53
54  if (pstmt->asyn_on == en_NullProc)
55    {
56      switch (pstmt->state)
57	 {
58	 case en_stmt_needdata:
59	 case en_stmt_mustput:
60	 case en_stmt_canput:
61	   sqlstat = en_S1010;
62	   break;
63
64	 case en_stmt_fetched:
65	 case en_stmt_xfetched:
66	   sqlstat = en_24000;
67	   break;
68
69	 default:
70	   break;
71	 }
72    }
73  else if (pstmt->asyn_on != fidx)
74    {
75      sqlstat = en_S1010;
76    }
77
78  if (sqlstat != en_00000)
79    {
80      PUSHSQLERR (pstmt->herr, sqlstat);
81
82      return SQL_ERROR;
83    }
84
85  return SQL_SUCCESS;
86}
87
88
89static RETCODE
90_iodbcdm_cata_state_tr (
91    HSTMT hstmt,
92    int fidx,
93    RETCODE result)
94/* state transition for catalog function */
95{
96  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
97  DBC_t FAR *pdbc;
98
99  pdbc = (DBC_t FAR *) (pstmt->hdbc);
100
101  if (pstmt->asyn_on == fidx)
102    {
103      switch (result)
104	 {
105	 case SQL_SUCCESS:
106	 case SQL_SUCCESS_WITH_INFO:
107	 case SQL_ERROR:
108	   pstmt->asyn_on = en_NullProc;
109	   break;
110
111	 case SQL_STILL_EXECUTING:
112	 default:
113	   return result;
114	 }
115    }
116
117  if (pstmt->state <= en_stmt_executed)
118    {
119      switch (result)
120	 {
121	 case SQL_SUCCESS:
122	 case SQL_SUCCESS_WITH_INFO:
123	   pstmt->state = en_stmt_cursoropen;
124	   break;
125
126	 case SQL_ERROR:
127	   pstmt->state = en_stmt_allocated;
128	   pstmt->prep_state = 0;
129	   break;
130
131	 case SQL_STILL_EXECUTING:
132	   pstmt->asyn_on = fidx;
133	   break;
134
135	 default:
136	   break;
137	 }
138    }
139
140  return result;
141}
142
143
144RETCODE SQL_API
145SQLGetTypeInfo (
146    HSTMT hstmt,
147    SWORD fSqlType)
148{
149  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
150  HPROC hproc = SQL_NULL_HPROC;
151  int sqlstat = en_00000;
152  RETCODE retcode;
153
154  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
155    {
156      return SQL_INVALID_HANDLE;
157    }
158
159  for (;;)
160    {
161      if (fSqlType > SQL_TYPE_MAX)
162	{
163	  sqlstat = en_S1004;
164	  break;
165	}
166
167      /* Note: SQL_TYPE_DRIVER_START is a negative number So, we use ">" */
168      if (fSqlType < SQL_TYPE_MIN && fSqlType > SQL_TYPE_DRIVER_START)
169	{
170	  sqlstat = en_S1004;
171	  break;
172	}
173
174      retcode = _iodbcdm_cata_state_ok (hstmt, en_GetTypeInfo);
175
176      if (retcode != SQL_SUCCESS)
177	{
178	  return SQL_ERROR;
179	}
180
181      hproc = _iodbcdm_getproc (pstmt->hdbc, en_GetTypeInfo);
182
183      if (hproc == SQL_NULL_HPROC)
184	{
185	  sqlstat = en_IM001;
186	  break;
187	}
188
189      sqlstat = en_00000;
190      if (1)			/* turn off solaris warning message */
191	break;
192    }
193
194  if (sqlstat != en_00000)
195    {
196      PUSHSQLERR (pstmt->herr, sqlstat);
197
198      return SQL_ERROR;
199    }
200
201  CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_GetTypeInfo,
202    (pstmt->dhstmt, fSqlType))
203
204  return _iodbcdm_cata_state_tr (hstmt, en_GetTypeInfo, retcode);
205}
206
207
208RETCODE SQL_API
209SQLSpecialColumns (
210    HSTMT hstmt,
211    UWORD fColType,
212    UCHAR FAR * szTableQualifier,
213    SWORD cbTableQualifier,
214    UCHAR FAR * szTableOwner,
215    SWORD cbTableOwner,
216    UCHAR FAR * szTableName,
217    SWORD cbTableName,
218    UWORD fScope,
219    UWORD fNullable)
220{
221  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
222  HPROC hproc = SQL_NULL_HPROC;
223  RETCODE retcode;
224  int sqlstat = en_00000;
225
226  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
227    {
228      return SQL_INVALID_HANDLE;
229    }
230
231  for (;;)
232    {
233      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
234	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
235	  || (cbTableName < 0 && cbTableName != SQL_NTS))
236	{
237	  sqlstat = en_S1090;
238	  break;
239	}
240
241      if (fColType != SQL_BEST_ROWID && fColType != SQL_ROWVER)
242	{
243	  sqlstat = en_S1097;
244	  break;
245	}
246
247      if (fScope != SQL_SCOPE_CURROW
248	  && fScope != SQL_SCOPE_TRANSACTION
249	  && fScope != SQL_SCOPE_SESSION)
250	{
251	  sqlstat = en_S1098;
252	  break;
253	}
254
255      if (fNullable != SQL_NO_NULLS && fNullable != SQL_NULLABLE)
256	{
257	  sqlstat = en_S1099;
258	  break;
259	}
260
261      retcode = _iodbcdm_cata_state_ok (hstmt, en_SpecialColumns);
262
263      if (retcode != SQL_SUCCESS)
264	{
265	  return SQL_ERROR;
266	}
267
268      hproc = _iodbcdm_getproc (pstmt->hdbc, en_SpecialColumns);
269
270      if (hproc == SQL_NULL_HPROC)
271	{
272	  sqlstat = en_IM001;
273	  break;
274	}
275
276      sqlstat = en_00000;
277      if (1)			/* turn off solaris warning message */
278	break;
279    }
280
281  if (sqlstat != en_00000)
282    {
283      PUSHSQLERR (pstmt->herr, sqlstat);
284
285      return SQL_ERROR;
286    }
287
288  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_SpecialColumns, (
289	  pstmt->dhstmt,
290	  fColType,
291	  szTableQualifier,
292	  cbTableQualifier,
293	  szTableOwner,
294	  cbTableOwner,
295	  szTableName,
296	  cbTableName,
297	  fScope,
298	  fNullable))
299
300  return _iodbcdm_cata_state_tr (hstmt, en_SpecialColumns, retcode);
301}
302
303
304RETCODE SQL_API
305SQLStatistics (
306    HSTMT hstmt,
307    UCHAR FAR * szTableQualifier,
308    SWORD cbTableQualifier,
309    UCHAR FAR * szTableOwner,
310    SWORD cbTableOwner,
311    UCHAR FAR * szTableName,
312    SWORD cbTableName,
313    UWORD fUnique,
314    UWORD fAccuracy)
315{
316  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
317  HPROC hproc = SQL_NULL_HPROC;
318  RETCODE retcode;
319  int sqlstat = en_00000;
320
321  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
322    {
323      return SQL_INVALID_HANDLE;
324    }
325
326  for (;;)
327    {
328      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
329	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
330	  || (cbTableName < 0 && cbTableName != SQL_NTS))
331	{
332	  sqlstat = en_S1090;
333	  break;
334	}
335
336      if (fUnique != SQL_INDEX_UNIQUE && fUnique != SQL_INDEX_ALL)
337	{
338	  sqlstat = en_S1100;
339	  break;
340	}
341
342      if (fAccuracy != SQL_ENSURE && fAccuracy != SQL_QUICK)
343	{
344	  sqlstat = en_S1101;
345	  break;
346	}
347
348      retcode = _iodbcdm_cata_state_ok (hstmt, en_Statistics);
349
350      if (retcode != SQL_SUCCESS)
351	{
352	  return SQL_ERROR;
353	}
354
355      hproc = _iodbcdm_getproc (pstmt->hdbc, en_Statistics);
356
357      if (hproc == SQL_NULL_HPROC)
358	{
359	  sqlstat = en_IM001;
360	  break;
361	}
362
363      sqlstat = en_00000;
364
365      if (1)			/* turn off solaris warning message */
366	break;
367    }
368
369  if (sqlstat != en_00000)
370    {
371      PUSHSQLERR (pstmt->herr, sqlstat);
372
373      return SQL_ERROR;
374    }
375
376  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Statistics, (
377	  pstmt->dhstmt,
378	  szTableQualifier,
379	  cbTableQualifier,
380	  szTableOwner,
381	  cbTableOwner,
382	  szTableName,
383	  cbTableName,
384	  fUnique,
385	  fAccuracy))
386
387  return _iodbcdm_cata_state_tr (hstmt, en_Statistics, retcode);
388}
389
390
391RETCODE SQL_API
392SQLTables (
393    HSTMT hstmt,
394    UCHAR FAR * szTableQualifier,
395    SWORD cbTableQualifier,
396    UCHAR FAR * szTableOwner,
397    SWORD cbTableOwner,
398    UCHAR FAR * szTableName,
399    SWORD cbTableName,
400    UCHAR FAR * szTableType,
401    SWORD cbTableType)
402{
403  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
404  HPROC hproc = SQL_NULL_HPROC;
405  RETCODE retcode;
406  int sqlstat = en_00000;
407
408  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
409    {
410      return SQL_INVALID_HANDLE;
411    }
412
413  for (;;)
414    {
415      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
416	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
417	  || (cbTableName < 0 && cbTableName != SQL_NTS)
418	  || (cbTableType < 0 && cbTableType != SQL_NTS))
419	{
420	  sqlstat = en_S1090;
421	  break;
422	}
423
424      retcode = _iodbcdm_cata_state_ok (hstmt, en_Tables);
425
426      if (retcode != SQL_SUCCESS)
427	{
428	  return SQL_ERROR;
429	}
430
431      hproc = _iodbcdm_getproc (pstmt->hdbc, en_Tables);
432
433      if (hproc == SQL_NULL_HPROC)
434	{
435	  sqlstat = en_IM001;
436	  break;
437	}
438
439      sqlstat = en_00000;
440
441      if (1)			/* turn off solaris warning message */
442	break;
443    }
444
445  if (sqlstat != en_00000)
446    {
447      PUSHSQLERR (pstmt->herr, sqlstat);
448
449      return SQL_ERROR;
450    }
451
452  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Tables, (
453	  pstmt->dhstmt,
454	  szTableQualifier,
455	  cbTableQualifier,
456	  szTableOwner,
457	  cbTableOwner,
458	  szTableName,
459	  cbTableName,
460	  szTableType,
461	  cbTableType))
462
463  return _iodbcdm_cata_state_tr (hstmt, en_Tables, retcode);
464}
465
466
467RETCODE SQL_API
468SQLColumnPrivileges (
469    HSTMT hstmt,
470    UCHAR FAR * szTableQualifier,
471    SWORD cbTableQualifier,
472    UCHAR FAR * szTableOwner,
473    SWORD cbTableOwner,
474    UCHAR FAR * szTableName,
475    SWORD cbTableName,
476    UCHAR FAR * szColumnName,
477    SWORD cbColumnName)
478{
479  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
480  HPROC hproc = SQL_NULL_HPROC;
481  RETCODE retcode;
482  int sqlstat = en_00000;
483
484  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
485    {
486      return SQL_INVALID_HANDLE;
487    }
488
489  for (;;)
490    {
491      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
492	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
493	  || (cbTableName < 0 && cbTableName != SQL_NTS)
494	  || (cbColumnName < 0 && cbColumnName != SQL_NTS))
495	{
496	  sqlstat = en_S1090;
497	  break;
498	}
499
500      retcode = _iodbcdm_cata_state_ok (hstmt, en_ColumnPrivileges);
501
502      if (retcode != SQL_SUCCESS)
503	{
504	  return SQL_ERROR;
505	}
506
507      hproc = _iodbcdm_getproc (pstmt->hdbc, en_ColumnPrivileges);
508
509      if (hproc == SQL_NULL_HPROC)
510	{
511	  sqlstat = en_IM001;
512	  break;
513	}
514
515      sqlstat = en_00000;
516
517      if (1)			/* turn off solaris warning message */
518	break;
519    }
520
521  if (sqlstat != en_00000)
522    {
523      PUSHSQLERR (pstmt->herr, sqlstat);
524
525      return SQL_ERROR;
526    }
527
528  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ColumnPrivileges, (
529	  pstmt->dhstmt,
530	  szTableQualifier,
531	  cbTableQualifier,
532	  szTableOwner,
533	  cbTableOwner,
534	  szTableName,
535	  cbTableName,
536	  szColumnName,
537	  cbColumnName))
538
539  return _iodbcdm_cata_state_tr (hstmt, en_ColumnPrivileges, retcode);
540}
541
542
543RETCODE SQL_API
544SQLColumns (
545    HSTMT hstmt,
546    UCHAR FAR * szTableQualifier,
547    SWORD cbTableQualifier,
548    UCHAR FAR * szTableOwner,
549    SWORD cbTableOwner,
550    UCHAR FAR * szTableName,
551    SWORD cbTableName,
552    UCHAR FAR * szColumnName,
553    SWORD cbColumnName)
554{
555  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
556  HPROC hproc = SQL_NULL_HPROC;
557  RETCODE retcode;
558  int sqlstat = en_00000;
559
560  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
561    {
562      return SQL_INVALID_HANDLE;
563    }
564
565  for (;;)
566    {
567      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
568	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
569	  || (cbTableName < 0 && cbTableName != SQL_NTS)
570	  || (cbColumnName < 0 && cbColumnName != SQL_NTS))
571	{
572	  sqlstat = en_S1090;
573	  break;
574	}
575
576      retcode = _iodbcdm_cata_state_ok (hstmt, en_Columns);
577
578      if (retcode != SQL_SUCCESS)
579	{
580	  return SQL_ERROR;
581	}
582
583      hproc = _iodbcdm_getproc (pstmt->hdbc, en_Columns);
584
585      if (hproc == SQL_NULL_HPROC)
586	{
587	  sqlstat = en_IM001;
588	  break;
589	}
590
591      sqlstat = en_00000;
592
593      if (1)			/* turn off solaris warning message */
594	break;
595    }
596
597  if (sqlstat != en_00000)
598    {
599      PUSHSQLERR (pstmt->herr, sqlstat);
600
601      return SQL_ERROR;
602    }
603
604  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Columns, (
605	  pstmt->dhstmt,
606	  szTableQualifier,
607	  cbTableQualifier,
608	  szTableOwner,
609	  cbTableOwner,
610	  szTableName,
611	  cbTableName,
612	  szColumnName,
613	  cbColumnName))
614
615  return _iodbcdm_cata_state_tr (hstmt, en_Columns, retcode);
616}
617
618
619RETCODE SQL_API
620SQLForeignKeys (
621    HSTMT hstmt,
622    UCHAR FAR * szPkTableQualifier,
623    SWORD cbPkTableQualifier,
624    UCHAR FAR * szPkTableOwner,
625    SWORD cbPkTableOwner,
626    UCHAR FAR * szPkTableName,
627    SWORD cbPkTableName,
628    UCHAR FAR * szFkTableQualifier,
629    SWORD cbFkTableQualifier,
630    UCHAR FAR * szFkTableOwner,
631    SWORD cbFkTableOwner,
632    UCHAR FAR * szFkTableName,
633    SWORD cbFkTableName)
634{
635  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
636  HPROC hproc = SQL_NULL_HPROC;
637  RETCODE retcode;
638  int sqlstat = en_00000;
639
640  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
641    {
642      return SQL_INVALID_HANDLE;
643    }
644
645  for (;;)
646    {
647      if ((cbPkTableQualifier < 0 && cbPkTableQualifier != SQL_NTS)
648	  || (cbPkTableOwner < 0 && cbPkTableOwner != SQL_NTS)
649	  || (cbPkTableName < 0 && cbPkTableName != SQL_NTS)
650	  || (cbFkTableQualifier < 0 && cbFkTableQualifier != SQL_NTS)
651	  || (cbFkTableOwner < 0 && cbFkTableOwner != SQL_NTS)
652	  || (cbFkTableName < 0 && cbFkTableName != SQL_NTS))
653	{
654	  sqlstat = en_S1090;
655	  break;
656	}
657
658      retcode = _iodbcdm_cata_state_ok (hstmt, en_ForeignKeys);
659
660      if (retcode != SQL_SUCCESS)
661	{
662	  return SQL_ERROR;
663	}
664
665      hproc = _iodbcdm_getproc (pstmt->hdbc, en_ForeignKeys);
666
667      if (hproc == SQL_NULL_HPROC)
668	{
669	  sqlstat = en_IM001;
670	  break;
671	}
672
673      sqlstat = en_00000;
674
675      if (1)			/* turn off solaris warning message */
676	break;
677    }
678
679  if (sqlstat != en_00000)
680    {
681      PUSHSQLERR (pstmt->herr, sqlstat);
682
683      return SQL_ERROR;
684    }
685
686  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ForeignKeys, (
687	  pstmt->dhstmt,
688	  szPkTableQualifier,
689	  cbPkTableQualifier,
690	  szPkTableOwner,
691	  cbPkTableOwner,
692	  szPkTableName,
693	  cbPkTableName,
694	  szFkTableQualifier,
695	  cbFkTableQualifier,
696	  szFkTableOwner,
697	  cbFkTableOwner,
698	  szFkTableName,
699	  cbFkTableName))
700
701  return _iodbcdm_cata_state_tr (hstmt, en_ForeignKeys, retcode);
702}
703
704
705RETCODE SQL_API
706SQLPrimaryKeys (
707    HSTMT hstmt,
708    UCHAR FAR * szTableQualifier,
709    SWORD cbTableQualifier,
710    UCHAR FAR * szTableOwner,
711    SWORD cbTableOwner,
712    UCHAR FAR * szTableName,
713    SWORD cbTableName)
714{
715  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
716  HPROC hproc = SQL_NULL_HPROC;
717  RETCODE retcode;
718  int sqlstat = en_00000;
719
720  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
721    {
722      return SQL_INVALID_HANDLE;
723    }
724
725  for (;;)
726    {
727      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
728	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
729	  || (cbTableName < 0 && cbTableName != SQL_NTS))
730	{
731	  sqlstat = en_S1090;
732	  break;
733	}
734
735      retcode = _iodbcdm_cata_state_ok (hstmt, en_PrimaryKeys);
736
737      if (retcode != SQL_SUCCESS)
738	{
739	  return SQL_ERROR;
740	}
741
742      hproc = _iodbcdm_getproc (pstmt->hdbc, en_PrimaryKeys);
743
744      if (hproc == SQL_NULL_HPROC)
745	{
746	  sqlstat = en_IM001;
747	  break;
748	}
749
750      sqlstat = en_00000;
751
752      if (1)			/* turn off solaris warning message */
753	break;
754    }
755
756  if (sqlstat != en_00000)
757    {
758      PUSHSQLERR (pstmt->herr, sqlstat);
759
760      return SQL_ERROR;
761    }
762
763  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_PrimaryKeys, (
764	  pstmt->dhstmt,
765	  szTableQualifier,
766	  cbTableQualifier,
767	  szTableOwner,
768	  cbTableOwner,
769	  szTableName,
770	  cbTableName))
771
772  return _iodbcdm_cata_state_tr (hstmt, en_PrimaryKeys, retcode);
773}
774
775
776RETCODE SQL_API
777SQLProcedureColumns (
778    HSTMT hstmt,
779    UCHAR FAR * szProcQualifier,
780    SWORD cbProcQualifier,
781    UCHAR FAR * szProcOwner,
782    SWORD cbProcOwner,
783    UCHAR FAR * szProcName,
784    SWORD cbProcName,
785    UCHAR FAR * szColumnName,
786    SWORD cbColumnName)
787{
788  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
789  HPROC hproc = SQL_NULL_HPROC;
790  RETCODE retcode;
791  int sqlstat = en_00000;
792
793  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
794    {
795      return SQL_INVALID_HANDLE;
796    }
797
798  for (;;)
799    {
800      if ((cbProcQualifier < 0 && cbProcQualifier != SQL_NTS)
801	  || (cbProcOwner < 0 && cbProcOwner != SQL_NTS)
802	  || (cbProcName < 0 && cbProcName != SQL_NTS)
803	  || (cbColumnName < 0 && cbColumnName != SQL_NTS))
804	{
805	  sqlstat = en_S1090;
806	  break;
807	}
808
809      retcode = _iodbcdm_cata_state_ok (hstmt, en_ProcedureColumns);
810
811      if (retcode != SQL_SUCCESS)
812	{
813	  return SQL_ERROR;
814	}
815
816      hproc = _iodbcdm_getproc (pstmt->hdbc, en_ProcedureColumns);
817
818      if (hproc == SQL_NULL_HPROC)
819	{
820	  sqlstat = en_IM001;
821	  break;
822	}
823
824      sqlstat = en_00000;
825
826      if (1)			/* turn off solaris warning message */
827	break;
828    }
829
830  if (sqlstat != en_00000)
831    {
832      PUSHSQLERR (pstmt->herr, sqlstat);
833
834      return SQL_ERROR;
835    }
836
837  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ProcedureColumns, (
838	  pstmt->dhstmt,
839	  szProcQualifier,
840	  cbProcQualifier,
841	  szProcOwner,
842	  cbProcOwner,
843	  szProcName,
844	  cbProcName,
845	  szColumnName,
846	  cbColumnName))
847
848  return _iodbcdm_cata_state_tr (hstmt, en_ProcedureColumns, retcode);
849}
850
851
852RETCODE SQL_API
853SQLProcedures (
854    HSTMT hstmt,
855    UCHAR FAR * szProcQualifier,
856    SWORD cbProcQualifier,
857    UCHAR FAR * szProcOwner,
858    SWORD cbProcOwner,
859    UCHAR FAR * szProcName,
860    SWORD cbProcName)
861{
862  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
863  HPROC hproc = SQL_NULL_HPROC;
864  RETCODE retcode;
865  int sqlstat = en_00000;
866
867  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
868    {
869      return SQL_INVALID_HANDLE;
870    }
871
872  for (;;)
873    {
874      if ((cbProcQualifier < 0 && cbProcQualifier != SQL_NTS)
875	  || (cbProcOwner < 0 && cbProcOwner != SQL_NTS)
876	  || (cbProcName < 0 && cbProcName != SQL_NTS))
877	{
878	  sqlstat = en_S1090;
879	  break;
880	}
881
882      retcode = _iodbcdm_cata_state_ok (hstmt, en_Procedures);
883
884      if (retcode != SQL_SUCCESS)
885	{
886	  return SQL_ERROR;
887	}
888
889      hproc = _iodbcdm_getproc (pstmt->hdbc, en_Procedures);
890
891      if (hproc == SQL_NULL_HPROC)
892	{
893	  sqlstat = en_IM001;
894	  break;
895	}
896
897      sqlstat = en_00000;
898
899      if (1)			/* turn off solaris warning message */
900	break;
901    }
902
903  if (sqlstat != en_00000)
904    {
905      PUSHSQLERR (pstmt->herr, sqlstat);
906
907      return SQL_ERROR;
908    }
909
910  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Procedures, (
911	  pstmt->dhstmt,
912	  szProcQualifier,
913	  cbProcQualifier,
914	  szProcOwner,
915	  cbProcOwner,
916	  szProcName,
917	  cbProcName))
918
919  return _iodbcdm_cata_state_tr (hstmt, en_Procedures, retcode);
920}
921
922
923RETCODE SQL_API
924SQLTablePrivileges (
925    HSTMT hstmt,
926    UCHAR FAR * szTableQualifier,
927    SWORD cbTableQualifier,
928    UCHAR FAR * szTableOwner,
929    SWORD cbTableOwner,
930    UCHAR FAR * szTableName,
931    SWORD cbTableName)
932{
933
934  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
935  HPROC hproc = SQL_NULL_HPROC;
936  RETCODE retcode;
937  int sqlstat = en_00000;
938
939  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
940    {
941      return SQL_INVALID_HANDLE;
942    }
943
944  for (;;)
945    {
946      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
947	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
948	  || (cbTableName < 0 && cbTableName != SQL_NTS))
949	{
950	  sqlstat = en_S1090;
951	  break;
952	}
953
954      retcode = _iodbcdm_cata_state_ok (hstmt, en_TablePrivileges);
955
956      if (retcode != SQL_SUCCESS)
957	{
958	  return SQL_ERROR;
959	}
960
961      hproc = _iodbcdm_getproc (pstmt->hdbc, en_TablePrivileges);
962
963      if (hproc == SQL_NULL_HPROC)
964	{
965	  sqlstat = en_IM001;
966	  break;
967	}
968
969      sqlstat = en_00000;
970
971      if (1)			/* turn off solaris warning message */
972	break;
973    }
974
975  if (sqlstat != en_00000)
976    {
977      PUSHSQLERR (pstmt->herr, sqlstat);
978
979      return SQL_ERROR;
980    }
981
982  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_TablePrivileges,
983    (pstmt->dhstmt, szTableQualifier, cbTableQualifier, szTableOwner,
984	cbTableOwner, szTableName, cbTableName))
985
986  return _iodbcdm_cata_state_tr (hstmt, en_TablePrivileges, retcode);
987}
988