Source for java.sql.DatabaseMetaData

   1: /* DatabaseMetaData.java -- Information about the database itself.
   2:    Copyright (C) 1999, 2000, 2001, 2002, 2006 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10:  
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: package java.sql;
  39: 
  40: public interface DatabaseMetaData 
  41: {
  42:   /**
  43:    * It is unknown whether or not the procedure returns a result.
  44:    */
  45:   int procedureResultUnknown = 0;
  46: 
  47:   /**
  48:    * The procedure does not return a result.
  49:    */
  50:   int procedureNoResult = 1;
  51: 
  52:   /**
  53:    * The procedure returns a result.
  54:    */
  55:   int procedureReturnsResult = 2;
  56: 
  57:   /**
  58:    * The column type is unknown.
  59:    */
  60:   int procedureColumnUnknown = 0;
  61: 
  62:   /**
  63:    * The column type is input.
  64:    */
  65:   int procedureColumnIn = 1;
  66: 
  67:   /**
  68:    * The column type is input/output.
  69:    */
  70:   int procedureColumnInOut = 2;
  71: 
  72:   /**
  73:    * The column type is output
  74:    */
  75:   int procedureColumnOut = 4;
  76: 
  77:   /**
  78:    * The column is used for return values.
  79:    */
  80:   int procedureColumnReturn = 5;
  81: 
  82:   /**
  83:    * The column is used for storing results
  84:    */
  85:   int procedureColumnResult = 3;
  86: 
  87:   /**
  88:    * NULL values are not allowed.
  89:    */
  90:   int procedureNoNulls = 0;
  91: 
  92:   /**
  93:    * NULL values are allowed.
  94:    */
  95:   int procedureNullable = 1;
  96: 
  97:   /**
  98:    * It is unknown whether or not NULL values are allowed.
  99:    */
 100:   int procedureNullableUnknown = 2;
 101: 
 102:   /**
 103:    * The column does not allow NULL
 104:    */
 105:   int columnNoNulls = 0;
 106: 
 107:   /**
 108:    * The column does allow NULL
 109:    */
 110:   int columnNullable = 1;
 111: 
 112:   /**
 113:    * It is unknown whether or not the column allows NULL
 114:    */
 115:   int columnNullableUnknown = 2;
 116: 
 117:   /**
 118:    * The best row's scope is only guaranteed to be valid so long as the
 119:    * row is actually being used.
 120:    */
 121:   int bestRowTemporary = 0;
 122: 
 123:   /**
 124:    * The best row identifier is valid to the end of the transaction.
 125:    */
 126:   int bestRowTransaction = 1;
 127: 
 128:   /**
 129:    * The best row identifier is valid to the end of the session.
 130:    */
 131:   int bestRowSession = 2;
 132: 
 133:   /**
 134:    * The best row may or may not be a pseudo-column.
 135:    */
 136:   int bestRowUnknown = 0;
 137: 
 138:   /**
 139:    * The best row identifier is not a pseudo-column.
 140:    */
 141:   int bestRowNotPseudo = 1;
 142: 
 143:   /**
 144:    * The best row identifier is a pseudo-column.
 145:    */
 146:   int bestRowPseudo = 2;
 147: 
 148:   /**
 149:    * It is unknown whether or not the version column is a pseudo-column.
 150:    */
 151:   int versionColumnUnknown = 0;
 152: 
 153:   /**
 154:    * The version column is not a pseudo-column
 155:    */
 156:   int versionColumnNotPseudo = 1;
 157: 
 158:   /**
 159:    * The version column is a pseudo-column
 160:    */
 161:   int versionColumnPseudo = 2;
 162: 
 163:   /**
 164:    * Foreign key changes are cascaded in updates or deletes.
 165:    */
 166:   int importedKeyCascade = 0;
 167: 
 168:   /**
 169:    * Column may not be updated or deleted in use as a foreign key.
 170:    */
 171:   int importedKeyRestrict = 1;
 172: 
 173:   /**
 174:    * When primary key is updated or deleted, the foreign key is set to NULL.
 175:    */
 176:   int importedKeySetNull = 2;
 177: 
 178:   /**
 179:    * If the primary key is a foreign key, it cannot be udpated or deleted.
 180:    */
 181:   int importedKeyNoAction = 3;
 182: 
 183:   /**
 184:    * If the primary key is updated or deleted, the foreign key is set to
 185:    * a default value.
 186:    */
 187:   int importedKeySetDefault = 4;
 188: 
 189:   /**
 190:    * Wish I knew what this meant.
 191:    */
 192:   int importedKeyInitiallyDeferred = 5;
 193: 
 194:   /**
 195:    * Wish I knew what this meant.
 196:    */
 197:   int importedKeyInitiallyImmediate = 6;
 198: 
 199:   /**
 200:    * Wish I knew what this meant.
 201:    */
 202:   int importedKeyNotDeferrable = 7;
 203: 
 204:   /**
 205:    * A NULL value is not allowed for this data type.
 206:    */
 207:   int typeNoNulls = 0;
 208: 
 209:   /**
 210:    * A NULL value is allowed for this data type.
 211:    */
 212:   int typeNullable = 1;
 213: 
 214:   /**
 215:    * It is unknown whether or not NULL values are allowed for this data type.
 216:    */
 217:   int typeNullableUnknown = 2;
 218: 
 219:   /**
 220:    * Where clauses are not supported for this type.
 221:    */
 222:   int typePredNone = 0;
 223: 
 224:   /**
 225:    * Only "WHERE..LIKE" style WHERE clauses are allowed on this data type.
 226:    */
 227:   int typePredChar = 1;
 228: 
 229:   /**
 230:    * All WHERE clauses except "WHERE..LIKE" style are allowed on this data type.
 231:    */
 232:   int typePredBasic = 2;
 233: 
 234:   /**
 235:    * Any type of WHERE clause is allowed for this data type.
 236:    */
 237:   int typeSearchable = 3;
 238: 
 239:   /**
 240:    * This column contains table statistics.
 241:    */
 242:   short tableIndexStatistic = 0;
 243: 
 244:   /**
 245:    * This table index is clustered.
 246:    */
 247:   short tableIndexClustered = 1;
 248: 
 249:   /**
 250:    * This table index is hashed.
 251:    */
 252:   short tableIndexHashed = 2;
 253: 
 254:   /**
 255:    * This table index is of another type.
 256:    */
 257:   short tableIndexOther = 3;
 258: 
 259:   /**
 260:    * A NULL value is not allowed for this attribute.
 261:    */
 262:   short attributeNoNulls = 0;
 263: 
 264:   /**
 265:    * A NULL value is allowed for this attribute.
 266:    */
 267:   short attributeNullable = 1;
 268: 
 269:   /**
 270:    * It is unknown whether or not NULL values are allowed for this attribute.
 271:    */
 272:   short attributeNullableUnknown = 2;
 273: 
 274:   int sqlStateXOpen = 1;
 275: 
 276:   int sqlStateSQL99 = 2;
 277: 
 278:   /**
 279:    * This method tests whether or not all the procedures returned by
 280:    * the <code>getProcedures</code> method can be called by this user.
 281:    *
 282:    * @return <code>true</code> if all the procedures can be called,
 283:    * <code>false</code> otherwise.
 284:    * @exception SQLException If an error occurs.
 285:    */
 286:   boolean allProceduresAreCallable() throws SQLException;
 287: 
 288:   /**
 289:    * This method tests whether or not all the table returned by the
 290:    * <code>getTables</code> method can be selected by this user.
 291:    *
 292:    * @return <code>true</code> if all the procedures can be called,
 293:    * <code>false</code> otherwise.
 294:    *
 295:    * @exception SQLException If an error occurs.
 296:    */
 297:   boolean allTablesAreSelectable() throws SQLException;
 298: 
 299:   /**
 300:    * This method returns the URL for this database.
 301:    *
 302:    * @return The URL string for this database, or <code>null</code> if it
 303:    *         is not known.
 304:    * @exception SQLException If an error occurs.
 305:    */
 306:   String getURL() throws SQLException;
 307: 
 308:   /**
 309:    * This method returns the database username for this connection.
 310:    *
 311:    * @return The database username.
 312:    * @exception SQLException If an error occurs.
 313:    */
 314:   String getUserName() throws SQLException;
 315: 
 316:   /**
 317:    * This method tests whether or not the database is in read only mode.
 318:    *
 319:    * @return <code>true</code> if the database is in read only mode,
 320:    *         <code>false</code> otherwise.
 321:    * @exception SQLException If an error occurs.
 322:    */
 323:   boolean isReadOnly() throws SQLException;
 324: 
 325:   /**
 326:    * This method tests whether or not NULL's sort as high values.
 327:    *
 328:    * @return <code>true</code> if NULL's sort as high values, <code>false</code>
 329:    *         otherwise.
 330:    * @exception SQLException If an error occurs.
 331:    */
 332:   boolean nullsAreSortedHigh() throws SQLException;
 333: 
 334:   /**
 335:    * This method tests whether or not NULL's sort as low values.
 336:    *
 337:    * @return <code>true</code> if NULL's sort as low values, <code>false</code>
 338:    * otherwise.
 339:    * @exception SQLException If an error occurs.
 340:    */
 341:   boolean nullsAreSortedLow() throws SQLException;
 342: 
 343:   /**
 344:    * This method tests whether or not NULL's sort as high values.
 345:    *
 346:    * @return <code>true</code> if NULL's sort as high values, <code>false</code>
 347:    * otherwise.
 348:    * @exception SQLException If an error occurs.
 349:    */
 350:   boolean nullsAreSortedAtStart() throws SQLException;
 351: 
 352:   /**
 353:    * This method test whether or not NULL's are sorted to the end
 354:    * of the list regardless of ascending or descending sort order.
 355:    *
 356:    * @return <code>true</code> if NULL's always sort to the end,
 357:    * <code>false</code> otherwise.
 358:    * @exception SQLException If an error occurs.
 359:    */
 360:   boolean nullsAreSortedAtEnd() throws SQLException;
 361: 
 362:   /**
 363:    * This method returns the name of the database product.
 364:    *
 365:    * @return The database product.
 366:    * @exception SQLException If an error occurs.
 367:    */
 368:   String getDatabaseProductName() throws SQLException;
 369: 
 370:   /**
 371:    * This method returns the version of the database product.
 372:    *
 373:    * @return The version of the database product.
 374:    * @exception SQLException If an error occurs.
 375:    */
 376:   String getDatabaseProductVersion() throws SQLException;
 377: 
 378:   /**
 379:    * This method returns the name of the JDBC driver.
 380:    *
 381:    * @return The name of the JDBC driver.
 382:    * @exception SQLException If an error occurs.
 383:    */
 384:   String getDriverName() throws SQLException;
 385: 
 386:   /**
 387:    * This method returns the version of the JDBC driver.
 388:    *
 389:    * @return The version of the JDBC driver.
 390:    * @exception SQLException If an error occurs.
 391:    */
 392:   String getDriverVersion() throws SQLException;
 393: 
 394:   /**
 395:    * This method returns the major version number of the JDBC driver.
 396:    *
 397:    * @return The major version number of the JDBC driver.
 398:    */
 399:   int getDriverMajorVersion();
 400: 
 401:   /**
 402:    * This method returns the minor version number of the JDBC driver.
 403:    *
 404:    * @return The minor version number of the JDBC driver.
 405:    */
 406:   int getDriverMinorVersion();
 407: 
 408:   /**
 409:    * This method tests whether or not the database uses local files to
 410:    * store tables.
 411:    *
 412:    * @return <code>true</code> if the database uses local files, 
 413:    * <code>false</code> otherwise.
 414:    *
 415:    * @exception SQLException If an error occurs.
 416:    */
 417:   boolean usesLocalFiles() throws SQLException;
 418: 
 419:   /**
 420:    * This method tests whether or not the database uses a separate file for
 421:    * each table.
 422:    *
 423:    * @return <code>true</code> if the database uses a separate file for each
 424:    * table <code>false</code> otherwise.
 425:    *
 426:    * @exception SQLException If an error occurs.
 427:    */
 428:   boolean usesLocalFilePerTable() throws SQLException;
 429: 
 430:   /**
 431:    * This method tests whether or not the database supports identifiers
 432:    * with mixed case.
 433:    *
 434:    * @return <code>true</code> if the database supports mixed case identifiers,
 435:    * <code>false</code> otherwise.
 436:    *
 437:    * @exception SQLException If an error occurs.
 438:    */
 439:   boolean supportsMixedCaseIdentifiers() throws SQLException;
 440: 
 441:   /**
 442:    * This method tests whether or not the database treats mixed case
 443:    * identifiers as all upper case.
 444:    *
 445:    * @return <code>true</code> if the database treats all identifiers as
 446:    *         upper case, <code>false</code> otherwise.
 447:    * @exception SQLException If an error occurs.
 448:    */
 449:   boolean storesUpperCaseIdentifiers() throws SQLException;
 450: 
 451:   /**
 452:    * This method tests whether or not the database treats mixed case
 453:    * identifiers as all lower case.
 454:    *
 455:    * @return <code>true</code> if the database treats all identifiers as
 456:    *         lower case, <code>false</code> otherwise.
 457:    * @exception SQLException If an error occurs.
 458:    */
 459:   boolean storesLowerCaseIdentifiers() throws SQLException;
 460: 
 461:   /**
 462:    * This method tests whether or not the database stores mixed case 
 463:    * identifers even if it treats them as case insensitive.
 464:    *
 465:    * @return <code>true</code> if the database stores mixed case identifiers,
 466:    *         <code>false</code> otherwise.
 467:    * @exception SQLException If an error occurs.
 468:    */
 469:   boolean storesMixedCaseIdentifiers() throws SQLException;
 470: 
 471:   /**
 472:    * This method tests whether or not the database supports quoted identifiers
 473:    * with mixed case.
 474:    *
 475:    * @return <code>true</code> if the database supports mixed case quoted
 476:    *         identifiers, <code>false</code> otherwise.
 477:    * @exception SQLException If an error occurs.
 478:    */
 479:   boolean supportsMixedCaseQuotedIdentifiers() throws SQLException;
 480: 
 481:   /**
 482:    * This method tests whether or not the database treats mixed case
 483:    * quoted identifiers as all upper case.
 484:    *
 485:    * @return <code>true</code> if the database treats all quoted identifiers 
 486:    *         as upper case, <code>false</code> otherwise.
 487:    * @exception SQLException If an error occurs.
 488:    */
 489:   boolean storesUpperCaseQuotedIdentifiers() throws SQLException;
 490: 
 491:   /**
 492:    * This method tests whether or not the database treats mixed case
 493:    * quoted identifiers as all lower case.
 494:    *
 495:    * @return <code>true</code> if the database treats all quoted identifiers 
 496:    *         as lower case, <code>false</code> otherwise.
 497:    * @exception SQLException If an error occurs.
 498:    */
 499:   boolean storesLowerCaseQuotedIdentifiers() throws SQLException;
 500: 
 501:   /**
 502:    * This method tests whether or not the database stores mixed case 
 503:    * quoted identifers even if it treats them as case insensitive.
 504:    *
 505:    * @return <code>true</code> if the database stores mixed case quoted 
 506:    *         identifiers, <code>false</code> otherwise.
 507:    * @exception SQLException If an error occurs.
 508:    */
 509:   boolean storesMixedCaseQuotedIdentifiers() throws SQLException;
 510: 
 511:   /**
 512:    * This metohd returns the quote string for SQL identifiers.
 513:    *
 514:    * @return The quote string for SQL identifers, or a space if quoting
 515:    *         is not supported.
 516:    * @exception SQLException If an error occurs.
 517:    */
 518:   String getIdentifierQuoteString() throws SQLException;
 519: 
 520:   /**
 521:    * This method returns a comma separated list of all the SQL keywords in
 522:    * the database that are not in SQL92.
 523:    *
 524:    * @return The list of SQL keywords not in SQL92.
 525:    * @exception SQLException If an error occurs.
 526:    */
 527:   String getSQLKeywords() throws SQLException;
 528: 
 529:   /**
 530:    * This method returns a comma separated list of math functions.
 531:    *
 532:    * @return The list of math functions.
 533:    * @exception SQLException If an error occurs.
 534:    */
 535:   String getNumericFunctions() throws SQLException;
 536: 
 537:   /**
 538:    * This method returns a comma separated list of string functions.
 539:    *
 540:    * @return The list of string functions.
 541:    * @exception SQLException If an error occurs.
 542:    */
 543:   String getStringFunctions() throws SQLException;
 544: 
 545:   /**
 546:    * This method returns a comma separated list of of system functions.
 547:    *
 548:    * @return A comma separated list of system functions.
 549:    * @exception SQLException If an error occurs.
 550:    */
 551:   String getSystemFunctions() throws SQLException;
 552: 
 553:   /**
 554:    * This method returns comma separated list of time/date functions.
 555:    * 
 556:    * @return The list of time/date functions.
 557:    * @exception SQLException If an error occurs.
 558:    */
 559:   String getTimeDateFunctions() throws SQLException;
 560: 
 561:   /**
 562:    * This method returns the string used to escape wildcards in search strings.
 563:    *
 564:    * @return The string used to escape wildcards in search strings.
 565:    * @exception SQLException If an error occurs.
 566:    */
 567:   String getSearchStringEscape() throws SQLException;
 568: 
 569:   /**
 570:    * This methods returns non-standard characters that can appear in 
 571:    * unquoted identifiers.
 572:    *
 573:    * @return Non-standard characters that can appear in unquoted identifiers.
 574:    * @exception SQLException If an error occurs.
 575:    */
 576:   String getExtraNameCharacters() throws SQLException;
 577: 
 578:   /**
 579:    * This method tests whether or not the database supports
 580:    * "ALTER TABLE ADD COLUMN"
 581:    *
 582:    * @return <code>true</code> if column add supported, <code>false</code>
 583:    *         otherwise.
 584:    * @exception SQLException If an error occurs.
 585:    */
 586:   boolean supportsAlterTableWithAddColumn() throws SQLException;
 587: 
 588:   /**
 589:    * This method tests whether or not the database supports
 590:    * "ALTER TABLE DROP COLUMN"
 591:    *
 592:    * @return <code>true</code> if column drop supported, <code>false</code>
 593:    *         otherwise.
 594:    * @exception SQLException If an error occurs.
 595:    */
 596:   boolean supportsAlterTableWithDropColumn() throws SQLException;
 597: 
 598:   /**
 599:    * This method tests whether or not column aliasing is supported.
 600:    *
 601:    * @return <code>true</code> if column aliasing is supported,
 602:    *         <code>false</code> otherwise.
 603:    * @exception SQLException If an error occurs.
 604:    */
 605:   boolean supportsColumnAliasing() throws SQLException;
 606: 
 607:   /**
 608:    * This method tests whether the concatenation of a NULL and non-NULL
 609:    * value results in a NULL.  This will always be true in fully JDBC compliant
 610:    * drivers.
 611:    *
 612:    * @return <code>true</code> if concatenating NULL and a non-NULL value
 613:    *         returns a NULL, <code>false</code> otherwise.
 614:    * @exception SQLException If an error occurs.
 615:    */
 616:   boolean nullPlusNonNullIsNull() throws SQLException;
 617: 
 618:   /**
 619:    * Tests whether or not CONVERT is supported.
 620:    *
 621:    * @return <code>true</code> if CONVERT is supported, <code>false</code>
 622:    *         otherwise.
 623:    * @exception SQLException If an error occurs.
 624:    */
 625:   boolean supportsConvert() throws SQLException;
 626: 
 627:   /**
 628:    * This method tests whether or not CONVERT can be performed between the
 629:    * specified types.  The types are contants from <code>Types</code>.
 630:    *
 631:    * @param fromType The SQL type to convert from.
 632:    * @param toType The SQL type to convert to.
 633:    * @return <code>true</code> if the conversion can be performed,
 634:    *         <code>false</code> otherwise.
 635:    * @see Types
 636:    */
 637:   boolean supportsConvert(int fromType, int toType) throws
 638:       SQLException;
 639: 
 640:   /**
 641:    * This method tests whether or not table correlation names are 
 642:    * supported.  This will be always be <code>true</code> in a fully JDBC
 643:    * compliant driver.
 644:    *
 645:    * @return <code>true</code> if table correlation names are supported,
 646:    *         <code>false</code> otherwise.
 647:    * @exception SQLException If an error occurs.
 648:    */
 649:   boolean supportsTableCorrelationNames() throws SQLException;
 650: 
 651:   /**
 652:    * This method tests whether correlation names must be different from the
 653:    * name of the table.
 654:    *
 655:    * @return <code>true</code> if the correlation name must be different from
 656:    *         the table name, <code>false</code> otherwise.
 657:    * @exception SQLException If an error occurs.
 658:    */
 659:   boolean supportsDifferentTableCorrelationNames() throws SQLException;
 660: 
 661:   /**
 662:    * This method tests whether or not expressions are allowed in an
 663:    * ORDER BY lists.
 664:    *
 665:    * @return <code>true</code> if expressions are allowed in ORDER BY
 666:    *         lists, <code>false</code> otherwise.
 667:    * @exception SQLException If an error occurs.
 668:    */
 669:   boolean supportsExpressionsInOrderBy() throws SQLException;
 670: 
 671:   /**
 672:    * This method tests whether or ORDER BY on a non-selected column is
 673:    * allowed.
 674:    *
 675:    * @return <code>true</code> if a non-selected column can be used in an
 676:    *         ORDER BY, <code>false</code> otherwise.
 677:    * @exception SQLException If an error occurs.
 678:    */
 679:   boolean supportsOrderByUnrelated() throws SQLException;
 680: 
 681:   /**
 682:    * This method tests whether or not GROUP BY is supported.
 683:    *
 684:    * @return <code>true</code> if GROUP BY is supported, <code>false</code>
 685:    *         otherwise.
 686:    * @exception SQLException If an error occurs.
 687:    */
 688:   boolean supportsGroupBy() throws SQLException;
 689: 
 690:   /**
 691:    * This method tests whether GROUP BY on a non-selected column is
 692:    * allowed.
 693:    *
 694:    * @return <code>true</code> if a non-selected column can be used in a
 695:    *         GROUP BY, <code>false</code> otherwise.
 696:    * @exception SQLException If an error occurs.
 697:    */
 698:   boolean supportsGroupByUnrelated() throws SQLException;
 699: 
 700:   /**
 701:    * This method tests whether or not a GROUP BY can add columns not in the
 702:    * select if it includes all the columns in the select.
 703:    *
 704:    * @return <code>true</code> if GROUP BY an add columns provided it includes
 705:    *         all columns in the select, <code>false</code> otherwise.
 706:    * @exception SQLException If an error occurs.
 707:    */
 708:   boolean supportsGroupByBeyondSelect() throws SQLException;
 709: 
 710:   /**
 711:    * This method tests whether or not the escape character is supported in
 712:    * LIKE expressions.  A fully JDBC compliant driver will always return
 713:    * <code>true</code>.
 714:    *
 715:    * @return <code>true</code> if escapes are supported in LIKE expressions,
 716:    *         <code>false</code> otherwise.
 717:    * @exception SQLException If an error occurs.
 718:    */
 719:   boolean supportsLikeEscapeClause() throws SQLException;
 720: 
 721:   /**
 722:    * This method tests whether multiple result sets for a single statement are
 723:    * supported.
 724:    *
 725:    * @return <code>true</code> if multiple result sets are supported for a 
 726:    *         single statement, <code>false</code> otherwise.
 727:    * @exception SQLException If an error occurs.
 728:    */
 729:   boolean supportsMultipleResultSets() throws SQLException;
 730: 
 731:   /**
 732:    * This method test whether or not multiple transactions may be open
 733:    * at once, as long as they are on different connections.
 734:    *
 735:    * @return <code>true</code> if multiple transactions on different
 736:    *         connections are supported, <code>false</code> otherwise.
 737:    * @exception SQLException If an error occurs.
 738:    */
 739:   boolean supportsMultipleTransactions() throws SQLException;
 740: 
 741:   /**
 742:    * This method tests whether or not columns can be defined as NOT NULL.  A
 743:    * fully JDBC compliant driver always returns <code>true</code>.
 744:    *
 745:    * @return <code>true</code> if NOT NULL columns are supported,
 746:    *         <code>false</code> otherwise.
 747:    * @exception SQLException If an error occurs.
 748:    */
 749:   boolean supportsNonNullableColumns() throws SQLException;
 750: 
 751:   /**
 752:    * This method tests whether or not the minimum grammer for ODBC is supported.
 753:    * A fully JDBC compliant driver will always return <code>true</code>.
 754:    *
 755:    * @return <code>true</code> if the ODBC minimum grammar is supported,
 756:    *         <code>false</code> otherwise.
 757:    * @exception SQLException If an error occurs.
 758:    */
 759:   boolean supportsMinimumSQLGrammar() throws SQLException;
 760: 
 761:   /**
 762:    * This method tests whether or not the core grammer for ODBC is supported.
 763:    *
 764:    * @return <code>true</code> if the ODBC core grammar is supported,
 765:    *         <code>false</code> otherwise.
 766:    * @exception SQLException If an error occurs.
 767:    */
 768:   boolean supportsCoreSQLGrammar() throws SQLException;
 769: 
 770:   /**
 771:    * This method tests whether or not the extended grammer for ODBC is supported.
 772:    *
 773:    * @return <code>true</code> if the ODBC extended grammar is supported,
 774:    *         <code>false</code> otherwise.
 775:    * @exception SQLException If an error occurs.
 776:    */
 777:   boolean supportsExtendedSQLGrammar() throws SQLException;
 778: 
 779:   /**
 780:    * This method tests whether or not the ANSI92 entry level SQL
 781:    * grammar is supported.  A fully JDBC compliant drivers must return
 782:    * <code>true</code>.
 783:    *
 784:    * @return <code>true</code> if the ANSI92 entry level SQL grammar is
 785:    *         supported, <code>false</code> otherwise.
 786:    * @exception SQLException If an error occurs.
 787:    */
 788:   boolean supportsANSI92EntryLevelSQL() throws SQLException;
 789: 
 790:   /**
 791:    * This method tests whether or not the ANSI92 intermediate SQL
 792:    * grammar is supported.  
 793:    *
 794:    * @return <code>true</code> if the ANSI92 intermediate SQL grammar is
 795:    *         supported, <code>false</code> otherwise.
 796:    * @exception SQLException If an error occurs.
 797:    */
 798:   boolean supportsANSI92IntermediateSQL() throws SQLException;
 799: 
 800:   /**
 801:    * This method tests whether or not the ANSI92 full SQL
 802:    * grammar is supported.  
 803:    *
 804:    * @return <code>true</code> if the ANSI92 full SQL grammar is
 805:    *         supported, <code>false</code> otherwise.
 806:    * @exception SQLException If an error occurs.
 807:    */
 808:   boolean supportsANSI92FullSQL() throws SQLException;
 809: 
 810:   /**
 811:    * This method tests whether or not the SQL integrity enhancement
 812:    * facility is supported.
 813:    *
 814:    * @return <code>true</code> if the integrity enhancement facility is
 815:    *         supported, <code>false</code> otherwise.
 816:    * @exception SQLException If an error occurs.
 817:    */
 818:   boolean supportsIntegrityEnhancementFacility() throws SQLException;
 819: 
 820:   /**
 821:    * This method tests whether or not the database supports outer joins.
 822:    *
 823:    * @return <code>true</code> if outer joins are supported, <code>false</code>
 824:    *         otherwise.
 825:    * @exception SQLException If an error occurs.
 826:    */
 827:   boolean supportsOuterJoins() throws SQLException;
 828: 
 829:   /**
 830:    * This method tests whether or not the database supports full outer joins.
 831:    *
 832:    * @return <code>true</code> if full outer joins are supported, 
 833:    *         <code>false</code> otherwise.
 834:    * @exception SQLException If an error occurs.
 835:    */
 836:   boolean supportsFullOuterJoins() throws SQLException;
 837: 
 838:   /**
 839:    * This method tests whether or not the database supports limited outer joins.
 840:    *
 841:    * @return <code>true</code> if limited outer joins are supported, 
 842:    *         <code>false</code> otherwise.
 843:    * @exception SQLException If an error occurs.
 844:    */
 845:   boolean supportsLimitedOuterJoins() throws SQLException;
 846: 
 847:   /**
 848:    * This method returns the vendor's term for "schema".
 849:    *
 850:    * @return The vendor's term for schema.
 851:    * @exception SQLException if an error occurs.
 852:    */
 853:   String getSchemaTerm() throws SQLException;
 854: 
 855:   /**
 856:    * This method returns the vendor's term for "procedure".
 857:    *
 858:    * @return The vendor's term for procedure.
 859:    * @exception SQLException if an error occurs.
 860:    */
 861:   String getProcedureTerm() throws SQLException;
 862: 
 863:   /**
 864:    * This method returns the vendor's term for "catalog".
 865:    *
 866:    * @return The vendor's term for catalog.
 867:    * @exception SQLException if an error occurs.
 868:    */
 869:   String getCatalogTerm() throws SQLException;
 870: 
 871:   /**
 872:    * This method tests whether a catalog name appears at the beginning of
 873:    * a fully qualified table name.
 874:    *
 875:    * @return <code>true</code> if the catalog name appears at the beginning,
 876:    *         <code>false</code> if it appears at the end.
 877:    * @exception SQLException If an error occurs.
 878:    */
 879:   boolean isCatalogAtStart() throws SQLException;
 880: 
 881:   /**
 882:    * This method returns the separator between the catalog name and the
 883:    * table name.
 884:    *
 885:    * @return The separator between the catalog name and the table name.
 886:    * @exception SQLException If an error occurs.
 887:    */
 888:   String getCatalogSeparator() throws SQLException;
 889: 
 890:   /**
 891:    * This method tests whether a catalog name can appear in a data
 892:    * manipulation statement.
 893:    *
 894:    * @return <code>true</code> if a catalog name can appear in a data
 895:    *         manipulation statement, <code>false</code> otherwise.
 896:    * @exception SQLException If an error occurs.
 897:    */
 898:   boolean supportsSchemasInDataManipulation() throws SQLException;
 899: 
 900:   /**
 901:    * This method tests whether a catalog name can appear in a procedure
 902:    * call
 903:    *
 904:    * @return <code>true</code> if a catalog name can appear in a procedure
 905:    *         call, <code>false</code> otherwise.
 906:    * @exception SQLException If an error occurs.
 907:    */
 908:   boolean supportsSchemasInProcedureCalls() throws SQLException;
 909: 
 910:   /**
 911:    * This method tests whether a catalog name can appear in a table definition.
 912:    *
 913:    * @return <code>true</code> if a catalog name can appear in a table
 914:    *         definition, <code>false</code> otherwise.
 915:    * @exception SQLException If an error occurs.
 916:    */
 917:   boolean supportsSchemasInTableDefinitions() throws SQLException;
 918: 
 919:   /**
 920:    * This method tests whether a catalog name can appear in an index definition.
 921:    *
 922:    * @return <code>true</code> if a catalog name can appear in an index
 923:    *         definition, <code>false</code> otherwise.
 924:    * @exception SQLException If an error occurs.
 925:    */
 926:   boolean supportsSchemasInIndexDefinitions() throws SQLException;
 927: 
 928:   /**
 929:    * This method tests whether a catalog name can appear in privilege definitions.
 930:    *
 931:    * @return <code>true</code> if a catalog name can appear in privilege
 932:    *         definition, <code>false</code> otherwise.
 933:    * @exception SQLException If an error occurs.
 934:    */
 935:   boolean supportsSchemasInPrivilegeDefinitions() throws SQLException;
 936: 
 937:   /**
 938:    * This method tests whether a catalog name can appear in a data
 939:    * manipulation statement.
 940:    *
 941:    * @return <code>true</code> if a catalog name can appear in a data
 942:    *         manipulation statement, <code>false</code> otherwise.
 943:    * @exception SQLException If an error occurs.
 944:    */
 945:   boolean supportsCatalogsInDataManipulation() throws SQLException;
 946: 
 947:   /**
 948:    * This method tests whether a catalog name can appear in a procedure
 949:    * call
 950:    *
 951:    * @return <code>true</code> if a catalog name can appear in a procedure
 952:    *         call, <code>false</code> otherwise.
 953:    * @exception SQLException If an error occurs.
 954:    */
 955:   boolean supportsCatalogsInProcedureCalls() throws SQLException;
 956: 
 957:   /**
 958:    * This method tests whether a catalog name can appear in a table definition.
 959:    *
 960:    * @return <code>true</code> if a catalog name can appear in a table
 961:    *         definition, <code>false</code> otherwise.
 962:    * @exception SQLException If an error occurs.
 963:    */
 964:   boolean supportsCatalogsInTableDefinitions() throws SQLException;
 965: 
 966:   /**
 967:    * This method tests whether a catalog name can appear in an index definition.
 968:    *
 969:    * @return <code>true</code> if a catalog name can appear in an index
 970:    *         definition, <code>false</code> otherwise.
 971:    * @exception SQLException If an error occurs.
 972:    */
 973:   boolean supportsCatalogsInIndexDefinitions() throws SQLException;
 974: 
 975:   /**
 976:    * This method tests whether a catalog name can appear in privilege definitions.
 977:    *
 978:    * @return <code>true</code> if a catalog name can appear in privilege
 979:    *         definition, <code>false</code> otherwise.
 980:    * @exception SQLException If an error occurs.
 981:    */
 982:   boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException;
 983: 
 984:   /**
 985:    * This method tests whether or not that database supports positioned
 986:    * deletes.
 987:    *
 988:    * @return <code>true</code> if positioned deletes are supported,
 989:    *         <code>false</code> otherwise.
 990:    * @exception SQLException If an error occurs.
 991:    */
 992:   boolean supportsPositionedDelete() throws SQLException;
 993: 
 994:   /**
 995:    * This method tests whether or not that database supports positioned
 996:    * updates.
 997:    *
 998:    * @return <code>true</code> if positioned updates are supported,
 999:    *         <code>false</code> otherwise.
1000:    * @exception SQLException If an error occurs.
1001:    */
1002:   boolean supportsPositionedUpdate() throws SQLException;
1003: 
1004:   /**
1005:    * This method tests whether or not SELECT FOR UPDATE is supported by the
1006:    * database.
1007:    *
1008:    * @return <code>true</code> if SELECT FOR UPDATE is supported 
1009:    *         <code>false</code> otherwise.
1010:    * @exception SQLException If an error occurs.
1011:    */
1012:   boolean supportsSelectForUpdate() throws SQLException;
1013: 
1014:   /**
1015:    * This method tests whether or not stored procedures are supported on
1016:    * this database.
1017:    *
1018:    * @return <code>true</code> if stored procedures are supported,
1019:    *         <code>false</code> otherwise.
1020:    * @exception SQLException If an error occurs.
1021:    */
1022:   boolean supportsStoredProcedures() throws SQLException;
1023: 
1024:   /**
1025:    * This method tests whether or not subqueries are allowed in comparisons.
1026:    * A fully JDBC compliant driver will always return <code>true</code>.
1027:    *
1028:    * @return <code>true</code> if subqueries are allowed in comparisons,
1029:    *         <code>false</code> otherwise.
1030:    * @exception SQLException If an error occurs.
1031:    */
1032:   boolean supportsSubqueriesInComparisons() throws SQLException;
1033: 
1034:   /**
1035:    * This method tests whether or not subqueries are allowed in exists
1036:    * expressions.  A fully JDBC compliant driver will always return
1037:    * <code>true</code>.
1038:    *
1039:    * @return <code>true</code> if subqueries are allowed in exists 
1040:    *         expressions, <code>false</code> otherwise.
1041:    * @exception SQLException If an error occurs.
1042:    */
1043:   boolean supportsSubqueriesInExists() throws SQLException;
1044: 
1045:   /**
1046:    * This method tests whether subqueries are allowed in IN statements.
1047:    * A fully JDBC compliant driver will always return <code>true</code>.
1048:    *
1049:    * @return <code>true</code> if the driver supports subqueries in IN
1050:    *         statements, <code>false</code> otherwise.
1051:    * @exception SQLException If an error occurs.
1052:    */
1053:   boolean supportsSubqueriesInIns() throws SQLException;
1054: 
1055:   /**
1056:    * This method tests whether or not subqueries are allowed in quantified
1057:    * expressions.  A fully JDBC compliant driver will always return
1058:    * <code>true</code>.
1059:    *
1060:    * @return <code>true</code> if subqueries are allowed in quantified 
1061:    *         expressions, <code>false</code> otherwise.
1062:    * @exception SQLException If an error occurs.
1063:    */
1064:   boolean supportsSubqueriesInQuantifieds() throws SQLException;
1065: 
1066:   /**
1067:    * This method test whether or not correlated subqueries are allowed. A
1068:    * fully JDBC compliant driver will always return <code>true</code>.
1069:    *
1070:    * @return <code>true</code> if correlated subqueries are allowed,
1071:    *         <code>false</code> otherwise.
1072:    * @exception SQLException If an error occurs.
1073:    */
1074:   boolean supportsCorrelatedSubqueries() throws SQLException;
1075: 
1076:   /**
1077:    * This method tests whether or not the UNION statement is supported.
1078:    *
1079:    * @return <code>true</code> if UNION is supported, <code>false</code>
1080:    *         otherwise.
1081:    * @exception SQLException If an error occurs.
1082:    */
1083:   boolean supportsUnion() throws SQLException;
1084: 
1085:   /**
1086:    * This method tests whether or not the UNION ALL statement is supported.
1087:    *
1088:    * @return <code>true</code> if UNION ALL is supported, <code>false</code>
1089:    *         otherwise.
1090:    * @exception SQLException If an error occurs.
1091:    */
1092:   boolean supportsUnionAll() throws SQLException;
1093: 
1094:   /**
1095:    * This method tests whether or not the database supports cursors
1096:    * remaining open across commits.
1097:    *
1098:    * @return <code>true</code> if cursors can remain open across commits,
1099:    *         <code>false</code> otherwise.
1100:    * @exception SQLException If an error occurs.
1101:    */
1102:   boolean supportsOpenCursorsAcrossCommit() throws SQLException;
1103: 
1104:   /**
1105:    * This method tests whether or not the database supports cursors
1106:    * remaining open across rollbacks.
1107:    *
1108:    * @return <code>true</code> if cursors can remain open across rollbacks,
1109:    *         <code>false</code> otherwise.
1110:    * @exception SQLException If an error occurs.
1111:    */
1112:   boolean supportsOpenCursorsAcrossRollback() throws SQLException;
1113: 
1114:   /**
1115:    * This method tests whether or not the database supports statements
1116:    * remaining open across commits.
1117:    *
1118:    * @return <code>true</code> if statements can remain open across commits,
1119:    *         <code>false</code> otherwise.
1120:    * @exception SQLException If an error occurs.
1121:    */
1122:   boolean supportsOpenStatementsAcrossCommit() throws SQLException;
1123: 
1124:   /**
1125:    * This method tests whether or not the database supports statements
1126:    * remaining open across rollbacks.
1127:    *
1128:    * @return <code>true</code> if statements can remain open across rollbacks,
1129:    *         <code>false</code> otherwise.
1130:    * @exception SQLException If an error occurs.
1131:    */
1132:   boolean supportsOpenStatementsAcrossRollback() throws SQLException;
1133: 
1134:   /**
1135:    * This method returns the number of hex characters allowed in an inline
1136:    * binary literal.
1137:    *
1138:    * @return The number of hex characters allowed in a binary literal, 0 meaning
1139:    *         either an unknown or unlimited number.
1140:    * @exception SQLException If an error occurs.
1141:    */
1142:   int getMaxBinaryLiteralLength() throws SQLException;
1143: 
1144:   /**
1145:    * This method returns the maximum length of a character literal.
1146:    * 
1147:    * @return The maximum length of a character literal.
1148:    * @exception SQLException If an error occurs.
1149:    */
1150:   int getMaxCharLiteralLength() throws SQLException;
1151: 
1152:   /**
1153:    * This method returns the maximum length of a column name.
1154:    *
1155:    * @return The maximum length of a column name.
1156:    * @exception SQLException If an error occurs.
1157:    */
1158:   int getMaxColumnNameLength() throws SQLException;
1159: 
1160:   /**
1161:    * This method returns the maximum number of columns in a GROUP BY statement.
1162:    *
1163:    * @return The maximum number of columns in a GROUP BY statement.
1164:    * @exception SQLException If an error occurs.
1165:    */
1166:   int getMaxColumnsInGroupBy() throws SQLException;
1167: 
1168:   /**
1169:    * This method returns the maximum number of columns in an index.
1170:    *
1171:    * @return The maximum number of columns in an index.
1172:    * @exception SQLException If an error occurs.
1173:    */
1174:   int getMaxColumnsInIndex() throws SQLException;
1175: 
1176:   /**
1177:    * This method returns the maximum number of columns in an ORDER BY statement.
1178:    *
1179:    * @return The maximum number of columns in an ORDER BY statement.
1180:    * @exception SQLException If an error occurs.
1181:    */
1182:   int getMaxColumnsInOrderBy() throws SQLException;
1183: 
1184:   /**
1185:    * This method returns the maximum number of columns in a SELECT statement.
1186:    *
1187:    * @return The maximum number of columns in a SELECT statement.
1188:    * @exception SQLException If an error occurs.
1189:    */
1190:   int getMaxColumnsInSelect() throws SQLException;
1191: 
1192:   /**
1193:    * This method returns the maximum number of columns in a table.
1194:    *
1195:    * @return The maximum number of columns in a table.
1196:    * @exception SQLException If an error occurs.
1197:    */
1198:   int getMaxColumnsInTable() throws SQLException;
1199: 
1200:   /**
1201:    * This method returns the maximum number of connections this client
1202:    * can have to the database.
1203:    *
1204:    * @return The maximum number of database connections.
1205:    * @SQLException If an error occurs.
1206:    */
1207:   int getMaxConnections() throws SQLException;
1208: 
1209:   /**
1210:    * This method returns the maximum length of a cursor name.
1211:    *
1212:    * @return The maximum length of a cursor name.
1213:    * @exception SQLException If an error occurs.
1214:    */
1215:   int getMaxCursorNameLength() throws SQLException;
1216: 
1217:   /**
1218:    * This method returns the maximum length of an index.
1219:    *
1220:    * @return The maximum length of an index.
1221:    * @exception SQLException If an error occurs.
1222:    */
1223:   int getMaxIndexLength() throws SQLException;
1224: 
1225:   /**
1226:    * This method returns the maximum length of a schema name.
1227:    *
1228:    * @return The maximum length of a schema name.
1229:    * @exception SQLException If an error occurs.
1230:    */
1231:   int getMaxSchemaNameLength() throws SQLException;
1232: 
1233:   /**
1234:    * This method returns the maximum length of a procedure name.
1235:    *
1236:    * @return The maximum length of a procedure name.
1237:    * @exception SQLException If an error occurs.
1238:    */
1239:   int getMaxProcedureNameLength() throws SQLException;
1240: 
1241:   /**
1242:    * This method returns the maximum length of a catalog name.
1243:    *
1244:    * @return The maximum length of a catalog name.
1245:    * @exception SQLException If an error occurs.
1246:    */
1247:   int getMaxCatalogNameLength() throws SQLException;
1248: 
1249:   /**
1250:    * This method returns the maximum size of a row in bytes.
1251:    *
1252:    * @return The maximum size of a row.
1253:    * @exception SQLException If an error occurs.
1254:    */
1255:   int getMaxRowSize() throws SQLException;
1256: 
1257:   /**
1258:    * This method tests whether or not the maximum row size includes BLOB's
1259:    *
1260:    * @return <code>true</code> if the maximum row size includes BLOB's,
1261:    *         <code>false</code> otherwise.
1262:    * @exception SQLException If an error occurs.
1263:    */
1264:   boolean doesMaxRowSizeIncludeBlobs() throws SQLException;
1265: 
1266:   /**
1267:    * This method includes the maximum length of a SQL statement.
1268:    *
1269:    * @return The maximum length of a SQL statement.
1270:    * @exception SQLException If an error occurs.
1271:    */
1272:   int getMaxStatementLength() throws SQLException;
1273: 
1274:   /**
1275:    * This method returns the maximum number of statements that can be
1276:    * active at any time.
1277:    *
1278:    * @return The maximum number of statements that can be active at any time.
1279:    * @exception SQLException If an error occurs.
1280:    */
1281:   int getMaxStatements() throws SQLException;
1282: 
1283:   /**
1284:    * This method returns the maximum length of a table name.
1285:    *
1286:    * @return The maximum length of a table name.
1287:    * @exception SQLException If an error occurs.
1288:    */
1289:   int getMaxTableNameLength() throws SQLException;
1290: 
1291:   /**
1292:    * This method returns the maximum number of tables that may be referenced
1293:    * in a SELECT statement.
1294:    *
1295:    * @return The maximum number of tables allowed in a SELECT statement.
1296:    * @exception SQLException If an error occurs.
1297:    */
1298:   int getMaxTablesInSelect() throws SQLException;
1299: 
1300:   /**
1301:    * This method returns the maximum length of a user name.
1302:    *
1303:    * @return The maximum length of a user name.
1304:    * @exception SQLException If an error occurs.
1305:    */
1306:   int getMaxUserNameLength() throws SQLException;
1307: 
1308:   /**
1309:    * This method returns the default transaction isolation level of the
1310:    * database.
1311:    *
1312:    * @return The default transaction isolation level of the database.
1313:    * @exception SQLException If an error occurs.
1314:    * @see Connection
1315:    */
1316:   int getDefaultTransactionIsolation() throws SQLException;
1317: 
1318:   /**
1319:    * This method tests whether or not the database supports transactions.
1320:    *
1321:    * @return <code>true</code> if the database supports transactions,
1322:    *         <code>false</code> otherwise.
1323:    * @exception SQLException If an error occurs.
1324:    */
1325:   boolean supportsTransactions() throws SQLException;
1326: 
1327:   /**
1328:    * This method tests whether or not the database supports the specified
1329:    * transaction isolation level.
1330:    *
1331:    * @param level The transaction isolation level.
1332:    *
1333:    * @return <code>true</code> if the specified transaction isolation level
1334:    *         is supported, <code>false</code> otherwise.
1335:    * @exception SQLException If an error occurs.
1336:    */
1337:   boolean supportsTransactionIsolationLevel(int level) throws
1338:       SQLException;
1339: 
1340:   /**
1341:    * This method tests whether or not DDL and DML statements allowed within 
1342:    * the same transaction.
1343:    *
1344:    * @return <code>true</code> if DDL and DML statements are allowed in the
1345:    *         same transaction, <code>false</code> otherwise.
1346:    * @exception SQLException If an error occurs.
1347:    */
1348:   boolean supportsDataDefinitionAndDataManipulationTransactions()
1349:       throws SQLException;
1350: 
1351:   /**
1352:    * This method tests whether or not only DML statement are allowed
1353:    * inside a transaction.
1354:    *
1355:    * @return <code>true</code> if only DML statements are allowed in
1356:    *         transactions, <code>false</code> otherwise.
1357:    * @exception SQLException If an error occurs.
1358:    */
1359:   boolean supportsDataManipulationTransactionsOnly() throws
1360:       SQLException;
1361: 
1362:   /**
1363:    * This method tests whether or not a DDL statement will cause the
1364:    * current transaction to be automatically committed.
1365:    *
1366:    * @return <code>true</code> if DDL causes an immediate transaction commit,
1367:    *         <code>false</code> otherwise.
1368:    * @exception SQLException If an error occurs.
1369:    */
1370:   boolean dataDefinitionCausesTransactionCommit() throws SQLException;
1371: 
1372:   /**
1373:    * This method tests whether or not DDL statements are ignored in
1374:    * transactions.
1375:    *
1376:    * @return <code>true</code> if DDL statements are ignored in transactions,
1377:    *         <code>false</code> otherwise.
1378:    * @exception SQLException If an error occurs.
1379:    */
1380:   boolean dataDefinitionIgnoredInTransactions() throws SQLException;
1381: 
1382:   /**
1383:    * This method returns a list of all the stored procedures matching the
1384:    * specified pattern in the given schema and catalog.  This is returned
1385:    * a <code>ResultSet</code> with the following columns:
1386:    * <p>
1387:    * <ol>
1388:    * <li>PROCEDURE_CAT - The catalog the procedure is in, which may be 
1389:    * <code>null</code>.</li>
1390:    * <li>PROCEDURE_SCHEM - The schema the procedures is in, which may be
1391:    * <code>null</code>.</li>
1392:    * <li>PROCEDURE_NAME - The name of the procedure.</li>
1393:    * <li>Unused</li>
1394:    * <li>Unused</li>
1395:    * <li>Unused</li>
1396:    * <li>REMARKS - A description of the procedure</li>
1397:    * <li>PROCEDURE_TYPE - Indicates the return type of the procedure, which 
1398:    * is one of the contstants defined in this class 
1399:    * (<code>procedureResultUnknown</code>, <code>procedureNoResult</code>, or
1400:    * <code>procedureReturnsResult</code>).</li>
1401:    * </ol>
1402:    *
1403:    * @param catalog The name of the catalog to return stored procedured from,
1404:    *        or "" to return procedures from all catalogs.
1405:    * @param schemaPattern A schema pattern for the schemas to return stored
1406:    *        procedures from, or "" to return procedures from all schemas.
1407:    * @param procedurePattern The pattern of procedure names to return.
1408:    * @returns A <code>ResultSet</code> with all the requested procedures.
1409:    * @exception SQLException If an error occurs.
1410:    */
1411:   ResultSet getProcedures(String catalog, String schemaPattern, String
1412:       procedurePattern) throws SQLException;
1413: 
1414:   /**
1415:    * This method returns a list of the parameter and result columns for
1416:    * the requested stored procedures.  This is returned in the form of a
1417:    * <code>ResultSet</code> with the following columns:
1418:    * <p>
1419:    * <ol>
1420:    * <li>PROCEDURE_CAT - The catalog the procedure is in, which may be 
1421:    * <code>null</code>.</li>
1422:    * <li>PROCEDURE_SCHEM - The schema the procedures is in, which may be
1423:    * <code>null</code>.</li>
1424:    * <li>PROCEDURE_NAME - The name of the procedure.</li>
1425:    * <li>COLUMN_NAME - The name of the column</li>
1426:    * <li>COLUMN_TYPE - The type of the column, which will be one of the
1427:    * contants defined in this class (<code>procedureColumnUnknown</code>,
1428:    * <code>procedureColumnIn</code>, <code>procedureColumnInOut</code>,
1429:    * <code>procedureColumnOut</code>, <code>procedureColumnReturn</code>,
1430:    * or <code>procedureColumnResult</code>).</li>
1431:    * <li>DATA_TYPE - The SQL type of the column. This is one of the constants
1432:    * defined in <code>Types</code>.</li>
1433:    * <li>TYPE_NAME - The string name of the data type for this column.</li>
1434:    * <li>PRECISION - The precision of the column.</li>
1435:    * <li>LENGTH - The length of the column in bytes</li>
1436:    * <li>SCALE - The scale of the column.</li>
1437:    * <li>RADIX - The radix of the column.</li>
1438:    * <li>NULLABLE - Whether or not the column is NULLABLE.  This is one of
1439:    * the constants defined in this class (<code>procedureNoNulls</code>,
1440:    * <code>procedureNullable</code>, or <code>procedureNullableUnknown</code>)</li>
1441:    * <li>REMARKS - A description of the column.</li>
1442:    * </ol>
1443:    *
1444:    * @param catalog The name of the catalog to return stored procedured from,
1445:    *        or "" to return procedures from all catalogs.
1446:    * @param schemaPattern A schema pattern for the schemas to return stored
1447:    *        procedures from, or "" to return procedures from all schemas.
1448:    * @param procedurePattern The pattern of procedures names to return.
1449:    * @param columnPattern The pattern of column names to return.
1450:    * @returns A <code>ResultSet</code> with all the requested procedures.
1451:    * @exception SQLException If an error occurs.
1452:    */
1453:   ResultSet getProcedureColumns(String catalog, String schemaPattern,
1454:       String procedurePattern, String columnPattern) throws
1455:       SQLException;
1456: 
1457:   /**
1458:    * This method returns a list of the requested table as a   
1459:    * <code>ResultSet</code> with the following columns:
1460:    *
1461:    * <ol>
1462:    * <li>TABLE_CAT - The catalog the table is in, which may be <code>null</code>.</li>
1463:    * <li>TABLE_SCHEM - The schema the table is in, which may be <code>null</code>.</li>
1464:    * <li>TABLE_NAME - The name of the table.</li>
1465:    * <li>TABLE_TYPE - A string describing the table type.  This will be one
1466:    * of the values returned by the <code>getTableTypes()</code> method.</li>
1467:    * <li>REMARKS - Comments about the table.</li>
1468:    * </ol>
1469:    * 
1470:    * @param catalog The name of the catalog to return tables from,
1471:    *        or "" to return tables from all catalogs.
1472:    * @param schemaPattern A schema pattern for the schemas to return tables
1473:    *        from, or "" to return tables from all schemas.
1474:    * @param tablePattern The pattern of table names to return.
1475:    * @param types The list of table types to include; null returns all types.
1476:    * @returns A <code>ResultSet</code> with all the requested tables.
1477:    * @exception SQLException If an error occurs.
1478:    */
1479:   ResultSet getTables(String catalog, String schemaPattern, String
1480:       tablePattern, String[] types) throws SQLException;
1481: 
1482:   /**
1483:    * This method returns the list of database schemas as a 
1484:    * <code>ResultSet</code>, with one column - TABLE_SCHEM - that is the
1485:    * name of the schema.
1486:    *
1487:    * @return A <code>ResultSet</code> with all the requested schemas.
1488:    * @exception SQLException If an error occurs.
1489:    */
1490:   ResultSet getSchemas() throws SQLException;
1491: 
1492:   /**
1493:    * This method returns the list of database catalogs as a
1494:    * <code>ResultSet</code> with one column - TABLE_CAT - that is the
1495:    * name of the catalog.
1496:    *
1497:    * @return A <code>ResultSet</code> with all the requested catalogs.
1498:    * @exception SQLException If an error occurs.
1499:    */
1500:   ResultSet getCatalogs() throws SQLException;
1501: 
1502:   /**
1503:    * This method returns the list of database table types as a
1504:    * <code>ResultSet</code> with one column - TABLE_TYPE - that is the
1505:    * name of the table type.
1506:    *
1507:    * @return A <code>ResultSet</code> with all the requested table types.
1508:    * @exception SQLException If an error occurs.
1509:    */
1510:   ResultSet getTableTypes() throws SQLException;
1511: 
1512:   /**
1513:    * This method returns a list of the tables columns for
1514:    * the requested tables.  This is returned in the form of a
1515:    * <code>ResultSet</code> with the following columns:
1516:    * <p>
1517:    * <ol>
1518:    * <li>TABLE_CAT - The catalog the table is in, which may be 
1519:    * <code>null</code>.</li>
1520:    * <li>TABLE_SCHEM - The schema the tables is in, which may be
1521:    * <code>null</code>.</li>
1522:    * <li>TABLE_NAME - The name of the table.</li>
1523:    * <li>COLUMN_NAME - The name of the column</li>
1524:    * <li>DATA_TYPE - The SQL type of the column. This is one of the constants
1525:    * defined in <code>Types</code>.</li>
1526:    * <li>TYPE_NAME - The string name of the data type for this column.</li>
1527:    * <li>COLUMN_SIZE - The size of the column.</li>
1528:    * <li>Unused</li>
1529:    * <li>NUM_PREC_RADIX - The radix of the column.</li>
1530:    * <li>NULLABLE - Whether or not the column is NULLABLE.  This is one of
1531:    * the constants defined in this class (<code>tableNoNulls</code>,
1532:    * <code>tableNullable</code>, or <code>tableNullableUnknown</code>)</li>
1533:    * <li>REMARKS - A description of the column.</li>
1534:    * <li>COLUMN_DEF - The default value for the column, may be <code>null</code>.</li>
1535:    * <li>SQL_DATA_TYPE - Unused</li>
1536:    * <li>SQL_DATETIME_SUB - Unused</li>
1537:    * <li>CHAR_OCTET_LENGTH - For character columns, the maximum number of bytes
1538:    * in the column.</li>
1539:    * <li>ORDINAL_POSITION - The index of the column in the table.</li>
1540:    * <li>IS_NULLABLE - "NO" means no, "YES" means maybe, and an empty string
1541:    * means unknown.</li>
1542:    * </ol>
1543:    *
1544:    * @param catalog The name of the catalog to return table from,
1545:    * or "" to return tables from all catalogs.
1546:    * @param schemaPattern A schema pattern for the schemas to return 
1547:    * tables from, or "" to return tables from all schemas.
1548:    * @param tablePattern The pattern of table names to return.
1549:    * @param columnPattern The pattern of column names to return.
1550:    * @returns A <code>ResultSet</code> with all the requested tables.
1551:    * @exception SQLException If an error occurs.
1552:    */
1553:   ResultSet getColumns(String catalog, String schemaPattern, String
1554:       tablePattern, String columnPattern) throws SQLException;
1555: 
1556:   /**
1557:    * This method returns the access rights that have been granted to the
1558:    * requested columns.  This information is returned as a <code>ResultSet</code>
1559:    * with the following columns:
1560:    *
1561:    * <ol>
1562:    * <li>TABLE_CAT - The catalog the table is in, which may be 
1563:    * <code>null</code>.</li>
1564:    * <li>TABLE_SCHEM - The schema the tables is in, which may be
1565:    * <code>null</code>.</li>
1566:    * <li>TABLE_NAME - The name of the table.</li>
1567:    * <li>COLUMN_NAME - The name of the column.</li>
1568:    * <li>GRANTOR - The entity that granted the access.</li>
1569:    * <li>GRANTEE - The entity granted the access.</li>
1570:    * <li>PRIVILEGE - The name of the privilege granted.</li>
1571:    * <li>IS_GRANTABLE - "YES" if the grantee can grant the privilege to
1572:    * others, "NO" if not, and <code>null</code> if unknown.</li>
1573:    * </ol>
1574:    *
1575:    * @param catalog The catalog to retrieve information from, or the empty string
1576:    *        to return entities not associated with a catalog, or <code>null</code>
1577:    *        to return information from all catalogs.
1578:    * @param schema The schema to retrieve information from, or the empty string
1579:    *        to return entities not associated with a schema.
1580:    * @param tableName The table name to return information for.
1581:    * @param columnPattern A pattern of column names to return information for.
1582:    * @return A <code>ResultSet</code> with all the requested privileges.
1583:    * @exception SQLException If an error occurs.
1584:    */
1585:   ResultSet getColumnPrivileges(String catalog, String schema, String
1586:       tableName, String columnPattern) throws SQLException;
1587: 
1588:   /**
1589:    * This method returns the access rights that have been granted to the
1590:    * requested tables.  This information is returned as a <code>ResultSet</code>
1591:    * with the following columns:
1592:    *
1593:    * <ol>
1594:    * <li>TABLE_CAT - The catalog the table is in, which may be 
1595:    * <code>null</code>.</li>
1596:    * <li>TABLE_SCHEM - The schema the tables is in, which may be
1597:    * <code>null</code>.</li>
1598:    * <li>TABLE_NAME - The name of the table.</li>
1599:    * <li>GRANTOR - The entity that granted the access.</li>
1600:    * <li>GRANTEE - The entity granted the access.</li>
1601:    * <li>PRIVILEGE - The name of the privilege granted.</li>
1602:    * <li>IS_GRANTABLE - "YES" if the grantee can grant the privilege to
1603:    * others, "NO" if not, and <code>null</code> if unknown.</li>
1604:    * </ol>
1605:    *
1606:    * @param catalog The catalog to retrieve information from, or the empty string
1607:    *        to return entities not associated with a catalog, or <code>null</code>
1608:    *        to return information from all catalogs.
1609:    * @param schemaPattern The schema to retrieve information from, or the empty string
1610:    *        to return entities not associated with a schema.
1611:    * @param tablePattern The table name pattern of tables to return 
1612:    *        information for.
1613:    * @return A <code>ResultSet</code> with all the requested privileges.
1614:    * @exception SQLException If an error occurs.
1615:    */
1616:   ResultSet getTablePrivileges(String catalog, String schemaPattern,
1617:       String tablePattern) throws SQLException;
1618: 
1619:   /**
1620:    * This method returns the best set of columns for uniquely identifying
1621:    * a row.  It returns this information as a <code>ResultSet</code> with
1622:    * the following columns:
1623:    *
1624:    * <ol>
1625:    * <li>SCOPE - The scope of the results returned.  This is one of the 
1626:    * constants defined in this class (<code>bestRowTemporary</code>,
1627:    * <code>bestRowTransaction</code>, or <code>bestRowSession</code>).</li>
1628:    * <li>COLUMN_NAME - The name of the column.</li>
1629:    * <li>DATA_TYPE - The SQL type of the column. This is one of the constants
1630:    * defined in <code>Types</code>.</li>
1631:    * <li>TYPE_NAME - The string name of the data type for this column.</li>
1632:    * <li>COLUMN_SIZE - The precision of the columns</li>
1633:    * <li>BUFFER_LENGTH - Unused</li>
1634:    * <li>DECIMAL_DIGITS - The scale of the column.</li>
1635:    * <li>PSEUDO_COLUMN - Whether or not the best row identifier is a
1636:    * pseudo_column.  This is one of the constants defined in this class 
1637:    * (<code>bestRowUnknown</code>, <code>bestRowNotPseudo</code>, or
1638:    * <code>bestRowPseudo</code>).</li>
1639:    * </ol>
1640:    *
1641:    * @param catalog The catalog to retrieve information from, or the empty string
1642:    * to return entities not associated with a catalog, or <code>null</code>
1643:    * to return information from all catalogs.
1644:    * @param schema The schema to retrieve information from, or the empty string
1645:    * to return entities not associated with a schema.
1646:    * @param tableName The table name to return information for.
1647:    * @param scope One of the best row id scope constants from this class.
1648:    * @param nullable <code>true</code> to include columns that are nullable,
1649:    * <code>false</code> otherwise.
1650:    * @return A <code>ResultSet</code> with the best row identifier.
1651:    * @exception SQLException If an error occurs.
1652:    */
1653:   ResultSet getBestRowIdentifier(String catalog, String schema,
1654:     String tableName, int scope, boolean nullable) throws SQLException;
1655: 
1656:   /**
1657:    * This method returns the set of columns that are automatically updated
1658:    * when the row is update. It returns this information as a 
1659:    * <code>ResultSet</code> with the following columns:
1660:    *
1661:    * <ol>
1662:    * <li>SCOPE - Unused</li>
1663:    * <li>COLUMN_NAME - The name of the column.</li>
1664:    * <li>DATA_TYPE - The SQL type of the column. This is one of the constants
1665:    * defined in <code>Types</code>.</li>
1666:    * <li>TYPE_NAME - The string name of the data type for this column.</li>
1667:    * <li>COLUMN_SIZE - The precision of the columns</li>
1668:    * <li>BUFFER_LENGTH - Unused</li>
1669:    * <li>DECIMAL_DIGITS - The scale of the column.</li>
1670:    * <li>PSEUDO_COLUMN - Whether or not the best row identifier is a
1671:    * pseudo_column.  This is one of the constants defined in this class 
1672:    * (<code>versionRowUnknown</code>, <code>versionRowNotPseudo</code>, or
1673:    * <code>versionRowPseudo</code>).</li>
1674:    * </ol>
1675:    *
1676:    * @param catalog The catalog to retrieve information from, or the empty string
1677:    *        to return entities not associated with a catalog, or <code>null</code>
1678:    *        to return information from all catalogs.
1679:    * @param schema The schema to retrieve information from, or the empty string
1680:    *        to return entities not associated with a schema.
1681:    * @param tableName The table name to return information for
1682:    * @return A <code>ResultSet</code> with the version columns.
1683:    * @exception SQLException If an error occurs.
1684:    */
1685:   ResultSet getVersionColumns(String catalog, String schema,
1686:     String tableName) throws SQLException;
1687: 
1688:   /**
1689:    * This method returns a list of a table's primary key columns.  These
1690:    * are returned as a <code>ResultSet</code> with the following columns.
1691:    *
1692:    * <ol>
1693:    * <li>TABLE_CAT - The catalog of the table, which may be <code>null</code>.</li>
1694:    * <li>TABLE_SCHEM - The schema of the table, which may be <code>null</code>.</li>
1695:    * <li>TABLE_NAME - The name of the table.</li>
1696:    * <li>COLUMN_NAME - The name of the column.</li>
1697:    * <li>KEY_SEQ - The sequence number of the column within the primary key.</li>
1698:    * <li>PK_NAME - The name of the primary key, which may be <code>null</code>.</li>
1699:    * </ol>
1700:    *
1701:    * @param catalog The catalog to retrieve information from, or the empty string
1702:    *        to return entities not associated with a catalog, or <code>null</code>
1703:    *        to return information from all catalogs.
1704:    * @param schema The schema to retrieve information from, or the empty string
1705:    *        to return entities not associated with a schema.
1706:    * @param tableName The table name to return information for.
1707:    * @return A <code>ResultSet</code> with the primary key columns.
1708:    * @exception SQLException If an error occurs.
1709:    */
1710:   ResultSet getPrimaryKeys(String catalog, String schema, String tableName)
1711:       throws SQLException;
1712: 
1713:   /**
1714:    * This method returns a list of the table's foreign keys.  These are
1715:    * returned as a <code>ResultSet</code> with the following columns:
1716:    *
1717:    * <ol>
1718:    * <li>PKTABLE_CAT - The catalog of the table the key was imported from.</li>
1719:    * <li>PKTABLE_SCHEM - The schema of the table the key was imported from.</li>
1720:    * <li>PKTABLE_NAME - The name of the table the key was imported from.</li>
1721:    * <li>PKCOLUMN_NAME - The name of the column that was imported.</li>
1722:    * <li>FKTABLE_CAT - The foreign key catalog name.</li>
1723:    * <li>FKTABLE_SCHEM - The foreign key schema name.</li>
1724:    * <li>FKTABLE_NAME - The foreign key table name.</li>
1725:    * <li>FKCOLUMN_NAME - The foreign key column name.</li>
1726:    * <li>KEY_SEQ - The sequence number of the column within the foreign key.</li>
1727:    * <li>UPDATE_RULE - How the foreign key behaves when the primary key is
1728:    * updated.  This is one of the constants defined in this class 
1729:    * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1730:    * <code>importedKeySetNull</code>, <code>importedKeySetDefault</code>, or
1731:    * <code>importedKeyRestrict</code>).</li>
1732:    * <li>DELETE_RULE - How the foreign key behaves when the primary key is
1733:    * deleted.  This is one of the constants defined in this class 
1734:    * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1735:    * <code>importedKeySetNull</code>, or <code>importedKeySetDefault</code>)</li>
1736:    * <li>FK_NAME - The name of the foreign key.</li>
1737:    * <li>PK_NAME - The name of the primary key.</li>
1738:    * <li>DEFERRABILITY - The deferrability value.  This is one of the
1739:    * constants defined in this table (<code>importedKeyInitiallyDeferred</code>,
1740:    * <code>importedKeyInitiallyImmediate</code>, or
1741:    * <code>importedKeyNotDeferrable</code>).</li>
1742:    * </ol>
1743:    *
1744:    * @param catalog The catalog to retrieve information from, or the empty string
1745:    *        to return entities not associated with a catalog, or <code>null</code>
1746:    *        to return information from all catalogs.
1747:    * @param schema The schema to retrieve information from, or the empty string
1748:    *        to return entities not associated with a schema.
1749:    * @param tableName The table name to return information for.
1750:    * @return A <code>ResultSet</code> with the foreign key columns.
1751:    * @exception SQLException If an error occurs.
1752:    */
1753:   ResultSet getImportedKeys(String catalog, String schema,
1754:     String tableName) throws SQLException;
1755: 
1756:   /**
1757:    * This method returns a list of the table's which use this table's
1758:    * primary key as a foreign key.  The information is
1759:    * returned as a <code>ResultSet</code> with the following columns:
1760:    *
1761:    * <ol>
1762:    * <li>PKTABLE_CAT - The catalog of the table the key was imported from.</li>
1763:    * <li>PKTABLE_SCHEM - The schema of the table the key was imported from.</li>
1764:    * <li>PKTABLE_NAME - The name of the table the key was imported from.</li>
1765:    * <li>PKCOLUMN_NAME - The name of the column that was imported.</li>
1766:    * <li>FKTABLE_CAT - The foreign key catalog name.</li>
1767:    * <li>FKTABLE_SCHEM - The foreign key schema name.</li>
1768:    * <li>FKTABLE_NAME - The foreign key table name.</li>
1769:    * <li>FKCOLUMN_NAME - The foreign key column name.</li>
1770:    * <li>KEY_SEQ - The sequence number of the column within the foreign key.</li>
1771:    * <li>UPDATE_RULE - How the foreign key behaves when the primary key is
1772:    * updated.  This is one of the constants defined in this class 
1773:    * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1774:    * <code>importedKeySetNull</code>, <code>importedKeySetDefault</code>, or
1775:    * <code>importedKeyRestrict</code>).</li>
1776:    * <li>DELETE_RULE - How the foreign key behaves when the primary key is
1777:    * deleted.  This is one of the constants defined in this class 
1778:    * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1779:    * <code>importedKeySetNull</code>, or <code>importedKeySetDefault</code>)</li>
1780:    * <li>FK_NAME - The name of the foreign key.</li>
1781:    * <li>PK_NAME - The name of the primary key.</li>
1782:    * <li>DEFERRABILITY - The deferrability value.  This is one of the
1783:    * constants defined in this table (<code>importedKeyInitiallyDeferred</code>,
1784:    * <code>importedKeyInitiallyImmediate</code>, or
1785:    * <code>importedKeyNotDeferrable</code>).</li>
1786:    * </ol>
1787:    *
1788:    * @param catalog The catalog to retrieve information from, or the empty string
1789:    *        to return entities not associated with a catalog, or <code>null</code>
1790:    *        to return information from all catalogs.
1791:    * @param schema The schema to retrieve information from, or the empty string
1792:    *        to return entities not associated with a schema.
1793:    * @param tableName The table name to return information for.
1794:    * @return A <code>ResultSet</code> with the requested information
1795:    * @exception SQLException If an error occurs.
1796:    */
1797:   ResultSet getExportedKeys(String catalog, String schema,
1798:     String tableName) throws SQLException;
1799: 
1800:   /**
1801:    * This method returns a description of how one table imports another
1802:    * table's primary key as a foreign key.  The information is
1803:    * returned as a <code>ResultSet</code> with the following columns:
1804:    *
1805:    * <ol>
1806:    * <li>PKTABLE_CAT - The catalog of the table the key was imported from.</li>
1807:    * <li>PKTABLE_SCHEM - The schema of the table the key was imported from.</li>
1808:    * <li>PKTABLE_NAME - The name of the table the key was imported from.</li>
1809:    * <li>PKCOLUMN_NAME - The name of the column that was imported.</li>
1810:    * <li>FKTABLE_CAT - The foreign key catalog name.</li>
1811:    * <li>FKTABLE_SCHEM - The foreign key schema name.</li>
1812:    * <li>FKTABLE_NAME - The foreign key table name.</li>
1813:    * <li>FKCOLUMN_NAME - The foreign key column name.</li>
1814:    * <li>KEY_SEQ - The sequence number of the column within the foreign key.</li>
1815:    * <li>UPDATE_RULE - How the foreign key behaves when the primary key is
1816:    * updated.  This is one of the constants defined in this class 
1817:    * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1818:    * <code>importedKeySetNull</code>, <code>importedKeySetDefault</code>, or
1819:    * <code>importedKeyRestrict</code>).</li>
1820:    * <li>DELETE_RULE - How the foreign key behaves when the primary key is
1821:    * deleted.  This is one of the constants defined in this class 
1822:    * (<code>importedNoAction</code>, <code>importedKeyCascade</code>,
1823:    * <code>importedKeySetNull</code>, or <code>importedKeySetDefault</code>)</li>
1824:    * <li>FK_NAME - The name of the foreign key.</li>
1825:    * <li>PK_NAME - The name of the primary key.</li>
1826:    * <li>DEFERRABILITY - The deferrability value.  This is one of the
1827:    * constants defined in this table (<code>importedKeyInitiallyDeferred</code>,
1828:    * <code>importedKeyInitiallyImmediate</code>, or
1829:    * <code>importedKeyNotDeferrable</code>).</li>
1830:    * </ol>
1831:    *
1832:    * @param primaryCatalog The catalog to retrieve information from, or the
1833:    *        empty string to return entities not associated with a catalog, or
1834:    *        <code>null</code> to return information from all catalogs, on the
1835:    *         exporting side.
1836:    * @param primarySchema The schema to retrieve information from, or the empty
1837:    *        string to return entities not associated with a schema, on the
1838:    *        exporting side.
1839:    * @param primaryTableName The table name to return information for, on the
1840:    *        exporting side.
1841:    * @param foreignCatalog The catalog to retrieve information from, or the
1842:    *        empty string to return entities not associated with a catalog,
1843:    *        or <code>null</code> to return information from all catalogs, on
1844:    *        the importing side.
1845:    * @param foreignSchema The schema to retrieve information from, or the
1846:    *        empty string to return entities not associated with a schema on
1847:    *        the importing side.
1848:    * @param foreignTableName The table name to return information for on the
1849:    *        importing side.
1850:    * @return A <code>ResultSet</code> with the requested information
1851:    * @exception SQLException If an error occurs.
1852:    */
1853:   ResultSet getCrossReference(String primaryCatalog, String
1854:     primarySchema, String primaryTableName, String foreignCatalog, String
1855:     foreignSchema, String foreignTableName) throws SQLException;
1856: 
1857:   /**
1858:    * This method returns a list of the SQL types supported by this
1859:    * database.  The information is returned as a <code>ResultSet</code>
1860:    * with the following columns:
1861:    *
1862:    * <ol>
1863:    * <li>TYPE_NAME - The name of the data type.</li>
1864:    * <li>DATA_TYPE - A data type constant from <code>Types</code> for this
1865:    * type.</li>
1866:    * <li>PRECISION - The maximum precision of this type.</li>
1867:    * <li>LITERAL_PREFIX - Prefix value used to quote a literal, which may be
1868:    * <code>null</code>.</li>
1869:    * <li>LITERAL_SUFFIX - Suffix value used to quote a literal, which may be
1870:    * <code>null</code>.</li>
1871:    * <li>CREATE_PARAMS - The parameters used to create the type, which may be
1872:    * <code>null</code>.</li>
1873:    * <li>NULLABLE - Whether or not this type supports NULL values.  This will
1874:    * be one of the constants defined in this interface 
1875:    * (<code>typeNoNulls</code>, <code>typeNullable</code>, or
1876:    * <code>typeNullableUnknown</code>).</li>
1877:    * <li>CASE_SENSITIVE - Whether or not the value is case sensitive.</li>
1878:    * <li>SEARCHABLE - Whether or not "LIKE" expressions are supported in
1879:    * WHERE clauses for this type.  This will be one of the constants defined
1880:    * in this interface (<code>typePredNone</code>, <code>typePredChar</code>,
1881:    * <code>typePredBasic</code>, or <code>typeSearchable</code>).</li>
1882:    * <li>UNSIGNED_ATTRIBUTE - Is the value of this type unsigned.</li>
1883:    * <li>FIXED_PREC_SCALE - Whether or not this type can be used for money.</li>
1884:    * <li>AUTO_INCREMENT - Whether or not this type supports auto-incrementing.</li>
1885:    * <li>LOCAL_TYPE_NAME - A localized name for this data type.</li>
1886:    * <li>MINIMUM_SCALE - The minimum scale supported by this type.</li>
1887:    * <li>MAXIMUM_SCALE - The maximum scale supported by this type.</li>
1888:    * <li>SQL_DATA_TYPE - Unused.</li>
1889:    * <li>SQL_DATETIME_SUB - Unused.</li>
1890:    * <li>NUM_PREC_RADIX - The radix of this data type.</li>
1891:    * </ol>
1892:    * 
1893:    * @return A <code>ResultSet</code> with the list of available data types.
1894:    * @exception SQLException If an error occurs.
1895:    */
1896:   ResultSet getTypeInfo() throws SQLException;
1897: 
1898:   /**
1899:    * This method returns information about a tables indices and statistics.
1900:    * It is returned as a <code>ResultSet</code> with the following columns:
1901:    *
1902:    * <ol>
1903:    * <li>TABLE_CAT - The catalog of the table, which may be <code>null</code>.</li>
1904:    * <li>TABLE_SCHEM - The schema of the table, which may be <code>null</code>.</li>
1905:    * <li>TABLE_NAME - The name of the table.</li>
1906:    * <li>NON_UNIQUE - Are index values non-unique?</li>
1907:    * <li>INDEX_QUALIFIER The index catalog, which may be <code>null</code></li>
1908:    * <li>INDEX_NAME - The name of the index.</li>
1909:    * <li>TYPE - The type of index, which will be one of the constants defined
1910:    * in this interface (<code>tableIndexStatistic</code>,
1911:    * <code>tableIndexClustered</code>, <code>tableIndexHashed</code>, or
1912:    * <code>tableIndexOther</code>).</li>
1913:    * <li>ORDINAL_POSITION - The sequence number of this column in the index.
1914:    * This will be 0 when the index type is <code>tableIndexStatistic</code>.</li>
1915:    * <li>COLUMN_NAME - The name of this column in the index.</li>
1916:    * <li>ASC_OR_DESC - "A" for an ascending sort sequence, "D" for a
1917:    * descending sort sequence or <code>null</code> if a sort sequence is not
1918:    * supported.</li>
1919:    * <li>CARDINALITY - The number of unique rows in the index, or the number
1920:    * of rows in the table if the index type is <code>tableIndexStatistic</code>.</li>
1921:    * <li>PAGES - The number of pages used for the index, or the number of pages
1922:    * in the table if the index type is <code>tableIndexStatistic</code>.</li>
1923:    * <li>FILTER_CONDITION - The filter condition for this index, which may be
1924:    * <code>null</code>.</li>
1925:    * </ol>
1926:    *
1927:    * @param catalog The catalog to retrieve information from, or the empty string
1928:    *        to return entities not associated with a catalog, or 
1929:    *        <code>null</code> to return information from all catalogs.
1930:    * @param schema The schema to retrieve information from, or the empty string
1931:    *        to return entities not associated with a schema.
1932:    * @param tableName The table name to return information for.
1933:    * @param unique <code>true</code> to return only unique indexes, 
1934:    *        <code>false</code> otherwise.
1935:    * @param approximate <code>true</code> if data values can be approximations,
1936:    *        <code>false</code> otherwise.
1937:    * @return A <code>ResultSet</code> with the requested index information
1938:    * @exception SQLException If an error occurs.
1939:    */
1940:   ResultSet getIndexInfo(String catalog, String schema, String tableName,
1941:     boolean unique, boolean approximate) throws SQLException;
1942: 
1943:   /**
1944:    * This method tests whether or not the datbase supports the specified
1945:    * result type.
1946:    *
1947:    * @param type The desired result type, which is one of the constants
1948:    * defined in <code>ResultSet</code>.
1949:    *
1950:    * @return <code>true</code> if the result set type is supported,
1951:    * <code>false</code> otherwise.
1952:    *
1953:    * @exception SQLException If an error occurs.
1954:    *
1955:    * @see ResultSet
1956:    */
1957:   boolean supportsResultSetType(int type) throws SQLException;
1958: 
1959:   /**
1960:    * This method tests whether the specified result set type and result set
1961:    * concurrency type are supported by the database.
1962:    *
1963:    * @param type The desired result type, which is one of the constants
1964:    *        defined in <code>ResultSet</code>.
1965:    * @param concurrency The desired concurrency type, which is one of the
1966:    *                    constants defined in <code>ResultSet</code>.
1967:    * @return <code>true</code> if the result set type is supported,
1968:    *         <code>false</code> otherwise.
1969:    * @exception SQLException If an error occurs.
1970:    * @see ResultSet
1971:    */
1972:   boolean supportsResultSetConcurrency(int type, int concurrency)
1973:       throws SQLException;
1974: 
1975:   /**
1976:    * This method tests whether or not the specified result set type sees its
1977:    * own updates.
1978:    *
1979:    * @param type The desired result type, which is one of the constants
1980:    *        defined in <code>ResultSet</code>.
1981:    * @return <code>true</code> if the result set type sees its own updates,
1982:    *         <code>false</code> otherwise.
1983:    * @exception SQLException If an error occurs.
1984:    * @see ResultSet
1985:    */
1986:   boolean ownUpdatesAreVisible(int type) throws SQLException;
1987: 
1988:  /**
1989:    * This method tests whether or not the specified result set type sees its
1990:    * own deletes.
1991:    *
1992:    * @param type The desired result type, which is one of the constants
1993:    *        defined in <code>ResultSet</code>.
1994:    * @return <code>true</code> if the result set type sees its own deletes,
1995:    *         <code>false</code> otherwise.
1996:    * @exception SQLException If an error occurs.
1997:    * @see ResultSet
1998:    */
1999:   boolean ownDeletesAreVisible(int type) throws SQLException;
2000: 
2001:   /**
2002:    * This method tests whether or not the specified result set type sees its
2003:    * own inserts.
2004:    *
2005:    * @param type The desired result type, which is one of the constants
2006:    *        defined in <code>ResultSet</code>.
2007:    * @return <code>true</code> if the result set type sees its own inserts,
2008:    *         <code>false</code> otherwise.
2009:    * @exception SQLException If an error occurs.
2010:    * @see ResultSet
2011:    */
2012:   boolean ownInsertsAreVisible(int type) throws SQLException;
2013: 
2014:   /**
2015:    * This method tests whether or not the specified result set type sees 
2016:    * updates committed by others.
2017:    *
2018:    * @param type The desired result type, which is one of the constants
2019:    *        defined in <code>ResultSet</code>.
2020:    * @return <code>true</code> if the result set type sees other updates,
2021:    *         <code>false</code> otherwise.
2022:    * @exception SQLException If an error occurs.
2023:    * @see ResultSet
2024:    */
2025:   boolean othersUpdatesAreVisible(int type) throws SQLException;
2026: 
2027:   /**
2028:    * This method tests whether or not the specified result set type sees 
2029:    * deletes committed by others.
2030:    *
2031:    * @param type The desired result type, which is one of the constants
2032:    *        defined in <code>ResultSet</code>.
2033:    * @return <code>true</code> if the result set type sees other deletes,
2034:    *         <code>false</code> otherwise.
2035:    * @exception SQLException If an error occurs.
2036:    * @see ResultSet
2037:    */
2038:   boolean othersDeletesAreVisible(int type) throws SQLException;
2039: 
2040:   /**
2041:    * This method tests whether or not the specified result set type sees 
2042:    * inserts committed by others.
2043:    *
2044:    * @param type The desired result type, which is one of the constants
2045:    *        defined in <code>ResultSet</code>.
2046:    * @return <code>true</code> if the result set type sees other inserts,
2047:    *         <code>false</code> otherwise.
2048:    * @exception SQLException If an error occurs.
2049:    * @see ResultSet
2050:    */
2051:   boolean othersInsertsAreVisible(int type) throws SQLException;
2052: 
2053:   /**
2054:    * This method tests whether or not the specified result set type can detect
2055:    * a visible update by calling the <code>rowUpdated</code> method.
2056:    *
2057:    * @param type The desired result type, which is one of the constants
2058:    *        defined in <code>ResultSet</code>.
2059:    * @return <code>true</code> if the result set type can detect visible updates
2060:    *         using <code>rowUpdated</code>, <code>false</code> otherwise.
2061:    * @exception SQLException If an error occurs.
2062:    * @see ResultSet
2063:    */
2064:   boolean updatesAreDetected(int type) throws SQLException;
2065: 
2066:   /**
2067:    * This method tests whether or not the specified result set type can detect
2068:    * a visible delete by calling the <code>rowUpdated</code> method.
2069:    *
2070:    * @param type The desired result type, which is one of the constants
2071:    *        defined in <code>ResultSet</code>.
2072:    * @return <code>true</code> if the result set type can detect visible deletes
2073:    *         using <code>rowUpdated</code>, <code>false</code> otherwise.
2074:    * @exception SQLException If an error occurs.
2075:    * @see ResultSet
2076:    */
2077:   boolean deletesAreDetected(int type) throws SQLException;
2078:   
2079:   /**
2080:    * This method tests whether or not the specified result set type can detect
2081:    * a visible insert by calling the <code>rowUpdated</code> method.
2082:    *
2083:    * @param type The desired result type, which is one of the constants
2084:    *        defined in <code>ResultSet</code>.
2085:    * @return <code>true</code> if the result set type can detect visible inserts
2086:    *         using <code>rowUpdated</code>, <code>false</code> otherwise.
2087:    * @exception SQLException If an error occurs.
2088:    * @see ResultSet
2089:    */
2090:   boolean insertsAreDetected(int type) throws SQLException;
2091: 
2092:   /**
2093:    * This method tests whether or not the database supports batch updates.
2094:    *
2095:    * @return <code>true</code> if batch updates are supported,
2096:    *         <code>false</code> otherwise.
2097:    * @exception SQLException If an error occurs.
2098:    */
2099:   boolean supportsBatchUpdates() throws SQLException;
2100: 
2101:   /**
2102:    * This method returns the list of user defined data types in use.  These
2103:    * are returned as a <code>ResultSet</code> with the following columns:
2104:    *
2105:    * <ol>
2106:    * <li>TYPE_CAT - The catalog name, which may be <code>null</code>.</li>
2107:    * <li>TYPE_SCEHM - The schema name, which may be <code>null</code>.</li>
2108:    * <li>TYPE_NAME - The user defined data type name.</li>
2109:    * <li>CLASS_NAME - The Java class name this type maps to.</li>
2110:    * <li>DATA_TYPE - A type identifier from <code>Types</code> for this type.
2111:    * This will be one of <code>JAVA_OBJECT</code>, <code>STRUCT</code>, or
2112:    * <code>DISTINCT</code>.</li>
2113:    * <li>REMARKS - Comments about this data type.</li>
2114:    * </ol>
2115:    *
2116:    * @param catalog The catalog to retrieve information from, or the empty string
2117:    *        to return entities not associated with a catalog, or <code>null</code>
2118:    *        to return information from all catalogs.
2119:    * @param schemaPattern The schema to retrieve information from, or the
2120:    *        empty string to return entities not associated with a schema.
2121:    * @param typePattern The type name pattern to match.
2122:    * @param types The type identifier patterns (from <code>Types</code>) to
2123:    *        match.
2124:    * @return A <code>ResultSet</code> with the requested type information
2125:    * @exception SQLException If an error occurs.
2126:    */
2127:   ResultSet getUDTs(String catalog, String schemaPattern, String
2128:       typePattern, int[] types) throws SQLException;
2129: 
2130:   /**
2131:    * This method returns the <code>Connection</code> object that was used
2132:    * to generate the metadata in this object.
2133:    *
2134:    * @return The connection for this object.
2135:    * @exception SQLException If an error occurs.
2136:    */
2137:   Connection getConnection() throws SQLException;
2138: 
2139:   /**
2140:    * This method tests whether the databse supports savepoints.
2141:    * 
2142:    * @return <code>true</code> if the database supports savepoints,
2143:    *         <code>false</code> if it does not.
2144:    * @exception SQLException If an error occurs.
2145:    * @see Savepoint
2146:    * @since 1.4
2147:    */
2148:   boolean supportsSavepoints() throws SQLException;
2149: 
2150:   /**
2151:    * This method tests whether the database supports named parameters.
2152:    * 
2153:    * @return <code>true</code> if the database supports named parameters,
2154:    *         <code>false</code> if it does not.
2155:    * @exception SQLException If an error occurs.
2156:    * @since 1.4
2157:    */
2158:   boolean supportsNamedParameters() throws SQLException;
2159: 
2160:   /**
2161:    * This method tests whether the database supports returning multiple
2162:    * <code>ResultSet</code>S from a <code>CallableStatement</code> at once.
2163:    * 
2164:    * @return <code>true</code> if the database supports returnig multiple
2165:    *         results at once, <code>false</code> if it does not.
2166:    * @exception SQLException If an error occurs.
2167:    * @since 1.4
2168:    */
2169:   boolean supportsMultipleOpenResults() throws SQLException;
2170: 
2171:   /**
2172:    * @since 1.4
2173:    */
2174:   boolean supportsGetGeneratedKeys() throws SQLException;
2175: 
2176:   /**
2177:    * @since 1.4
2178:    */
2179:   ResultSet getSuperTypes(String catalog, String schemaPattern,
2180:     String typePattern) throws SQLException;
2181: 
2182:   /**
2183:    * @since 1.4
2184:    */
2185:   ResultSet getSuperTables(String catalog, String schemaPattern,
2186:     String tablePattern) throws SQLException;
2187: 
2188:   /**
2189:    * @since 1.4
2190:    */
2191:   ResultSet getAttributes(String catalog, String schemaPattern, String
2192:     typePattern, String attributePattern) throws SQLException;
2193: 
2194:   /**
2195:    * This method tests if the database supports the specified holdability type.
2196:    * Valid values for this parameter are specified in the
2197:    * <code>ResultSet</code> class.
2198:    * 
2199:    * @param holdability The holdability type to test.
2200:    * @return <code>true</code> if the database supports the holdability type,
2201:    *         <code>false</code> if it does not.
2202:    * @exception SQLException If an error occurs.
2203:    * @see ResultSet
2204:    * @since 1.4
2205:    */
2206:   boolean supportsResultSetHoldability(int holdability)
2207:     throws SQLException;
2208: 
2209:   /**
2210:    * This method returns the default holdability type of <code>ResultSet</code>S
2211:    * retrieved from this database. The possible values are specified in the
2212:    * <code>ResultSet</code> class.
2213:    * 
2214:    * @return The default holdability type.
2215:    * @exception SQLException If an error occurs.
2216:    * @since 1.4
2217:    */
2218:   int getResultSetHoldability() throws SQLException;
2219: 
2220:   /**
2221:    * This method returns the major version number of the database.
2222:    * 
2223:    * @return The major version number of the database.
2224:    * @exception SQLException If an error occurs.
2225:    * @since 1.4
2226:    */
2227:   int getDatabaseMajorVersion() throws SQLException;
2228: 
2229:   /**
2230:    * This method returns the minor version number of the database.
2231:    * 
2232:    * @return The minor version number of the database.
2233:    * @exception SQLException If an error occurs.
2234:    * @since 1.4
2235:    */
2236:   int getDatabaseMinorVersion() throws SQLException;
2237: 
2238:   /**
2239:    * This method returns the major version number of the JDBC driver.
2240:    * 
2241:    * @return The major version number of the JDBC driver.
2242:    * @exception  SQLException If an error occurs.
2243:    * @since 1.4
2244:    */
2245:   int getJDBCMajorVersion() throws SQLException;
2246: 
2247:   /**
2248:    * This method returns the minor version number of the JDBC driver.
2249:    * 
2250:    * @return The minor version number of the database.
2251:    * @exception SQLException If an error occurs.
2252:    * @since 1.4
2253:    */
2254:   int getJDBCMinorVersion() throws SQLException;
2255: 
2256:   /**
2257:    * @since 1.4
2258:    */
2259:   int getSQLStateType() throws SQLException;
2260: 
2261:   /**
2262:    * @since 1.4
2263:    */
2264:   boolean locatorsUpdateCopy() throws SQLException;
2265: 
2266:   /**
2267:    * @since 1.4
2268:    */
2269:   boolean supportsStatementPooling() throws SQLException;
2270: }