1/* 2 * catalog.c 3 * 4 * $Id: catalog.c,v 1.17 2006/01/20 15:58:34 source Exp $ 5 * 6 * Catalog functions 7 * 8 * The iODBC driver manager. 9 * 10 * Copyright (C) 1995 by Ke Jin <kejin@empress.com> 11 * Copyright (C) 1996-2006 by OpenLink Software <iodbc@openlinksw.com> 12 * All Rights Reserved. 13 * 14 * This software is released under the terms of either of the following 15 * licenses: 16 * 17 * - GNU Library General Public License (see LICENSE.LGPL) 18 * - The BSD License (see LICENSE.BSD). 19 * 20 * Note that the only valid version of the LGPL license as far as this 21 * project is concerned is the original GNU Library General Public License 22 * Version 2, dated June 1991. 23 * 24 * While not mandated by the BSD license, any patches you make to the 25 * iODBC source code may be contributed back into the iODBC project 26 * at your discretion. Contributions will benefit the Open Source and 27 * Data Access community as a whole. Submissions may be made at: 28 * 29 * http://www.iodbc.org 30 * 31 * 32 * GNU Library Generic Public License Version 2 33 * ============================================ 34 * This library is free software; you can redistribute it and/or 35 * modify it under the terms of the GNU Library General Public 36 * License as published by the Free Software Foundation; only 37 * Version 2 of the License dated June 1991. 38 * 39 * This library is distributed in the hope that it will be useful, 40 * but WITHOUT ANY WARRANTY; without even the implied warranty of 41 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 42 * Library General Public License for more details. 43 * 44 * You should have received a copy of the GNU Library General Public 45 * License along with this library; if not, write to the Free 46 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 47 * 48 * 49 * The BSD License 50 * =============== 51 * Redistribution and use in source and binary forms, with or without 52 * modification, are permitted provided that the following conditions 53 * are met: 54 * 55 * 1. Redistributions of source code must retain the above copyright 56 * notice, this list of conditions and the following disclaimer. 57 * 2. Redistributions in binary form must reproduce the above copyright 58 * notice, this list of conditions and the following disclaimer in 59 * the documentation and/or other materials provided with the 60 * distribution. 61 * 3. Neither the name of OpenLink Software Inc. nor the names of its 62 * contributors may be used to endorse or promote products derived 63 * from this software without specific prior written permission. 64 * 65 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 66 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 67 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 68 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL OPENLINK OR 69 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 70 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 71 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 72 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 73 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 74 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 75 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 76 */ 77 78 79#include <iodbc.h> 80 81#include <sql.h> 82#include <sqlext.h> 83#include <sqlucode.h> 84 85#include <unicode.h> 86 87#include <herr.h> 88#include <henv.h> 89#include <hdbc.h> 90#include <hstmt.h> 91 92#include <dlproc.h> 93#include <itrace.h> 94 95/* 96 * Check state for executing catalog functions 97 */ 98static SQLRETURN 99_iodbcdm_cata_state_ok ( 100 STMT_t * pstmt, 101 int fidx) 102{ 103 sqlstcode_t sqlstat = en_00000; 104 105 if (pstmt->asyn_on == en_NullProc) 106 { 107 switch (pstmt->state) 108 { 109 case en_stmt_needdata: 110 case en_stmt_mustput: 111 case en_stmt_canput: 112 sqlstat = en_S1010; 113 break; 114 115 case en_stmt_fetched: 116 case en_stmt_xfetched: 117 sqlstat = en_24000; 118 break; 119 120 default: 121 break; 122 } 123 } 124 else if (pstmt->asyn_on != fidx) 125 { 126 sqlstat = en_S1010; 127 } 128 129 if (sqlstat != en_00000) 130 { 131 PUSHSQLERR (pstmt->herr, sqlstat); 132 133 return SQL_ERROR; 134 } 135 136 return SQL_SUCCESS; 137} 138 139 140/* 141 * State transition for catalog function 142 */ 143static SQLRETURN 144_iodbcdm_cata_state_tr ( 145 STMT_t * pstmt, 146 int fidx, 147 SQLRETURN result) 148{ 149 150 if (pstmt->asyn_on == fidx) 151 { 152 switch (result) 153 { 154 case SQL_SUCCESS: 155 case SQL_SUCCESS_WITH_INFO: 156 case SQL_ERROR: 157 pstmt->asyn_on = en_NullProc; 158 break; 159 160 case SQL_STILL_EXECUTING: 161 default: 162 return result; 163 } 164 } 165 166 if (pstmt->state <= en_stmt_executed) 167 { 168 switch (result) 169 { 170 case SQL_SUCCESS: 171 case SQL_SUCCESS_WITH_INFO: 172 pstmt->state = en_stmt_cursoropen; 173 break; 174 175 case SQL_ERROR: 176 pstmt->state = en_stmt_allocated; 177 pstmt->prep_state = 0; 178 break; 179 180 case SQL_STILL_EXECUTING: 181 pstmt->asyn_on = fidx; 182 break; 183 184 default: 185 break; 186 } 187 } 188 189 return result; 190} 191 192 193SQLRETURN SQL_API 194SQLGetTypeInfo_Internal ( 195 SQLHSTMT hstmt, 196 SQLSMALLINT fSqlType, 197 SQLCHAR waMode) 198{ 199 STMT (pstmt, hstmt); 200 CONN (pdbc, pstmt->hdbc); 201 ENVR (penv, pdbc->henv); 202 HPROC hproc = SQL_NULL_HPROC; 203 SQLRETURN retcode = SQL_SUCCESS; 204 sqlstcode_t sqlstat = en_00000; 205 206 waMode = waMode; /*NOTUSED*/ 207 208 for (;;) 209 { 210#if (ODBCVER < 0x0300) 211 if (fSqlType > SQL_TYPE_MAX) 212 { 213 sqlstat = en_S1004; 214 break; 215 } 216 217 /* Note: SQL_TYPE_DRIVER_START is a negative number So, we use ">" */ 218 if (fSqlType < SQL_TYPE_MIN && fSqlType > SQL_TYPE_DRIVER_START) 219 { 220 sqlstat = en_S1004; 221 break; 222 } 223#endif /* ODBCVER < 0x0300 */ 224 225 retcode = _iodbcdm_cata_state_ok (pstmt, en_GetTypeInfo); 226 227 if (retcode != SQL_SUCCESS) 228 { 229 return SQL_ERROR; 230 } 231 232 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 233 en_GetTypeInfo, ( 234 pstmt->dhstmt, 235 fSqlType)); 236 237 if (hproc == SQL_NULL_HPROC) 238 { 239 sqlstat = en_IM001; 240 break; 241 } 242 243 sqlstat = en_00000; 244 if (1) /* turn off solaris warning message */ 245 break; 246 } 247 248 if (sqlstat != en_00000) 249 { 250 PUSHSQLERR (pstmt->herr, sqlstat); 251 252 return SQL_ERROR; 253 } 254 255 retcode = _iodbcdm_cata_state_tr (pstmt, en_GetTypeInfo, retcode); 256 return retcode; 257} 258 259 260SQLRETURN SQL_API 261SQLGetTypeInfo (SQLHSTMT hstmt, 262 SQLSMALLINT fSqlType) 263{ 264 ENTER_STMT (hstmt, 265 trace_SQLGetTypeInfo (TRACE_ENTER, hstmt, fSqlType)); 266 267 retcode = SQLGetTypeInfo_Internal (hstmt, fSqlType, 'A'); 268 269 LEAVE_STMT (hstmt, 270 trace_SQLGetTypeInfo (TRACE_LEAVE, hstmt, fSqlType)); 271} 272 273 274#if ODBCVER >= 0x0300 275SQLRETURN SQL_API 276SQLGetTypeInfoA (SQLHSTMT hstmt, 277 SQLSMALLINT fSqlType) 278{ 279 ENTER_STMT (hstmt, 280 trace_SQLGetTypeInfo (TRACE_ENTER, hstmt, fSqlType)); 281 282 retcode = SQLGetTypeInfo_Internal (hstmt, fSqlType, 'A'); 283 284 LEAVE_STMT (hstmt, 285 trace_SQLGetTypeInfo (TRACE_LEAVE, hstmt, fSqlType)); 286} 287 288 289SQLRETURN SQL_API 290SQLGetTypeInfoW (SQLHSTMT hstmt, 291 SQLSMALLINT fSqlType) 292{ 293 ENTER_STMT (hstmt, 294 trace_SQLGetTypeInfoW (TRACE_ENTER, hstmt, fSqlType)); 295 296 retcode = SQLGetTypeInfo_Internal (hstmt, fSqlType, 'W'); 297 298 LEAVE_STMT (hstmt, 299 trace_SQLGetTypeInfoW (TRACE_LEAVE, hstmt, fSqlType)); 300} 301#endif 302 303 304SQLRETURN SQL_API 305SQLSpecialColumns_Internal ( 306 SQLHSTMT hstmt, 307 SQLUSMALLINT fColType, 308 SQLPOINTER szTableQualifier, 309 SQLSMALLINT cbTableQualifier, 310 SQLPOINTER szTableOwner, 311 SQLSMALLINT cbTableOwner, 312 SQLPOINTER szTableName, 313 SQLSMALLINT cbTableName, 314 SQLUSMALLINT fScope, 315 SQLUSMALLINT fNullable, 316 SQLCHAR waMode) 317{ 318 STMT (pstmt, hstmt); 319 CONN (pdbc, pstmt->hdbc); 320 ENVR (penv, pdbc->henv); 321 HPROC hproc = SQL_NULL_HPROC; 322 SQLRETURN retcode = SQL_SUCCESS; 323 sqlstcode_t sqlstat = en_00000; 324 void * _TableQualifier = NULL; 325 void * _TableOwner = NULL; 326 void * _TableName = NULL; 327 328 for (;;) 329 { 330 if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS) 331 || (cbTableOwner < 0 && cbTableOwner != SQL_NTS) 332 || (cbTableName < 0 && cbTableName != SQL_NTS)) 333 { 334 sqlstat = en_S1090; 335 break; 336 } 337 338 if (fColType != SQL_BEST_ROWID && fColType != SQL_ROWVER) 339 { 340 sqlstat = en_S1097; 341 break; 342 } 343 344 if (fScope != SQL_SCOPE_CURROW 345 && fScope != SQL_SCOPE_TRANSACTION 346 && fScope != SQL_SCOPE_SESSION) 347 { 348 sqlstat = en_S1098; 349 break; 350 } 351 352 if (fNullable != SQL_NO_NULLS && fNullable != SQL_NULLABLE) 353 { 354 sqlstat = en_S1099; 355 break; 356 } 357 358 retcode = _iodbcdm_cata_state_ok (pstmt, en_SpecialColumns); 359 360 if (retcode != SQL_SUCCESS) 361 { 362 return SQL_ERROR; 363 } 364 365 if ((penv->unicode_driver && waMode != 'W') 366 || (!penv->unicode_driver && waMode == 'W')) 367 { 368 if (waMode != 'W') 369 { 370 /* ansi=>unicode*/ 371 _TableQualifier = _iodbcdm_conv_param_A2W(pstmt, 0, (SQLCHAR *) szTableQualifier, cbTableQualifier); 372 _TableOwner = _iodbcdm_conv_param_A2W(pstmt, 1, (SQLCHAR *) szTableOwner, cbTableOwner); 373 _TableName = _iodbcdm_conv_param_A2W(pstmt, 2, (SQLCHAR *) szTableName, cbTableName); 374 } 375 else 376 { 377 /* unicode=>ansi*/ 378 _TableQualifier = _iodbcdm_conv_param_W2A(pstmt, 0, (SQLWCHAR *)szTableQualifier, cbTableQualifier); 379 _TableOwner = _iodbcdm_conv_param_W2A(pstmt, 1, (SQLWCHAR *)szTableOwner, cbTableOwner); 380 _TableName = _iodbcdm_conv_param_W2A(pstmt, 2, (SQLWCHAR *)szTableName, cbTableName); 381 } 382 szTableQualifier = _TableQualifier; 383 szTableOwner = _TableOwner; 384 szTableName = _TableName; 385 cbTableQualifier = SQL_NTS; 386 cbTableOwner = SQL_NTS; 387 cbTableName = SQL_NTS; 388 } 389 390 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 391 en_SpecialColumns, ( 392 pstmt->dhstmt, 393 fColType, 394 szTableQualifier, 395 cbTableQualifier, 396 szTableOwner, 397 cbTableOwner, 398 szTableName, 399 cbTableName, 400 fScope, 401 fNullable)); 402 403 if (hproc == SQL_NULL_HPROC) 404 { 405 sqlstat = en_IM001; 406 break; 407 } 408 409 sqlstat = en_00000; 410 if (1) /* turn off solaris warning message */ 411 break; 412 } 413 414 if (retcode != SQL_STILL_EXECUTING) 415 _iodbcdm_FreeStmtParams(pstmt); 416 417 if (sqlstat != en_00000) 418 { 419 PUSHSQLERR (pstmt->herr, sqlstat); 420 421 return SQL_ERROR; 422 } 423 424 retcode = _iodbcdm_cata_state_tr (pstmt, en_SpecialColumns, retcode); 425 return retcode; 426} 427 428 429SQLRETURN SQL_API 430SQLSpecialColumns (SQLHSTMT hstmt, 431 SQLUSMALLINT fColType, 432 SQLCHAR * szTableQualifier, 433 SQLSMALLINT cbTableQualifier, 434 SQLCHAR * szTableOwner, 435 SQLSMALLINT cbTableOwner, 436 SQLCHAR * szTableName, 437 SQLSMALLINT cbTableName, 438 SQLUSMALLINT fScope, 439 SQLUSMALLINT fNullable) 440{ 441 ENTER_STMT (hstmt, 442 trace_SQLSpecialColumns (TRACE_ENTER, 443 hstmt, 444 fColType, 445 szTableQualifier, cbTableQualifier, 446 szTableOwner, cbTableOwner, 447 szTableName, cbTableName, 448 fScope, 449 fNullable)); 450 451 retcode = SQLSpecialColumns_Internal( 452 hstmt, 453 fColType, 454 szTableQualifier, cbTableQualifier, 455 szTableOwner, cbTableOwner, 456 szTableName, cbTableName, 457 fScope, 458 fNullable, 459 'A'); 460 461 LEAVE_STMT (hstmt, 462 trace_SQLSpecialColumns (TRACE_LEAVE, 463 hstmt, 464 fColType, 465 szTableQualifier, cbTableQualifier, 466 szTableOwner, cbTableOwner, 467 szTableName, cbTableName, 468 fScope, 469 fNullable)); 470} 471 472 473#if ODBCVER >= 0x0300 474SQLRETURN SQL_API 475SQLSpecialColumnsA (SQLHSTMT hstmt, 476 SQLUSMALLINT fColType, 477 SQLCHAR * szTableQualifier, 478 SQLSMALLINT cbTableQualifier, 479 SQLCHAR * szTableOwner, 480 SQLSMALLINT cbTableOwner, 481 SQLCHAR * szTableName, 482 SQLSMALLINT cbTableName, 483 SQLUSMALLINT fScope, 484 SQLUSMALLINT fNullable) 485{ 486 ENTER_STMT (hstmt, 487 trace_SQLSpecialColumns (TRACE_ENTER, 488 hstmt, 489 fColType, 490 szTableQualifier, cbTableQualifier, 491 szTableOwner, cbTableOwner, 492 szTableName, cbTableName, 493 fScope, 494 fNullable)); 495 496 retcode = SQLSpecialColumns_Internal( 497 hstmt, 498 fColType, 499 szTableQualifier, cbTableQualifier, 500 szTableOwner, cbTableOwner, 501 szTableName, cbTableName, 502 fScope, 503 fNullable, 504 'A'); 505 506 LEAVE_STMT (hstmt, 507 trace_SQLSpecialColumns (TRACE_LEAVE, 508 hstmt, 509 fColType, 510 szTableQualifier, cbTableQualifier, 511 szTableOwner, cbTableOwner, 512 szTableName, cbTableName, 513 fScope, 514 fNullable)); 515} 516 517 518SQLRETURN SQL_API 519SQLSpecialColumnsW (SQLHSTMT hstmt, 520 SQLUSMALLINT fColType, 521 SQLWCHAR * szTableQualifier, 522 SQLSMALLINT cbTableQualifier, 523 SQLWCHAR * szTableOwner, 524 SQLSMALLINT cbTableOwner, 525 SQLWCHAR * szTableName, 526 SQLSMALLINT cbTableName, 527 SQLUSMALLINT fScope, 528 SQLUSMALLINT fNullable) 529{ 530 ENTER_STMT (hstmt, 531 trace_SQLSpecialColumnsW (TRACE_ENTER, 532 hstmt, 533 fColType, 534 szTableQualifier, cbTableQualifier, 535 szTableOwner, cbTableOwner, 536 szTableName, cbTableName, 537 fScope, 538 fNullable)); 539 540 retcode = SQLSpecialColumns_Internal( 541 hstmt, 542 fColType, 543 szTableQualifier, cbTableQualifier, 544 szTableOwner, cbTableOwner, 545 szTableName, cbTableName, 546 fScope, 547 fNullable, 548 'W'); 549 550 LEAVE_STMT (hstmt, 551 trace_SQLSpecialColumnsW (TRACE_LEAVE, 552 hstmt, 553 fColType, 554 szTableQualifier, cbTableQualifier, 555 szTableOwner, cbTableOwner, 556 szTableName, cbTableName, 557 fScope, 558 fNullable)); 559} 560#endif 561 562 563SQLRETURN SQL_API 564SQLStatistics_Internal ( 565 SQLHSTMT hstmt, 566 SQLPOINTER szTableQualifier, 567 SQLSMALLINT cbTableQualifier, 568 SQLPOINTER szTableOwner, 569 SQLSMALLINT cbTableOwner, 570 SQLPOINTER szTableName, 571 SQLSMALLINT cbTableName, 572 SQLUSMALLINT fUnique, 573 SQLUSMALLINT fAccuracy, 574 SQLCHAR waMode) 575{ 576 STMT (pstmt, hstmt); 577 CONN (pdbc, pstmt->hdbc); 578 ENVR (penv, pdbc->henv); 579 HPROC hproc = SQL_NULL_HPROC; 580 SQLRETURN retcode = SQL_SUCCESS; 581 sqlstcode_t sqlstat = en_00000; 582 void * _TableQualifier = NULL; 583 void * _TableOwner = NULL; 584 void * _TableName = NULL; 585 586 for (;;) 587 { 588 if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS) 589 || (cbTableOwner < 0 && cbTableOwner != SQL_NTS) 590 || (cbTableName < 0 && cbTableName != SQL_NTS)) 591 { 592 sqlstat = en_S1090; 593 break; 594 } 595 596 if (fUnique != SQL_INDEX_UNIQUE && fUnique != SQL_INDEX_ALL) 597 { 598 sqlstat = en_S1100; 599 break; 600 } 601 602 if (fAccuracy != SQL_ENSURE && fAccuracy != SQL_QUICK) 603 { 604 sqlstat = en_S1101; 605 break; 606 } 607 608 retcode = _iodbcdm_cata_state_ok (pstmt, en_Statistics); 609 610 if (retcode != SQL_SUCCESS) 611 { 612 return SQL_ERROR; 613 } 614 615 616 if ((penv->unicode_driver && waMode != 'W') 617 || (!penv->unicode_driver && waMode == 'W')) 618 { 619 if (waMode != 'W') 620 { 621 /* ansi=>unicode*/ 622 _TableQualifier = _iodbcdm_conv_param_A2W(pstmt, 0, (SQLCHAR *)szTableQualifier, cbTableQualifier); 623 _TableOwner = _iodbcdm_conv_param_A2W(pstmt, 1, (SQLCHAR *)szTableOwner, cbTableOwner); 624 _TableName = _iodbcdm_conv_param_A2W(pstmt, 2, (SQLCHAR *)szTableName, cbTableName); 625 } 626 else 627 { 628 /* unicode=>ansi*/ 629 _TableQualifier = _iodbcdm_conv_param_W2A(pstmt, 0, (SQLWCHAR *)szTableQualifier, cbTableQualifier); 630 _TableOwner = _iodbcdm_conv_param_W2A(pstmt, 1, (SQLWCHAR *)szTableOwner, cbTableOwner); 631 _TableName = _iodbcdm_conv_param_W2A(pstmt, 2, (SQLWCHAR *)szTableName, cbTableName); 632 } 633 szTableQualifier = _TableQualifier; 634 szTableOwner = _TableOwner; 635 szTableName = _TableName; 636 cbTableQualifier = SQL_NTS; 637 cbTableOwner = SQL_NTS; 638 cbTableName = SQL_NTS; 639 } 640 641 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 642 en_Statistics, ( 643 pstmt->dhstmt, 644 szTableQualifier, 645 cbTableQualifier, 646 szTableOwner, 647 cbTableOwner, 648 szTableName, 649 cbTableName, 650 fUnique, 651 fAccuracy)); 652 653 if (hproc == SQL_NULL_HPROC) 654 { 655 sqlstat = en_IM001; 656 break; 657 } 658 659 sqlstat = en_00000; 660 661 if (1) /* turn off solaris warning message */ 662 break; 663 } 664 665 if (retcode != SQL_STILL_EXECUTING) 666 _iodbcdm_FreeStmtParams(pstmt); 667 668 if (sqlstat != en_00000) 669 { 670 PUSHSQLERR (pstmt->herr, sqlstat); 671 672 return SQL_ERROR; 673 } 674 675 retcode = _iodbcdm_cata_state_tr (pstmt, en_Statistics, retcode); 676 return retcode; 677} 678 679 680SQLRETURN SQL_API 681SQLStatistics (SQLHSTMT hstmt, 682 SQLCHAR * szTableQualifier, 683 SQLSMALLINT cbTableQualifier, 684 SQLCHAR * szTableOwner, 685 SQLSMALLINT cbTableOwner, 686 SQLCHAR * szTableName, 687 SQLSMALLINT cbTableName, 688 SQLUSMALLINT fUnique, 689 SQLUSMALLINT fAccuracy) 690{ 691 ENTER_STMT (hstmt, 692 trace_SQLStatistics (TRACE_ENTER, 693 hstmt, 694 szTableQualifier, cbTableQualifier, 695 szTableOwner, cbTableOwner, 696 szTableName, cbTableName, 697 fUnique, 698 fAccuracy)); 699 700 retcode = SQLStatistics_Internal ( 701 hstmt, 702 szTableQualifier, cbTableQualifier, 703 szTableOwner, cbTableOwner, 704 szTableName, cbTableName, 705 fUnique, 706 fAccuracy, 707 'A'); 708 709 LEAVE_STMT (hstmt, 710 trace_SQLStatistics (TRACE_LEAVE, 711 hstmt, 712 szTableQualifier, cbTableQualifier, 713 szTableOwner, cbTableOwner, 714 szTableName, cbTableName, 715 fUnique, 716 fAccuracy)); 717} 718 719 720#if ODBCVER >= 0x0300 721SQLRETURN SQL_API 722SQLStatisticsA (SQLHSTMT hstmt, 723 SQLCHAR * szTableQualifier, 724 SQLSMALLINT cbTableQualifier, 725 SQLCHAR * szTableOwner, 726 SQLSMALLINT cbTableOwner, 727 SQLCHAR * szTableName, 728 SQLSMALLINT cbTableName, 729 SQLUSMALLINT fUnique, 730 SQLUSMALLINT fAccuracy) 731{ 732 ENTER_STMT (hstmt, 733 trace_SQLStatistics (TRACE_ENTER, 734 hstmt, 735 szTableQualifier, cbTableQualifier, 736 szTableOwner, cbTableOwner, 737 szTableName, cbTableName, 738 fUnique, 739 fAccuracy)); 740 741 retcode = SQLStatistics_Internal ( 742 hstmt, 743 szTableQualifier, cbTableQualifier, 744 szTableOwner, cbTableOwner, 745 szTableName, cbTableName, 746 fUnique, 747 fAccuracy, 748 'A'); 749 750 LEAVE_STMT (hstmt, 751 trace_SQLStatistics (TRACE_LEAVE, 752 hstmt, 753 szTableQualifier, cbTableQualifier, 754 szTableOwner, cbTableOwner, 755 szTableName, cbTableName, 756 fUnique, 757 fAccuracy)); 758} 759 760 761SQLRETURN SQL_API 762SQLStatisticsW (SQLHSTMT hstmt, 763 SQLWCHAR * szTableQualifier, 764 SQLSMALLINT cbTableQualifier, 765 SQLWCHAR * szTableOwner, 766 SQLSMALLINT cbTableOwner, 767 SQLWCHAR * szTableName, 768 SQLSMALLINT cbTableName, 769 SQLUSMALLINT fUnique, 770 SQLUSMALLINT fAccuracy) 771{ 772 ENTER_STMT (hstmt, 773 trace_SQLStatisticsW (TRACE_ENTER, 774 hstmt, 775 szTableQualifier, cbTableQualifier, 776 szTableOwner, cbTableOwner, 777 szTableName, cbTableName, 778 fUnique, 779 fAccuracy)); 780 781 retcode = SQLStatistics_Internal ( 782 hstmt, 783 szTableQualifier, cbTableQualifier, 784 szTableOwner, cbTableOwner, 785 szTableName, cbTableName, 786 fUnique, 787 fAccuracy, 788 'W'); 789 790 LEAVE_STMT (hstmt, 791 trace_SQLStatisticsW (TRACE_LEAVE, 792 hstmt, 793 szTableQualifier, cbTableQualifier, 794 szTableOwner, cbTableOwner, 795 szTableName, cbTableName, 796 fUnique, 797 fAccuracy)); 798} 799#endif 800 801 802SQLRETURN SQL_API 803SQLTables_Internal ( 804 SQLHSTMT hstmt, 805 SQLPOINTER szTableQualifier, 806 SQLSMALLINT cbTableQualifier, 807 SQLPOINTER szTableOwner, 808 SQLSMALLINT cbTableOwner, 809 SQLPOINTER szTableName, 810 SQLSMALLINT cbTableName, 811 SQLPOINTER szTableType, 812 SQLSMALLINT cbTableType, 813 SQLCHAR waMode) 814{ 815 STMT (pstmt, hstmt); 816 CONN (pdbc, pstmt->hdbc); 817 ENVR (penv, pdbc->henv); 818 HPROC hproc = SQL_NULL_HPROC; 819 SQLRETURN retcode = SQL_SUCCESS; 820 sqlstcode_t sqlstat = en_00000; 821 void * _TableQualifier = NULL; 822 void * _TableOwner = NULL; 823 void * _TableName = NULL; 824 void * _TableType = NULL; 825 826 for (;;) 827 { 828 if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS) 829 || (cbTableOwner < 0 && cbTableOwner != SQL_NTS) 830 || (cbTableName < 0 && cbTableName != SQL_NTS) 831 || (cbTableType < 0 && cbTableType != SQL_NTS)) 832 { 833 sqlstat = en_S1090; 834 break; 835 } 836 837 retcode = _iodbcdm_cata_state_ok (pstmt, en_Tables); 838 839 if (retcode != SQL_SUCCESS) 840 { 841 return SQL_ERROR; 842 } 843 844 if ((penv->unicode_driver && waMode != 'W') 845 || (!penv->unicode_driver && waMode == 'W')) 846 { 847 if (waMode != 'W') 848 { 849 /* ansi=>unicode*/ 850 _TableQualifier = _iodbcdm_conv_param_A2W(pstmt, 0, (SQLCHAR *)szTableQualifier, cbTableQualifier); 851 _TableOwner = _iodbcdm_conv_param_A2W(pstmt, 1, (SQLCHAR *)szTableOwner, cbTableOwner); 852 _TableName = _iodbcdm_conv_param_A2W(pstmt, 2, (SQLCHAR *)szTableName, cbTableName); 853 _TableType = _iodbcdm_conv_param_A2W(pstmt, 3, (SQLCHAR *)szTableType, cbTableType); 854 } 855 else 856 { 857 /* unicode=>ansi*/ 858 _TableQualifier = _iodbcdm_conv_param_W2A(pstmt, 0, (SQLWCHAR *)szTableQualifier, cbTableQualifier); 859 _TableOwner = _iodbcdm_conv_param_W2A(pstmt, 1, (SQLWCHAR *)szTableOwner, cbTableOwner); 860 _TableName = _iodbcdm_conv_param_W2A(pstmt, 2, (SQLWCHAR *)szTableName, cbTableName); 861 _TableType = _iodbcdm_conv_param_W2A(pstmt, 3, (SQLWCHAR *)szTableType, cbTableType); 862 } 863 szTableQualifier = _TableQualifier; 864 szTableOwner = _TableOwner; 865 szTableName = _TableName; 866 szTableType = _TableType; 867 cbTableQualifier = SQL_NTS; 868 cbTableOwner = SQL_NTS; 869 cbTableName = SQL_NTS; 870 cbTableType = SQL_NTS; 871 } 872 873 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 874 en_Tables, ( 875 pstmt->dhstmt, 876 szTableQualifier, 877 cbTableQualifier, 878 szTableOwner, 879 cbTableOwner, 880 szTableName, 881 cbTableName, 882 szTableType, 883 cbTableType)); 884 885 if (hproc == SQL_NULL_HPROC) 886 { 887 sqlstat = en_IM001; 888 break; 889 } 890 891 sqlstat = en_00000; 892 893 if (1) /* turn off solaris warning message */ 894 break; 895 } 896 897 if (retcode != SQL_STILL_EXECUTING) 898 _iodbcdm_FreeStmtParams(pstmt); 899 900 if (sqlstat != en_00000) 901 { 902 PUSHSQLERR (pstmt->herr, sqlstat); 903 904 return SQL_ERROR; 905 } 906 907 retcode = _iodbcdm_cata_state_tr (pstmt, en_Tables, retcode); 908 return retcode; 909} 910 911 912SQLRETURN SQL_API 913SQLTables (SQLHSTMT hstmt, 914 SQLCHAR * szTableQualifier, 915 SQLSMALLINT cbTableQualifier, 916 SQLCHAR * szTableOwner, 917 SQLSMALLINT cbTableOwner, 918 SQLCHAR * szTableName, 919 SQLSMALLINT cbTableName, 920 SQLCHAR * szTableType, 921 SQLSMALLINT cbTableType) 922{ 923 ENTER_STMT (hstmt, 924 trace_SQLTables (TRACE_ENTER, 925 hstmt, 926 szTableQualifier, cbTableQualifier, 927 szTableOwner, cbTableOwner, 928 szTableName, cbTableName, 929 szTableType, cbTableType)); 930 931 retcode = SQLTables_Internal( 932 hstmt, 933 szTableQualifier, cbTableQualifier, 934 szTableOwner, cbTableOwner, 935 szTableName, cbTableName, 936 szTableType, cbTableType, 937 'A'); 938 939 LEAVE_STMT (hstmt, 940 trace_SQLTables (TRACE_LEAVE, 941 hstmt, 942 szTableQualifier, cbTableQualifier, 943 szTableOwner, cbTableOwner, 944 szTableName, cbTableName, 945 szTableType, cbTableType)); 946} 947 948 949#if ODBCVER >= 0x0300 950SQLRETURN SQL_API 951SQLTablesA (SQLHSTMT hstmt, 952 SQLCHAR * szTableQualifier, 953 SQLSMALLINT cbTableQualifier, 954 SQLCHAR * szTableOwner, 955 SQLSMALLINT cbTableOwner, 956 SQLCHAR * szTableName, 957 SQLSMALLINT cbTableName, 958 SQLCHAR * szTableType, 959 SQLSMALLINT cbTableType) 960{ 961 ENTER_STMT (hstmt, 962 trace_SQLTables (TRACE_ENTER, 963 hstmt, 964 szTableQualifier, cbTableQualifier, 965 szTableOwner, cbTableOwner, 966 szTableName, cbTableName, 967 szTableType, cbTableType)); 968 969 retcode = SQLTables_Internal ( 970 hstmt, 971 szTableQualifier, cbTableQualifier, 972 szTableOwner, cbTableOwner, 973 szTableName, cbTableName, 974 szTableType, cbTableType, 975 'A'); 976 977 LEAVE_STMT (hstmt, 978 trace_SQLTables (TRACE_LEAVE, 979 hstmt, 980 szTableQualifier, cbTableQualifier, 981 szTableOwner, cbTableOwner, 982 szTableName, cbTableName, 983 szTableType, cbTableType)); 984} 985 986 987SQLRETURN SQL_API 988SQLTablesW (SQLHSTMT hstmt, 989 SQLWCHAR * szTableQualifier, 990 SQLSMALLINT cbTableQualifier, 991 SQLWCHAR * szTableOwner, 992 SQLSMALLINT cbTableOwner, 993 SQLWCHAR * szTableName, 994 SQLSMALLINT cbTableName, 995 SQLWCHAR * szTableType, 996 SQLSMALLINT cbTableType) 997{ 998 ENTER_STMT (hstmt, 999 trace_SQLTablesW (TRACE_ENTER, 1000 hstmt, 1001 szTableQualifier, cbTableQualifier, 1002 szTableOwner, cbTableOwner, 1003 szTableName, cbTableName, 1004 szTableType, cbTableType)); 1005 1006 retcode = SQLTables_Internal ( 1007 hstmt, 1008 szTableQualifier, cbTableQualifier, 1009 szTableOwner, cbTableOwner, 1010 szTableName, cbTableName, 1011 szTableType, cbTableType, 1012 'W'); 1013 1014 LEAVE_STMT (hstmt, 1015 trace_SQLTablesW (TRACE_LEAVE, 1016 hstmt, 1017 szTableQualifier, cbTableQualifier, 1018 szTableOwner, cbTableOwner, 1019 szTableName, cbTableName, 1020 szTableType, cbTableType)); 1021} 1022#endif 1023 1024 1025SQLRETURN SQL_API 1026SQLColumnPrivileges_Internal ( 1027 SQLHSTMT hstmt, 1028 SQLPOINTER szTableQualifier, 1029 SQLSMALLINT cbTableQualifier, 1030 SQLPOINTER szTableOwner, 1031 SQLSMALLINT cbTableOwner, 1032 SQLPOINTER szTableName, 1033 SQLSMALLINT cbTableName, 1034 SQLPOINTER szColumnName, 1035 SQLSMALLINT cbColumnName, 1036 SQLCHAR waMode) 1037{ 1038 STMT (pstmt, hstmt); 1039 CONN (pdbc, pstmt->hdbc); 1040 ENVR (penv, pdbc->henv); 1041 HPROC hproc = SQL_NULL_HPROC; 1042 SQLRETURN retcode = SQL_SUCCESS; 1043 sqlstcode_t sqlstat = en_00000; 1044 void * _TableQualifier = NULL; 1045 void * _TableOwner = NULL; 1046 void * _TableName = NULL; 1047 void * _ColumnName = NULL; 1048 1049 for (;;) 1050 { 1051 if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS) 1052 || (cbTableOwner < 0 && cbTableOwner != SQL_NTS) 1053 || (cbTableName < 0 && cbTableName != SQL_NTS) 1054 || (cbColumnName < 0 && cbColumnName != SQL_NTS)) 1055 { 1056 sqlstat = en_S1090; 1057 break; 1058 } 1059 1060 retcode = _iodbcdm_cata_state_ok (pstmt, en_ColumnPrivileges); 1061 1062 if (retcode != SQL_SUCCESS) 1063 { 1064 return SQL_ERROR; 1065 } 1066 1067 1068 if ((penv->unicode_driver && waMode != 'W') 1069 || (!penv->unicode_driver && waMode == 'W')) 1070 { 1071 if (waMode != 'W') 1072 { 1073 /* ansi=>unicode*/ 1074 _TableQualifier = _iodbcdm_conv_param_A2W(pstmt, 0, (SQLCHAR *)szTableQualifier, cbTableQualifier); 1075 _TableOwner = _iodbcdm_conv_param_A2W(pstmt, 1, (SQLCHAR *)szTableOwner, cbTableOwner); 1076 _TableName = _iodbcdm_conv_param_A2W(pstmt, 2, (SQLCHAR *)szTableName, cbTableName); 1077 _ColumnName = _iodbcdm_conv_param_A2W(pstmt, 3, (SQLCHAR *)szColumnName, cbColumnName); 1078 } 1079 else 1080 { 1081 /* unicode=>ansi*/ 1082 _TableQualifier = _iodbcdm_conv_param_W2A(pstmt, 0, (SQLWCHAR *)szTableQualifier, cbTableQualifier); 1083 _TableOwner = _iodbcdm_conv_param_W2A(pstmt, 1, (SQLWCHAR *)szTableOwner, cbTableOwner); 1084 _TableName = _iodbcdm_conv_param_W2A(pstmt, 2, (SQLWCHAR *)szTableName, cbTableName); 1085 _ColumnName = _iodbcdm_conv_param_W2A(pstmt, 3, (SQLWCHAR *)szColumnName, cbColumnName); 1086 } 1087 szTableQualifier = _TableQualifier; 1088 szTableOwner = _TableOwner; 1089 szTableName = _TableName; 1090 szColumnName = _ColumnName; 1091 cbTableQualifier = SQL_NTS; 1092 cbTableOwner = SQL_NTS; 1093 cbTableName = SQL_NTS; 1094 cbColumnName = SQL_NTS; 1095 } 1096 1097 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 1098 en_ColumnPrivileges, ( 1099 pstmt->dhstmt, 1100 szTableQualifier, 1101 cbTableQualifier, 1102 szTableOwner, 1103 cbTableOwner, 1104 szTableName, 1105 cbTableName, 1106 szColumnName, 1107 cbColumnName)); 1108 1109 if (hproc == SQL_NULL_HPROC) 1110 { 1111 sqlstat = en_IM001; 1112 break; 1113 } 1114 1115 sqlstat = en_00000; 1116 1117 if (1) /* turn off solaris warning message */ 1118 break; 1119 } 1120 1121 if (retcode != SQL_STILL_EXECUTING) 1122 _iodbcdm_FreeStmtParams(pstmt); 1123 1124 if (sqlstat != en_00000) 1125 { 1126 PUSHSQLERR (pstmt->herr, sqlstat); 1127 1128 return SQL_ERROR; 1129 } 1130 1131 retcode = _iodbcdm_cata_state_tr (pstmt, en_ColumnPrivileges, retcode); 1132 return retcode; 1133} 1134 1135 1136SQLRETURN SQL_API 1137SQLColumnPrivileges (SQLHSTMT hstmt, 1138 SQLCHAR * szTableQualifier, 1139 SQLSMALLINT cbTableQualifier, 1140 SQLCHAR * szTableOwner, 1141 SQLSMALLINT cbTableOwner, 1142 SQLCHAR * szTableName, 1143 SQLSMALLINT cbTableName, 1144 SQLCHAR * szColumnName, 1145 SQLSMALLINT cbColumnName) 1146{ 1147 ENTER_STMT (hstmt, 1148 trace_SQLColumnPrivileges (TRACE_ENTER, 1149 hstmt, 1150 szTableQualifier, cbTableQualifier, 1151 szTableOwner, cbTableOwner, 1152 szTableName, cbTableName, 1153 szColumnName, cbColumnName)); 1154 1155 retcode = SQLColumnPrivileges_Internal(hstmt, 1156 szTableQualifier, cbTableQualifier, 1157 szTableOwner, cbTableOwner, 1158 szTableName, cbTableName, 1159 szColumnName, cbColumnName, 1160 'A'); 1161 1162 LEAVE_STMT (hstmt, 1163 trace_SQLColumnPrivileges (TRACE_LEAVE, 1164 hstmt, 1165 szTableQualifier, cbTableQualifier, 1166 szTableOwner, cbTableOwner, 1167 szTableName, cbTableName, 1168 szColumnName, cbColumnName)); 1169} 1170 1171 1172#if ODBCVER >= 0x0300 1173SQLRETURN SQL_API 1174SQLColumnPrivilegesA (SQLHSTMT hstmt, 1175 SQLCHAR * szTableQualifier, 1176 SQLSMALLINT cbTableQualifier, 1177 SQLCHAR * szTableOwner, 1178 SQLSMALLINT cbTableOwner, 1179 SQLCHAR * szTableName, 1180 SQLSMALLINT cbTableName, 1181 SQLCHAR * szColumnName, 1182 SQLSMALLINT cbColumnName) 1183{ 1184 ENTER_STMT (hstmt, 1185 trace_SQLColumnPrivileges (TRACE_ENTER, 1186 hstmt, 1187 szTableQualifier, cbTableQualifier, 1188 szTableOwner, cbTableOwner, 1189 szTableName, cbTableName, 1190 szColumnName, cbColumnName)); 1191 1192 retcode = SQLColumnPrivileges_Internal(hstmt, 1193 szTableQualifier, cbTableQualifier, 1194 szTableOwner, cbTableOwner, 1195 szTableName, cbTableName, 1196 szColumnName, cbColumnName, 1197 'A'); 1198 1199 LEAVE_STMT (hstmt, 1200 trace_SQLColumnPrivileges (TRACE_LEAVE, 1201 hstmt, 1202 szTableQualifier, cbTableQualifier, 1203 szTableOwner, cbTableOwner, 1204 szTableName, cbTableName, 1205 szColumnName, cbColumnName)); 1206} 1207 1208 1209SQLRETURN SQL_API 1210SQLColumnPrivilegesW (SQLHSTMT hstmt, 1211 SQLWCHAR * szTableQualifier, 1212 SQLSMALLINT cbTableQualifier, 1213 SQLWCHAR * szTableOwner, 1214 SQLSMALLINT cbTableOwner, 1215 SQLWCHAR * szTableName, 1216 SQLSMALLINT cbTableName, 1217 SQLWCHAR * szColumnName, 1218 SQLSMALLINT cbColumnName) 1219{ 1220 ENTER_STMT (hstmt, 1221 trace_SQLColumnPrivilegesW (TRACE_ENTER, 1222 hstmt, 1223 szTableQualifier, cbTableQualifier, 1224 szTableOwner, cbTableOwner, 1225 szTableName, cbTableName, 1226 szColumnName, cbColumnName)); 1227 1228 retcode = SQLColumnPrivileges_Internal (hstmt, 1229 szTableQualifier, cbTableQualifier, 1230 szTableOwner, cbTableOwner, 1231 szTableName, cbTableName, 1232 szColumnName, cbColumnName, 1233 'W'); 1234 1235 LEAVE_STMT (hstmt, 1236 trace_SQLColumnPrivilegesW (TRACE_LEAVE, 1237 hstmt, 1238 szTableQualifier, cbTableQualifier, 1239 szTableOwner, cbTableOwner, 1240 szTableName, cbTableName, 1241 szColumnName, cbColumnName)); 1242} 1243#endif 1244 1245 1246SQLRETURN SQL_API 1247SQLColumns_Internal ( 1248 SQLHSTMT hstmt, 1249 SQLPOINTER szTableQualifier, 1250 SQLSMALLINT cbTableQualifier, 1251 SQLPOINTER szTableOwner, 1252 SQLSMALLINT cbTableOwner, 1253 SQLPOINTER szTableName, 1254 SQLSMALLINT cbTableName, 1255 SQLPOINTER szColumnName, 1256 SQLSMALLINT cbColumnName, 1257 SQLCHAR waMode) 1258{ 1259 STMT (pstmt, hstmt); 1260 CONN (pdbc, pstmt->hdbc); 1261 ENVR (penv, pdbc->henv); 1262 HPROC hproc = SQL_NULL_HPROC; 1263 SQLRETURN retcode = SQL_SUCCESS; 1264 sqlstcode_t sqlstat = en_00000; 1265 void * _TableQualifier = NULL; 1266 void * _TableOwner = NULL; 1267 void * _TableName = NULL; 1268 void * _ColumnName = NULL; 1269 1270 for (;;) 1271 { 1272 if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS) 1273 || (cbTableOwner < 0 && cbTableOwner != SQL_NTS) 1274 || (cbTableName < 0 && cbTableName != SQL_NTS) 1275 || (cbColumnName < 0 && cbColumnName != SQL_NTS)) 1276 { 1277 sqlstat = en_S1090; 1278 break; 1279 } 1280 1281 retcode = _iodbcdm_cata_state_ok (pstmt, en_Columns); 1282 1283 if (retcode != SQL_SUCCESS) 1284 { 1285 return SQL_ERROR; 1286 } 1287 1288 if ((penv->unicode_driver && waMode != 'W') 1289 || (!penv->unicode_driver && waMode == 'W')) 1290 { 1291 if (waMode != 'W') 1292 { 1293 /* ansi=>unicode*/ 1294 _TableQualifier = _iodbcdm_conv_param_A2W(pstmt, 0, (SQLCHAR *)szTableQualifier, cbTableQualifier); 1295 _TableOwner = _iodbcdm_conv_param_A2W(pstmt, 1, (SQLCHAR *)szTableOwner, cbTableOwner); 1296 _TableName = _iodbcdm_conv_param_A2W(pstmt, 2, (SQLCHAR *)szTableName, cbTableName); 1297 _ColumnName = _iodbcdm_conv_param_A2W(pstmt, 3, (SQLCHAR *)szColumnName, cbColumnName); 1298 } 1299 else 1300 { 1301 /* unicode=>ansi*/ 1302 _TableQualifier = _iodbcdm_conv_param_W2A(pstmt, 0, (SQLWCHAR *) szTableQualifier, cbTableQualifier); 1303 _TableOwner = _iodbcdm_conv_param_W2A(pstmt, 1, (SQLWCHAR *) szTableOwner, cbTableOwner); 1304 _TableName = _iodbcdm_conv_param_W2A(pstmt, 2, (SQLWCHAR *) szTableName, cbTableName); 1305 _ColumnName = _iodbcdm_conv_param_W2A(pstmt, 3, (SQLWCHAR *) szColumnName, cbColumnName); 1306 } 1307 szTableQualifier = _TableQualifier; 1308 szTableOwner = _TableOwner; 1309 szTableName = _TableName; 1310 szColumnName = _ColumnName; 1311 cbTableQualifier = SQL_NTS; 1312 cbTableOwner = SQL_NTS; 1313 cbTableName = SQL_NTS; 1314 cbColumnName = SQL_NTS; 1315 } 1316 1317 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 1318 en_Columns, ( 1319 pstmt->dhstmt, 1320 szTableQualifier, 1321 cbTableQualifier, 1322 szTableOwner, 1323 cbTableOwner, 1324 szTableName, 1325 cbTableName, 1326 szColumnName, 1327 cbColumnName)); 1328 1329 if (hproc == SQL_NULL_HPROC) 1330 { 1331 sqlstat = en_IM001; 1332 break; 1333 } 1334 1335 sqlstat = en_00000; 1336 1337 if (1) /* turn off solaris warning message */ 1338 break; 1339 } 1340 1341 if (retcode != SQL_STILL_EXECUTING) 1342 _iodbcdm_FreeStmtParams(pstmt); 1343 1344 if (sqlstat != en_00000) 1345 { 1346 PUSHSQLERR (pstmt->herr, sqlstat); 1347 1348 return SQL_ERROR; 1349 } 1350 1351 retcode = _iodbcdm_cata_state_tr (pstmt, en_Columns, retcode); 1352 return retcode; 1353} 1354 1355 1356SQLRETURN SQL_API 1357SQLColumns (SQLHSTMT hstmt, 1358 SQLCHAR * szTableQualifier, 1359 SQLSMALLINT cbTableQualifier, 1360 SQLCHAR * szTableOwner, 1361 SQLSMALLINT cbTableOwner, 1362 SQLCHAR * szTableName, 1363 SQLSMALLINT cbTableName, 1364 SQLCHAR * szColumnName, 1365 SQLSMALLINT cbColumnName) 1366{ 1367 ENTER_STMT (hstmt, 1368 trace_SQLColumns (TRACE_ENTER, 1369 hstmt, 1370 szTableQualifier, cbTableQualifier, 1371 szTableOwner, cbTableOwner, 1372 szTableName, cbTableName, 1373 szColumnName, cbColumnName)); 1374 1375 retcode = SQLColumns_Internal ( 1376 hstmt, 1377 szTableQualifier, cbTableQualifier, 1378 szTableOwner, cbTableOwner, 1379 szTableName, cbTableName, 1380 szColumnName, cbColumnName, 1381 'A'); 1382 1383 LEAVE_STMT (hstmt, 1384 trace_SQLColumns (TRACE_LEAVE, 1385 hstmt, 1386 szTableQualifier, cbTableQualifier, 1387 szTableOwner, cbTableOwner, 1388 szTableName, cbTableName, 1389 szColumnName, cbColumnName)); 1390} 1391 1392 1393#if ODBCVER >= 0x0300 1394SQLRETURN SQL_API 1395SQLColumnsA (SQLHSTMT hstmt, 1396 SQLCHAR * szTableQualifier, 1397 SQLSMALLINT cbTableQualifier, 1398 SQLCHAR * szTableOwner, 1399 SQLSMALLINT cbTableOwner, 1400 SQLCHAR * szTableName, 1401 SQLSMALLINT cbTableName, 1402 SQLCHAR * szColumnName, 1403 SQLSMALLINT cbColumnName) 1404{ 1405 ENTER_STMT (hstmt, 1406 trace_SQLColumns (TRACE_ENTER, 1407 hstmt, 1408 szTableQualifier, cbTableQualifier, 1409 szTableOwner, cbTableOwner, 1410 szTableName, cbTableName, 1411 szColumnName, cbColumnName)); 1412 1413 retcode = SQLColumns_Internal ( 1414 hstmt, 1415 szTableQualifier, cbTableQualifier, 1416 szTableOwner, cbTableOwner, 1417 szTableName, cbTableName, 1418 szColumnName, cbColumnName, 1419 'A'); 1420 1421 LEAVE_STMT (hstmt, 1422 trace_SQLColumns (TRACE_LEAVE, 1423 hstmt, 1424 szTableQualifier, cbTableQualifier, 1425 szTableOwner, cbTableOwner, 1426 szTableName, cbTableName, 1427 szColumnName, cbColumnName)); 1428} 1429 1430 1431SQLRETURN SQL_API 1432SQLColumnsW (SQLHSTMT hstmt, 1433 SQLWCHAR * szTableQualifier, 1434 SQLSMALLINT cbTableQualifier, 1435 SQLWCHAR * szTableOwner, 1436 SQLSMALLINT cbTableOwner, 1437 SQLWCHAR * szTableName, 1438 SQLSMALLINT cbTableName, 1439 SQLWCHAR * szColumnName, 1440 SQLSMALLINT cbColumnName) 1441{ 1442 ENTER_STMT (hstmt, 1443 trace_SQLColumnsW (TRACE_ENTER, 1444 hstmt, 1445 szTableQualifier, cbTableQualifier, 1446 szTableOwner, cbTableOwner, 1447 szTableName, cbTableName, 1448 szColumnName, cbColumnName)); 1449 1450 retcode = SQLColumns_Internal ( 1451 hstmt, 1452 szTableQualifier, cbTableQualifier, 1453 szTableOwner, cbTableOwner, 1454 szTableName, cbTableName, 1455 szColumnName, cbColumnName, 1456 'W'); 1457 1458 LEAVE_STMT (hstmt, 1459 trace_SQLColumnsW (TRACE_LEAVE, 1460 hstmt, 1461 szTableQualifier, cbTableQualifier, 1462 szTableOwner, cbTableOwner, 1463 szTableName, cbTableName, 1464 szColumnName, cbColumnName)); 1465} 1466#endif 1467 1468 1469SQLRETURN SQL_API 1470SQLForeignKeys_Internal ( 1471 SQLHSTMT hstmt, 1472 SQLPOINTER szPkTableQualifier, 1473 SQLSMALLINT cbPkTableQualifier, 1474 SQLPOINTER szPkTableOwner, 1475 SQLSMALLINT cbPkTableOwner, 1476 SQLPOINTER szPkTableName, 1477 SQLSMALLINT cbPkTableName, 1478 SQLPOINTER szFkTableQualifier, 1479 SQLSMALLINT cbFkTableQualifier, 1480 SQLPOINTER szFkTableOwner, 1481 SQLSMALLINT cbFkTableOwner, 1482 SQLPOINTER szFkTableName, 1483 SQLSMALLINT cbFkTableName, 1484 SQLCHAR waMode) 1485{ 1486 STMT (pstmt, hstmt); 1487 CONN (pdbc, pstmt->hdbc); 1488 ENVR (penv, pdbc->henv); 1489 HPROC hproc = SQL_NULL_HPROC; 1490 SQLRETURN retcode = SQL_SUCCESS; 1491 sqlstcode_t sqlstat = en_00000; 1492 void * _PkTableQualifier = NULL; 1493 void * _PkTableOwner = NULL; 1494 void * _PkTableName = NULL; 1495 void * _FkTableQualifier = NULL; 1496 void * _FkTableOwner = NULL; 1497 void * _FkTableName = NULL; 1498 1499 for (;;) 1500 { 1501 if ((cbPkTableQualifier < 0 && cbPkTableQualifier != SQL_NTS) 1502 || (cbPkTableOwner < 0 && cbPkTableOwner != SQL_NTS) 1503 || (cbPkTableName < 0 && cbPkTableName != SQL_NTS) 1504 || (cbFkTableQualifier < 0 && cbFkTableQualifier != SQL_NTS) 1505 || (cbFkTableOwner < 0 && cbFkTableOwner != SQL_NTS) 1506 || (cbFkTableName < 0 && cbFkTableName != SQL_NTS)) 1507 { 1508 sqlstat = en_S1090; 1509 break; 1510 } 1511 1512 retcode = _iodbcdm_cata_state_ok (pstmt, en_ForeignKeys); 1513 1514 if (retcode != SQL_SUCCESS) 1515 { 1516 return SQL_ERROR; 1517 } 1518 1519 if ((penv->unicode_driver && waMode != 'W') 1520 || (!penv->unicode_driver && waMode == 'W')) 1521 { 1522 if (waMode != 'W') 1523 { 1524 /* ansi=>unicode*/ 1525 _PkTableQualifier = _iodbcdm_conv_param_A2W(pstmt, 0, (SQLCHAR *)szPkTableQualifier, cbPkTableQualifier); 1526 _PkTableOwner = _iodbcdm_conv_param_A2W(pstmt, 1, (SQLCHAR *)szPkTableOwner, cbPkTableOwner); 1527 _PkTableName = _iodbcdm_conv_param_A2W(pstmt, 2, (SQLCHAR *)szPkTableName, cbPkTableName); 1528 _FkTableQualifier = _iodbcdm_conv_param_A2W(pstmt, 3, (SQLCHAR *)szFkTableQualifier, cbFkTableQualifier); 1529 _FkTableOwner = _iodbcdm_conv_param_A2W(pstmt, 4, (SQLCHAR *)szFkTableOwner, cbFkTableOwner); 1530 _FkTableName = _iodbcdm_conv_param_A2W(pstmt, 5, (SQLCHAR *)szFkTableName, cbFkTableName); 1531 } 1532 else 1533 { 1534 /* unicode=>ansi*/ 1535 _PkTableQualifier = _iodbcdm_conv_param_W2A(pstmt, 0, (SQLWCHAR *)szPkTableQualifier, cbPkTableQualifier); 1536 _PkTableOwner = _iodbcdm_conv_param_W2A(pstmt, 1, (SQLWCHAR *)szPkTableOwner, cbPkTableOwner); 1537 _PkTableName = _iodbcdm_conv_param_W2A(pstmt, 2, (SQLWCHAR *)szPkTableName, cbPkTableName); 1538 _FkTableQualifier = _iodbcdm_conv_param_W2A(pstmt, 3, (SQLWCHAR *)szFkTableQualifier, cbFkTableQualifier); 1539 _FkTableOwner = _iodbcdm_conv_param_W2A(pstmt, 4, (SQLWCHAR *)szFkTableOwner, cbFkTableOwner); 1540 _FkTableName = _iodbcdm_conv_param_W2A(pstmt, 5, (SQLWCHAR *)szFkTableName, cbFkTableName); 1541 } 1542 szPkTableQualifier = _PkTableQualifier; 1543 szPkTableOwner = _PkTableOwner; 1544 szPkTableName = _PkTableName; 1545 szFkTableQualifier = _FkTableQualifier; 1546 szFkTableOwner = _FkTableOwner; 1547 szFkTableName = _FkTableName; 1548 cbPkTableQualifier = SQL_NTS; 1549 cbPkTableOwner = SQL_NTS; 1550 cbPkTableName = SQL_NTS; 1551 cbFkTableQualifier = SQL_NTS; 1552 cbFkTableOwner = SQL_NTS; 1553 cbFkTableName = SQL_NTS; 1554 } 1555 1556 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 1557 en_ForeignKeys, ( 1558 pstmt->dhstmt, 1559 szPkTableQualifier, 1560 cbPkTableQualifier, 1561 szPkTableOwner, 1562 cbPkTableOwner, 1563 szPkTableName, 1564 cbPkTableName, 1565 szFkTableQualifier, 1566 cbFkTableQualifier, 1567 szFkTableOwner, 1568 cbFkTableOwner, 1569 szFkTableName, 1570 cbFkTableName)); 1571 1572 if (hproc == SQL_NULL_HPROC) 1573 { 1574 sqlstat = en_IM001; 1575 break; 1576 } 1577 1578 sqlstat = en_00000; 1579 1580 if (1) /* turn off solaris warning message */ 1581 break; 1582 } 1583 1584 if (retcode != SQL_STILL_EXECUTING) 1585 _iodbcdm_FreeStmtParams(pstmt); 1586 1587 if (sqlstat != en_00000) 1588 { 1589 PUSHSQLERR (pstmt->herr, sqlstat); 1590 1591 return SQL_ERROR; 1592 } 1593 1594 retcode = _iodbcdm_cata_state_tr (pstmt, en_ForeignKeys, retcode); 1595 return retcode; 1596} 1597 1598 1599SQLRETURN SQL_API 1600SQLForeignKeys (SQLHSTMT hstmt, 1601 SQLCHAR * szPkTableQualifier, 1602 SQLSMALLINT cbPkTableQualifier, 1603 SQLCHAR * szPkTableOwner, 1604 SQLSMALLINT cbPkTableOwner, 1605 SQLCHAR * szPkTableName, 1606 SQLSMALLINT cbPkTableName, 1607 SQLCHAR * szFkTableQualifier, 1608 SQLSMALLINT cbFkTableQualifier, 1609 SQLCHAR * szFkTableOwner, 1610 SQLSMALLINT cbFkTableOwner, 1611 SQLCHAR * szFkTableName, 1612 SQLSMALLINT cbFkTableName) 1613{ 1614 ENTER_STMT (hstmt, 1615 trace_SQLForeignKeys (TRACE_ENTER, 1616 hstmt, 1617 szPkTableQualifier, cbPkTableQualifier, 1618 szPkTableOwner, cbPkTableOwner, 1619 szPkTableName, cbPkTableName, 1620 szFkTableQualifier, cbFkTableQualifier, 1621 szFkTableOwner, cbFkTableOwner, 1622 szFkTableName, cbFkTableName)); 1623 1624 retcode = SQLForeignKeys_Internal( 1625 hstmt, 1626 szPkTableQualifier, cbPkTableQualifier, 1627 szPkTableOwner, cbPkTableOwner, 1628 szPkTableName, cbPkTableName, 1629 szFkTableQualifier, cbFkTableQualifier, 1630 szFkTableOwner, cbFkTableOwner, 1631 szFkTableName, cbFkTableName, 1632 'A'); 1633 1634 LEAVE_STMT (hstmt, 1635 trace_SQLForeignKeys (TRACE_LEAVE, 1636 hstmt, 1637 szPkTableQualifier, cbPkTableQualifier, 1638 szPkTableOwner, cbPkTableOwner, 1639 szPkTableName, cbPkTableName, 1640 szFkTableQualifier, cbFkTableQualifier, 1641 szFkTableOwner, cbFkTableOwner, 1642 szFkTableName, cbFkTableName)); 1643} 1644 1645 1646#if ODBCVER >= 0x0300 1647SQLRETURN SQL_API 1648SQLForeignKeysA (SQLHSTMT hstmt, 1649 SQLCHAR * szPkTableQualifier, 1650 SQLSMALLINT cbPkTableQualifier, 1651 SQLCHAR * szPkTableOwner, 1652 SQLSMALLINT cbPkTableOwner, 1653 SQLCHAR * szPkTableName, 1654 SQLSMALLINT cbPkTableName, 1655 SQLCHAR * szFkTableQualifier, 1656 SQLSMALLINT cbFkTableQualifier, 1657 SQLCHAR * szFkTableOwner, 1658 SQLSMALLINT cbFkTableOwner, 1659 SQLCHAR * szFkTableName, 1660 SQLSMALLINT cbFkTableName) 1661{ 1662 ENTER_STMT (hstmt, 1663 trace_SQLForeignKeys (TRACE_ENTER, 1664 hstmt, 1665 szPkTableQualifier, cbPkTableQualifier, 1666 szPkTableOwner, cbPkTableOwner, 1667 szPkTableName, cbPkTableName, 1668 szFkTableQualifier, cbFkTableQualifier, 1669 szFkTableOwner, cbFkTableOwner, 1670 szFkTableName, cbFkTableName)); 1671 1672 retcode = SQLForeignKeys_Internal( 1673 hstmt, 1674 szPkTableQualifier, cbPkTableQualifier, 1675 szPkTableOwner, cbPkTableOwner, 1676 szPkTableName, cbPkTableName, 1677 szFkTableQualifier, cbFkTableQualifier, 1678 szFkTableOwner, cbFkTableOwner, 1679 szFkTableName, cbFkTableName, 1680 'A'); 1681 1682 LEAVE_STMT (hstmt, 1683 trace_SQLForeignKeys (TRACE_LEAVE, 1684 hstmt, 1685 szPkTableQualifier, cbPkTableQualifier, 1686 szPkTableOwner, cbPkTableOwner, 1687 szPkTableName, cbPkTableName, 1688 szFkTableQualifier, cbFkTableQualifier, 1689 szFkTableOwner, cbFkTableOwner, 1690 szFkTableName, cbFkTableName)); 1691} 1692 1693 1694SQLRETURN SQL_API 1695SQLForeignKeysW (SQLHSTMT hstmt, 1696 SQLWCHAR * szPkTableQualifier, 1697 SQLSMALLINT cbPkTableQualifier, 1698 SQLWCHAR * szPkTableOwner, 1699 SQLSMALLINT cbPkTableOwner, 1700 SQLWCHAR * szPkTableName, 1701 SQLSMALLINT cbPkTableName, 1702 SQLWCHAR * szFkTableQualifier, 1703 SQLSMALLINT cbFkTableQualifier, 1704 SQLWCHAR * szFkTableOwner, 1705 SQLSMALLINT cbFkTableOwner, 1706 SQLWCHAR * szFkTableName, 1707 SQLSMALLINT cbFkTableName) 1708{ 1709 ENTER_STMT (hstmt, 1710 trace_SQLForeignKeysW (TRACE_ENTER, 1711 hstmt, 1712 szPkTableQualifier, cbPkTableQualifier, 1713 szPkTableOwner, cbPkTableOwner, 1714 szPkTableName, cbPkTableName, 1715 szFkTableQualifier, cbFkTableQualifier, 1716 szFkTableOwner, cbFkTableOwner, 1717 szFkTableName, cbFkTableName)); 1718 1719 retcode = SQLForeignKeys_Internal( 1720 hstmt, 1721 szPkTableQualifier, cbPkTableQualifier, 1722 szPkTableOwner, cbPkTableOwner, 1723 szPkTableName, cbPkTableName, 1724 szFkTableQualifier, cbFkTableQualifier, 1725 szFkTableOwner, cbFkTableOwner, 1726 szFkTableName, cbFkTableName, 1727 'W'); 1728 1729 LEAVE_STMT (hstmt, 1730 trace_SQLForeignKeysW (TRACE_LEAVE, 1731 hstmt, 1732 szPkTableQualifier, cbPkTableQualifier, 1733 szPkTableOwner, cbPkTableOwner, 1734 szPkTableName, cbPkTableName, 1735 szFkTableQualifier, cbFkTableQualifier, 1736 szFkTableOwner, cbFkTableOwner, 1737 szFkTableName, cbFkTableName)); 1738} 1739#endif 1740 1741 1742SQLRETURN SQL_API 1743SQLPrimaryKeys_Internal ( 1744 SQLHSTMT hstmt, 1745 SQLPOINTER szTableQualifier, 1746 SQLSMALLINT cbTableQualifier, 1747 SQLPOINTER szTableOwner, 1748 SQLSMALLINT cbTableOwner, 1749 SQLPOINTER szTableName, 1750 SQLSMALLINT cbTableName, 1751 SQLCHAR waMode) 1752{ 1753 STMT (pstmt, hstmt); 1754 CONN (pdbc, pstmt->hdbc); 1755 ENVR (penv, pdbc->henv); 1756 HPROC hproc = SQL_NULL_HPROC; 1757 SQLRETURN retcode = SQL_SUCCESS; 1758 sqlstcode_t sqlstat = en_00000; 1759 void * _TableQualifier = NULL; 1760 void * _TableOwner = NULL; 1761 void * _TableName = NULL; 1762 1763 for (;;) 1764 { 1765 if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS) 1766 || (cbTableOwner < 0 && cbTableOwner != SQL_NTS) 1767 || (cbTableName < 0 && cbTableName != SQL_NTS)) 1768 { 1769 sqlstat = en_S1090; 1770 break; 1771 } 1772 1773 retcode = _iodbcdm_cata_state_ok (pstmt, en_PrimaryKeys); 1774 1775 if (retcode != SQL_SUCCESS) 1776 { 1777 return SQL_ERROR; 1778 } 1779 1780 if ((penv->unicode_driver && waMode != 'W') 1781 || (!penv->unicode_driver && waMode == 'W')) 1782 { 1783 if (waMode != 'W') 1784 { 1785 /* ansi=>unicode*/ 1786 _TableQualifier = _iodbcdm_conv_param_A2W(pstmt, 0, (SQLCHAR *)szTableQualifier, cbTableQualifier); 1787 _TableOwner = _iodbcdm_conv_param_A2W(pstmt, 1, (SQLCHAR *)szTableOwner, cbTableOwner); 1788 _TableName = _iodbcdm_conv_param_A2W(pstmt, 2, (SQLCHAR *)szTableName, cbTableName); 1789 } 1790 else 1791 { 1792 /* unicode=>ansi*/ 1793 _TableQualifier = _iodbcdm_conv_param_W2A(pstmt, 0, (SQLWCHAR *)szTableQualifier, cbTableQualifier); 1794 _TableOwner = _iodbcdm_conv_param_W2A(pstmt, 1, (SQLWCHAR *)szTableOwner, cbTableOwner); 1795 _TableName = _iodbcdm_conv_param_W2A(pstmt, 2, (SQLWCHAR *)szTableName, cbTableName); 1796 } 1797 szTableQualifier = _TableQualifier; 1798 szTableOwner = _TableOwner; 1799 szTableName = _TableName; 1800 cbTableQualifier = SQL_NTS; 1801 cbTableOwner = SQL_NTS; 1802 cbTableName = SQL_NTS; 1803 } 1804 1805 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 1806 en_PrimaryKeys, ( 1807 pstmt->dhstmt, 1808 szTableQualifier, 1809 cbTableQualifier, 1810 szTableOwner, 1811 cbTableOwner, 1812 szTableName, 1813 cbTableName)); 1814 1815 if (hproc == SQL_NULL_HPROC) 1816 { 1817 sqlstat = en_IM001; 1818 break; 1819 } 1820 1821 sqlstat = en_00000; 1822 1823 if (1) /* turn off solaris warning message */ 1824 break; 1825 } 1826 1827 if (retcode != SQL_STILL_EXECUTING) 1828 _iodbcdm_FreeStmtParams(pstmt); 1829 1830 if (sqlstat != en_00000) 1831 { 1832 PUSHSQLERR (pstmt->herr, sqlstat); 1833 1834 return SQL_ERROR; 1835 } 1836 1837 retcode = _iodbcdm_cata_state_tr (pstmt, en_PrimaryKeys, retcode); 1838 return retcode; 1839} 1840 1841 1842SQLRETURN SQL_API 1843SQLPrimaryKeys (SQLHSTMT hstmt, 1844 SQLCHAR * szTableQualifier, 1845 SQLSMALLINT cbTableQualifier, 1846 SQLCHAR * szTableOwner, 1847 SQLSMALLINT cbTableOwner, 1848 SQLCHAR * szTableName, 1849 SQLSMALLINT cbTableName) 1850{ 1851 ENTER_STMT (hstmt, 1852 trace_SQLPrimaryKeys (TRACE_ENTER, 1853 hstmt, 1854 szTableQualifier, cbTableQualifier, 1855 szTableOwner, cbTableOwner, 1856 szTableName, cbTableName)); 1857 1858 retcode = SQLPrimaryKeys_Internal ( 1859 hstmt, 1860 szTableQualifier, cbTableQualifier, 1861 szTableOwner, cbTableOwner, 1862 szTableName, cbTableName, 1863 'A'); 1864 1865 LEAVE_STMT (hstmt, 1866 trace_SQLPrimaryKeys (TRACE_LEAVE, 1867 hstmt, 1868 szTableQualifier, cbTableQualifier, 1869 szTableOwner, cbTableOwner, 1870 szTableName, cbTableName)); 1871} 1872 1873 1874#if ODBCVER >= 0x0300 1875SQLRETURN SQL_API 1876SQLPrimaryKeysA (SQLHSTMT hstmt, 1877 SQLCHAR * szTableQualifier, 1878 SQLSMALLINT cbTableQualifier, 1879 SQLCHAR * szTableOwner, 1880 SQLSMALLINT cbTableOwner, 1881 SQLCHAR * szTableName, 1882 SQLSMALLINT cbTableName) 1883{ 1884 ENTER_STMT (hstmt, 1885 trace_SQLPrimaryKeys (TRACE_ENTER, 1886 hstmt, 1887 szTableQualifier, cbTableQualifier, 1888 szTableOwner, cbTableOwner, 1889 szTableName, cbTableName)); 1890 1891 retcode = SQLPrimaryKeys_Internal ( 1892 hstmt, 1893 szTableQualifier, cbTableQualifier, 1894 szTableOwner, cbTableOwner, 1895 szTableName, cbTableName, 1896 'A'); 1897 1898 LEAVE_STMT (hstmt, 1899 trace_SQLPrimaryKeys (TRACE_LEAVE, 1900 hstmt, 1901 szTableQualifier, cbTableQualifier, 1902 szTableOwner, cbTableOwner, 1903 szTableName, cbTableName)); 1904} 1905 1906 1907SQLRETURN SQL_API 1908SQLPrimaryKeysW (SQLHSTMT hstmt, 1909 SQLWCHAR * szTableQualifier, 1910 SQLSMALLINT cbTableQualifier, 1911 SQLWCHAR * szTableOwner, 1912 SQLSMALLINT cbTableOwner, 1913 SQLWCHAR * szTableName, 1914 SQLSMALLINT cbTableName) 1915{ 1916 ENTER_STMT (hstmt, 1917 trace_SQLPrimaryKeysW (TRACE_ENTER, 1918 hstmt, 1919 szTableQualifier, cbTableQualifier, 1920 szTableOwner, cbTableOwner, 1921 szTableName, cbTableName)); 1922 1923 retcode = SQLPrimaryKeys_Internal ( 1924 hstmt, 1925 szTableQualifier, cbTableQualifier, 1926 szTableOwner, cbTableOwner, 1927 szTableName, cbTableName, 1928 'W'); 1929 1930 LEAVE_STMT (hstmt, 1931 trace_SQLPrimaryKeysW (TRACE_LEAVE, 1932 hstmt, 1933 szTableQualifier, cbTableQualifier, 1934 szTableOwner, cbTableOwner, 1935 szTableName, cbTableName)); 1936} 1937#endif 1938 1939 1940SQLRETURN SQL_API 1941SQLProcedureColumns_Internal ( 1942 SQLHSTMT hstmt, 1943 SQLPOINTER szProcQualifier, 1944 SQLSMALLINT cbProcQualifier, 1945 SQLPOINTER szProcOwner, 1946 SQLSMALLINT cbProcOwner, 1947 SQLPOINTER szProcName, 1948 SQLSMALLINT cbProcName, 1949 SQLPOINTER szColumnName, 1950 SQLSMALLINT cbColumnName, 1951 SQLCHAR waMode) 1952{ 1953 STMT (pstmt, hstmt); 1954 CONN (pdbc, pstmt->hdbc); 1955 ENVR (penv, pdbc->henv); 1956 HPROC hproc = SQL_NULL_HPROC; 1957 SQLRETURN retcode = SQL_SUCCESS; 1958 sqlstcode_t sqlstat = en_00000; 1959 void * _ProcQualifier = NULL; 1960 void * _ProcOwner = NULL; 1961 void * _ProcName = NULL; 1962 void * _ColumnName = NULL; 1963 1964 for (;;) 1965 { 1966 if ((cbProcQualifier < 0 && cbProcQualifier != SQL_NTS) 1967 || (cbProcOwner < 0 && cbProcOwner != SQL_NTS) 1968 || (cbProcName < 0 && cbProcName != SQL_NTS) 1969 || (cbColumnName < 0 && cbColumnName != SQL_NTS)) 1970 { 1971 sqlstat = en_S1090; 1972 break; 1973 } 1974 1975 retcode = _iodbcdm_cata_state_ok (pstmt, en_ProcedureColumns); 1976 1977 if (retcode != SQL_SUCCESS) 1978 { 1979 return SQL_ERROR; 1980 } 1981 1982 if ((penv->unicode_driver && waMode != 'W') 1983 || (!penv->unicode_driver && waMode == 'W')) 1984 { 1985 if (waMode != 'W') 1986 { 1987 /* ansi=>unicode*/ 1988 _ProcQualifier = _iodbcdm_conv_param_A2W(pstmt, 0, (SQLCHAR *)szProcQualifier, cbProcQualifier); 1989 _ProcOwner = _iodbcdm_conv_param_A2W(pstmt, 1, (SQLCHAR *)szProcOwner, cbProcOwner); 1990 _ProcName = _iodbcdm_conv_param_A2W(pstmt, 2, (SQLCHAR *)szProcName, cbProcName); 1991 _ColumnName = _iodbcdm_conv_param_A2W(pstmt, 3, (SQLCHAR *)szColumnName, cbColumnName); 1992 } 1993 else 1994 { 1995 /* unicode=>ansi*/ 1996 _ProcQualifier = _iodbcdm_conv_param_W2A(pstmt, 0, (SQLWCHAR *)szProcQualifier, cbProcQualifier); 1997 _ProcOwner = _iodbcdm_conv_param_W2A(pstmt, 1, (SQLWCHAR *)szProcOwner, cbProcOwner); 1998 _ProcName = _iodbcdm_conv_param_W2A(pstmt, 2, (SQLWCHAR *)szProcName, cbProcName); 1999 _ColumnName = _iodbcdm_conv_param_W2A(pstmt, 3, (SQLWCHAR *)szColumnName, cbColumnName); 2000 } 2001 szProcQualifier = _ProcQualifier; 2002 szProcOwner = _ProcOwner; 2003 szProcName = _ProcName; 2004 szColumnName = _ColumnName; 2005 cbProcQualifier = SQL_NTS; 2006 cbProcOwner = SQL_NTS; 2007 cbProcName = SQL_NTS; 2008 cbColumnName = SQL_NTS; 2009 } 2010 2011 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 2012 en_ProcedureColumns, ( 2013 pstmt->dhstmt, 2014 szProcQualifier, 2015 cbProcQualifier, 2016 szProcOwner, 2017 cbProcOwner, 2018 szProcName, 2019 cbProcName, 2020 szColumnName, 2021 cbColumnName)); 2022 2023 if (hproc == SQL_NULL_HPROC) 2024 { 2025 sqlstat = en_IM001; 2026 break; 2027 } 2028 2029 sqlstat = en_00000; 2030 2031 if (1) /* turn off solaris warning message */ 2032 break; 2033 } 2034 2035 if (retcode != SQL_STILL_EXECUTING) 2036 _iodbcdm_FreeStmtParams(pstmt); 2037 2038 if (sqlstat != en_00000) 2039 { 2040 PUSHSQLERR (pstmt->herr, sqlstat); 2041 2042 return SQL_ERROR; 2043 } 2044 2045 retcode = _iodbcdm_cata_state_tr (pstmt, en_ProcedureColumns, retcode); 2046 return retcode; 2047} 2048 2049 2050SQLRETURN SQL_API 2051SQLProcedureColumns (SQLHSTMT hstmt, 2052 SQLCHAR * szProcQualifier, 2053 SQLSMALLINT cbProcQualifier, 2054 SQLCHAR * szProcOwner, 2055 SQLSMALLINT cbProcOwner, 2056 SQLCHAR * szProcName, 2057 SQLSMALLINT cbProcName, 2058 SQLCHAR * szColumnName, 2059 SQLSMALLINT cbColumnName) 2060{ 2061 ENTER_STMT (hstmt, 2062 trace_SQLProcedureColumns (TRACE_ENTER, 2063 hstmt, 2064 szProcQualifier, cbProcQualifier, 2065 szProcOwner, cbProcOwner, 2066 szProcName, cbProcName, 2067 szColumnName, cbColumnName)); 2068 2069 retcode = SQLProcedureColumns_Internal ( 2070 hstmt, 2071 szProcQualifier, cbProcQualifier, 2072 szProcOwner, cbProcOwner, 2073 szProcName, cbProcName, 2074 szColumnName, cbColumnName, 2075 'A'); 2076 2077 LEAVE_STMT (hstmt, 2078 trace_SQLProcedureColumns (TRACE_LEAVE, 2079 hstmt, 2080 szProcQualifier, cbProcQualifier, 2081 szProcOwner, cbProcOwner, 2082 szProcName, cbProcName, 2083 szColumnName, cbColumnName)); 2084} 2085 2086 2087#if ODBCVER >= 0x0300 2088SQLRETURN SQL_API 2089SQLProcedureColumnsA (SQLHSTMT hstmt, 2090 SQLCHAR * szProcQualifier, 2091 SQLSMALLINT cbProcQualifier, 2092 SQLCHAR * szProcOwner, 2093 SQLSMALLINT cbProcOwner, 2094 SQLCHAR * szProcName, 2095 SQLSMALLINT cbProcName, 2096 SQLCHAR * szColumnName, 2097 SQLSMALLINT cbColumnName) 2098{ 2099 ENTER_STMT (hstmt, 2100 trace_SQLProcedureColumns (TRACE_ENTER, 2101 hstmt, 2102 szProcQualifier, cbProcQualifier, 2103 szProcOwner, cbProcOwner, 2104 szProcName, cbProcName, 2105 szColumnName, cbColumnName)); 2106 2107 retcode = SQLProcedureColumns_Internal ( 2108 hstmt, 2109 szProcQualifier, cbProcQualifier, 2110 szProcOwner, cbProcOwner, 2111 szProcName, cbProcName, 2112 szColumnName, cbColumnName, 2113 'A'); 2114 2115 LEAVE_STMT (hstmt, 2116 trace_SQLProcedureColumns (TRACE_LEAVE, 2117 hstmt, 2118 szProcQualifier, cbProcQualifier, 2119 szProcOwner, cbProcOwner, 2120 szProcName, cbProcName, 2121 szColumnName, cbColumnName)); 2122} 2123 2124 2125SQLRETURN SQL_API 2126SQLProcedureColumnsW (SQLHSTMT hstmt, 2127 SQLWCHAR * szProcQualifier, 2128 SQLSMALLINT cbProcQualifier, 2129 SQLWCHAR * szProcOwner, 2130 SQLSMALLINT cbProcOwner, 2131 SQLWCHAR * szProcName, 2132 SQLSMALLINT cbProcName, 2133 SQLWCHAR * szColumnName, 2134 SQLSMALLINT cbColumnName) 2135{ 2136 ENTER_STMT (hstmt, 2137 trace_SQLProcedureColumnsW (TRACE_ENTER, 2138 hstmt, 2139 szProcQualifier, cbProcQualifier, 2140 szProcOwner, cbProcOwner, 2141 szProcName, cbProcName, 2142 szColumnName, cbColumnName)); 2143 2144 retcode = SQLProcedureColumns_Internal ( 2145 hstmt, 2146 szProcQualifier, cbProcQualifier, 2147 szProcOwner, cbProcOwner, 2148 szProcName, cbProcName, 2149 szColumnName, cbColumnName, 2150 'W'); 2151 2152 LEAVE_STMT (hstmt, 2153 trace_SQLProcedureColumnsW (TRACE_LEAVE, 2154 hstmt, 2155 szProcQualifier, cbProcQualifier, 2156 szProcOwner, cbProcOwner, 2157 szProcName, cbProcName, 2158 szColumnName, cbColumnName)); 2159} 2160#endif 2161 2162 2163SQLRETURN SQL_API 2164SQLProcedures_Internal ( 2165 SQLHSTMT hstmt, 2166 SQLPOINTER szProcQualifier, 2167 SQLSMALLINT cbProcQualifier, 2168 SQLPOINTER szProcOwner, 2169 SQLSMALLINT cbProcOwner, 2170 SQLPOINTER szProcName, 2171 SQLSMALLINT cbProcName, 2172 SQLCHAR waMode) 2173{ 2174 STMT (pstmt, hstmt); 2175 CONN (pdbc, pstmt->hdbc); 2176 ENVR (penv, pdbc->henv); 2177 HPROC hproc = SQL_NULL_HPROC; 2178 SQLRETURN retcode = SQL_SUCCESS; 2179 sqlstcode_t sqlstat = en_00000; 2180 void * _ProcQualifier = NULL; 2181 void * _ProcOwner = NULL; 2182 void * _ProcName = NULL; 2183 2184 for (;;) 2185 { 2186 if ((cbProcQualifier < 0 && cbProcQualifier != SQL_NTS) 2187 || (cbProcOwner < 0 && cbProcOwner != SQL_NTS) 2188 || (cbProcName < 0 && cbProcName != SQL_NTS)) 2189 { 2190 sqlstat = en_S1090; 2191 break; 2192 } 2193 2194 retcode = _iodbcdm_cata_state_ok (pstmt, en_Procedures); 2195 2196 if (retcode != SQL_SUCCESS) 2197 { 2198 return SQL_ERROR; 2199 } 2200 2201 if ((penv->unicode_driver && waMode != 'W') 2202 || (!penv->unicode_driver && waMode == 'W')) 2203 { 2204 if (waMode != 'W') 2205 { 2206 /* ansi=>unicode*/ 2207 _ProcQualifier = _iodbcdm_conv_param_A2W(pstmt, 0, (SQLCHAR *)szProcQualifier, cbProcQualifier); 2208 _ProcOwner = _iodbcdm_conv_param_A2W(pstmt, 1, (SQLCHAR *)szProcOwner, cbProcOwner); 2209 _ProcName = _iodbcdm_conv_param_A2W(pstmt, 2, (SQLCHAR *)szProcName, cbProcName); 2210 } 2211 else 2212 { 2213 /* unicode=>ansi*/ 2214 _ProcQualifier = _iodbcdm_conv_param_W2A(pstmt, 0, (SQLWCHAR *)szProcQualifier, cbProcQualifier); 2215 _ProcOwner = _iodbcdm_conv_param_W2A(pstmt, 1, (SQLWCHAR *)szProcOwner, cbProcOwner); 2216 _ProcName = _iodbcdm_conv_param_W2A(pstmt, 2, (SQLWCHAR *)szProcName, cbProcName); 2217 } 2218 szProcQualifier = _ProcQualifier; 2219 szProcOwner = _ProcOwner; 2220 szProcName = _ProcName; 2221 cbProcQualifier = SQL_NTS; 2222 cbProcOwner = SQL_NTS; 2223 cbProcName = SQL_NTS; 2224 } 2225 2226 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 2227 en_Procedures, ( 2228 pstmt->dhstmt, 2229 szProcQualifier, 2230 cbProcQualifier, 2231 szProcOwner, 2232 cbProcOwner, 2233 szProcName, 2234 cbProcName)); 2235 2236 if (hproc == SQL_NULL_HPROC) 2237 { 2238 sqlstat = en_IM001; 2239 break; 2240 } 2241 2242 sqlstat = en_00000; 2243 2244 if (1) /* turn off solaris warning message */ 2245 break; 2246 } 2247 2248 if (retcode != SQL_STILL_EXECUTING) 2249 _iodbcdm_FreeStmtParams(pstmt); 2250 2251 if (sqlstat != en_00000) 2252 { 2253 PUSHSQLERR (pstmt->herr, sqlstat); 2254 2255 return SQL_ERROR; 2256 } 2257 2258 retcode = _iodbcdm_cata_state_tr (pstmt, en_Procedures, retcode); 2259 return retcode; 2260} 2261 2262 2263SQLRETURN SQL_API 2264SQLProcedures (SQLHSTMT hstmt, 2265 SQLCHAR * szProcQualifier, 2266 SQLSMALLINT cbProcQualifier, 2267 SQLCHAR * szProcOwner, 2268 SQLSMALLINT cbProcOwner, 2269 SQLCHAR * szProcName, 2270 SQLSMALLINT cbProcName) 2271{ 2272 ENTER_STMT (hstmt, 2273 trace_SQLProcedures (TRACE_ENTER, 2274 hstmt, 2275 szProcQualifier, cbProcQualifier, 2276 szProcOwner, cbProcOwner, 2277 szProcName, cbProcName)); 2278 2279 retcode = SQLProcedures_Internal ( 2280 hstmt, 2281 szProcQualifier, cbProcQualifier, 2282 szProcOwner, cbProcOwner, 2283 szProcName, cbProcName, 2284 'A'); 2285 2286 LEAVE_STMT (hstmt, 2287 trace_SQLProcedures (TRACE_LEAVE, 2288 hstmt, 2289 szProcQualifier, cbProcQualifier, 2290 szProcOwner, cbProcOwner, 2291 szProcName, cbProcName)); 2292} 2293 2294 2295#if ODBCVER >= 0x0300 2296SQLRETURN SQL_API 2297SQLProceduresA (SQLHSTMT hstmt, 2298 SQLCHAR * szProcQualifier, 2299 SQLSMALLINT cbProcQualifier, 2300 SQLCHAR * szProcOwner, 2301 SQLSMALLINT cbProcOwner, 2302 SQLCHAR * szProcName, 2303 SQLSMALLINT cbProcName) 2304{ 2305 ENTER_STMT (hstmt, 2306 trace_SQLProcedures (TRACE_ENTER, 2307 hstmt, 2308 szProcQualifier, cbProcQualifier, 2309 szProcOwner, cbProcOwner, 2310 szProcName, cbProcName)); 2311 2312 retcode = SQLProcedures_Internal ( 2313 hstmt, 2314 szProcQualifier, cbProcQualifier, 2315 szProcOwner, cbProcOwner, 2316 szProcName, cbProcName, 2317 'A'); 2318 2319 LEAVE_STMT (hstmt, 2320 trace_SQLProcedures (TRACE_LEAVE, 2321 hstmt, 2322 szProcQualifier, cbProcQualifier, 2323 szProcOwner, cbProcOwner, 2324 szProcName, cbProcName)); 2325} 2326 2327 2328SQLRETURN SQL_API 2329SQLProceduresW (SQLHSTMT hstmt, 2330 SQLWCHAR * szProcQualifier, 2331 SQLSMALLINT cbProcQualifier, 2332 SQLWCHAR * szProcOwner, 2333 SQLSMALLINT cbProcOwner, 2334 SQLWCHAR * szProcName, 2335 SQLSMALLINT cbProcName) 2336{ 2337 ENTER_STMT (hstmt, 2338 trace_SQLProceduresW (TRACE_ENTER, 2339 hstmt, 2340 szProcQualifier, cbProcQualifier, 2341 szProcOwner, cbProcOwner, 2342 szProcName, cbProcName)); 2343 2344 retcode = SQLProcedures_Internal ( 2345 hstmt, 2346 szProcQualifier, cbProcQualifier, 2347 szProcOwner, cbProcOwner, 2348 szProcName, cbProcName, 2349 'W'); 2350 2351 LEAVE_STMT (hstmt, 2352 trace_SQLProceduresW (TRACE_LEAVE, 2353 hstmt, 2354 szProcQualifier, cbProcQualifier, 2355 szProcOwner, cbProcOwner, 2356 szProcName, cbProcName)); 2357} 2358#endif 2359 2360 2361SQLRETURN SQL_API 2362SQLTablePrivileges_Internal ( 2363 SQLHSTMT hstmt, 2364 SQLPOINTER szTableQualifier, 2365 SQLSMALLINT cbTableQualifier, 2366 SQLPOINTER szTableOwner, 2367 SQLSMALLINT cbTableOwner, 2368 SQLPOINTER szTableName, 2369 SQLSMALLINT cbTableName, 2370 SQLCHAR waMode) 2371{ 2372 STMT (pstmt, hstmt); 2373 CONN (pdbc, pstmt->hdbc); 2374 ENVR (penv, pdbc->henv); 2375 HPROC hproc = SQL_NULL_HPROC; 2376 SQLRETURN retcode = SQL_SUCCESS; 2377 sqlstcode_t sqlstat = en_00000; 2378 void * _TableQualifier = NULL; 2379 void * _TableOwner = NULL; 2380 void * _TableName = NULL; 2381 2382 for (;;) 2383 { 2384 if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS) 2385 || (cbTableOwner < 0 && cbTableOwner != SQL_NTS) 2386 || (cbTableName < 0 && cbTableName != SQL_NTS)) 2387 { 2388 sqlstat = en_S1090; 2389 break; 2390 } 2391 2392 retcode = _iodbcdm_cata_state_ok (pstmt, en_TablePrivileges); 2393 2394 if (retcode != SQL_SUCCESS) 2395 { 2396 return SQL_ERROR; 2397 } 2398 2399 if ((penv->unicode_driver && waMode != 'W') 2400 || (!penv->unicode_driver && waMode == 'W')) 2401 { 2402 if (waMode != 'W') 2403 { 2404 /* ansi=>unicode*/ 2405 _TableQualifier = _iodbcdm_conv_param_A2W(pstmt, 0, (SQLCHAR *)szTableQualifier, cbTableQualifier); 2406 _TableOwner = _iodbcdm_conv_param_A2W(pstmt, 1, (SQLCHAR *)szTableOwner, cbTableOwner); 2407 _TableName = _iodbcdm_conv_param_A2W(pstmt, 2, (SQLCHAR *)szTableName, cbTableName); 2408 } 2409 else 2410 { 2411 /* unicode=>ansi*/ 2412 _TableQualifier = _iodbcdm_conv_param_W2A(pstmt, 0, (SQLWCHAR *)szTableQualifier, cbTableQualifier); 2413 _TableOwner = _iodbcdm_conv_param_W2A(pstmt, 1, (SQLWCHAR *)szTableOwner, cbTableOwner); 2414 _TableName = _iodbcdm_conv_param_W2A(pstmt, 2, (SQLWCHAR *)szTableName, cbTableName); 2415 } 2416 szTableQualifier = _TableQualifier; 2417 szTableOwner = _TableOwner; 2418 szTableName = _TableName; 2419 cbTableQualifier = SQL_NTS; 2420 cbTableOwner = SQL_NTS; 2421 cbTableName = SQL_NTS; 2422 } 2423 2424 CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, 2425 en_TablePrivileges, ( 2426 pstmt->dhstmt, 2427 szTableQualifier, 2428 cbTableQualifier, 2429 szTableOwner, 2430 cbTableOwner, 2431 szTableName, 2432 cbTableName)); 2433 2434 if (hproc == SQL_NULL_HPROC) 2435 { 2436 sqlstat = en_IM001; 2437 break; 2438 } 2439 2440 sqlstat = en_00000; 2441 2442 if (1) /* turn off solaris warning message */ 2443 break; 2444 } 2445 2446 if (retcode != SQL_STILL_EXECUTING) 2447 _iodbcdm_FreeStmtParams(pstmt); 2448 2449 if (sqlstat != en_00000) 2450 { 2451 PUSHSQLERR (pstmt->herr, sqlstat); 2452 2453 return SQL_ERROR; 2454 } 2455 2456 retcode = _iodbcdm_cata_state_tr (pstmt, en_TablePrivileges, retcode); 2457 return retcode; 2458} 2459 2460 2461SQLRETURN SQL_API 2462SQLTablePrivileges (SQLHSTMT hstmt, 2463 SQLCHAR * szTableQualifier, 2464 SQLSMALLINT cbTableQualifier, 2465 SQLCHAR * szTableOwner, 2466 SQLSMALLINT cbTableOwner, 2467 SQLCHAR * szTableName, 2468 SQLSMALLINT cbTableName) 2469{ 2470 ENTER_STMT (hstmt, 2471 trace_SQLTablePrivileges (TRACE_ENTER, 2472 hstmt, 2473 szTableQualifier, cbTableQualifier, 2474 szTableOwner, cbTableOwner, 2475 szTableName,cbTableName)); 2476 2477 retcode = SQLTablePrivileges_Internal( 2478 hstmt, 2479 szTableQualifier, cbTableQualifier, 2480 szTableOwner, cbTableOwner, 2481 szTableName,cbTableName, 2482 'A'); 2483 2484 LEAVE_STMT (hstmt, 2485 trace_SQLTablePrivileges (TRACE_LEAVE, 2486 hstmt, 2487 szTableQualifier, cbTableQualifier, 2488 szTableOwner, cbTableOwner, 2489 szTableName,cbTableName)); 2490} 2491 2492 2493#if ODBCVER >= 0x0300 2494SQLRETURN SQL_API 2495SQLTablePrivilegesA (SQLHSTMT hstmt, 2496 SQLCHAR * szTableQualifier, 2497 SQLSMALLINT cbTableQualifier, 2498 SQLCHAR * szTableOwner, 2499 SQLSMALLINT cbTableOwner, 2500 SQLCHAR * szTableName, 2501 SQLSMALLINT cbTableName) 2502{ 2503 ENTER_STMT (hstmt, 2504 trace_SQLTablePrivileges (TRACE_ENTER, 2505 hstmt, 2506 szTableQualifier, cbTableQualifier, 2507 szTableOwner, cbTableOwner, 2508 szTableName,cbTableName)); 2509 2510 retcode = SQLTablePrivileges_Internal( 2511 hstmt, 2512 szTableQualifier, cbTableQualifier, 2513 szTableOwner, cbTableOwner, 2514 szTableName,cbTableName, 2515 'A'); 2516 2517 LEAVE_STMT (hstmt, 2518 trace_SQLTablePrivileges (TRACE_LEAVE, 2519 hstmt, 2520 szTableQualifier, cbTableQualifier, 2521 szTableOwner, cbTableOwner, 2522 szTableName,cbTableName)); 2523} 2524 2525 2526SQLRETURN SQL_API 2527SQLTablePrivilegesW (SQLHSTMT hstmt, 2528 SQLWCHAR * szTableQualifier, 2529 SQLSMALLINT cbTableQualifier, 2530 SQLWCHAR * szTableOwner, 2531 SQLSMALLINT cbTableOwner, 2532 SQLWCHAR * szTableName, 2533 SQLSMALLINT cbTableName) 2534{ 2535 ENTER_STMT (hstmt, 2536 trace_SQLTablePrivilegesW (TRACE_ENTER, 2537 hstmt, 2538 szTableQualifier, cbTableQualifier, 2539 szTableOwner, cbTableOwner, 2540 szTableName,cbTableName)); 2541 2542 retcode = SQLTablePrivileges_Internal( 2543 hstmt, 2544 szTableQualifier, cbTableQualifier, 2545 szTableOwner, cbTableOwner, 2546 szTableName,cbTableName, 2547 'W'); 2548 2549 LEAVE_STMT (hstmt, 2550 trace_SQLTablePrivilegesW (TRACE_LEAVE, 2551 hstmt, 2552 szTableQualifier, cbTableQualifier, 2553 szTableOwner, cbTableOwner, 2554 szTableName,cbTableName)); 2555} 2556#endif 2557