src/iodbc/catalog.c

   1 /*
   2  *  catalog.c
   3  *
   4  *  $Id$
   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
  45 static 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
  89 static 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
 144 RETCODE SQL_API
 145 SQLGetTypeInfo (
 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
 208 RETCODE SQL_API
 209 SQLSpecialColumns (
 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
 304 RETCODE SQL_API
 305 SQLStatistics (
 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
 391 RETCODE SQL_API
 392 SQLTables (
 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
 467 RETCODE SQL_API
 468 SQLColumnPrivileges (
 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
 543 RETCODE SQL_API
 544 SQLColumns (
 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
 619 RETCODE SQL_API
 620 SQLForeignKeys (
 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
 705 RETCODE SQL_API
 706 SQLPrimaryKeys (
 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
 776 RETCODE SQL_API
 777 SQLProcedureColumns (
 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
 852 RETCODE SQL_API
 853 SQLProcedures (
 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
 923 RETCODE SQL_API
 924 SQLTablePrivileges (
 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 }