001 package com.mockrunner.mock.jdbc; 002 003 import java.sql.Connection; 004 import java.sql.DatabaseMetaData; 005 import java.sql.ResultSet; 006 import java.sql.RowIdLifetime; 007 import java.sql.SQLException; 008 import java.util.ArrayList; 009 import java.util.Arrays; 010 import java.util.HashMap; 011 import java.util.Iterator; 012 import java.util.List; 013 import java.util.Map; 014 015 import com.mockrunner.util.common.StringUtil; 016 017 /** 018 * Mock implementation of <code>DatabaseMetaData</code>. 019 */ 020 public class MockDatabaseMetaData implements DatabaseMetaData 021 { 022 private boolean caseSensitive = false; 023 private int databaseMajorVersion = 1; 024 private int databaseMinorVersion = 0; 025 private int defaultTransactionLevel = Connection.TRANSACTION_READ_COMMITTED; 026 private int driverMajorVersion = 1; 027 private int driverMinorVersion = 0; 028 private int jdbcMajorVersion = 3; 029 private int jdbcMinorVersion = 0; 030 private int maxBinaryLiteralLength = 0; 031 private int maxCatalogNameLength = 0; 032 private int maxCharLiteralLength = 0; 033 private int maxColumnNameLength = 0; 034 private int maxColumnsInGroupBy = 0; 035 private int maxColumnsInIndex = 0; 036 private int maxColumnsInOrderBy = 0; 037 private int maxColumnsInSelect = 0; 038 private int maxColumnsInTable = 0; 039 private int maxConnections = 0; 040 private int maxCursorNameLength = 0; 041 private int maxIndexLength = 0; 042 private int maxProcedureNameLength = 0; 043 private int maxRowSize = 0; 044 private int maxSchemaNameLength = 0; 045 private int maxStatementLength = 0; 046 private int maxStatements = 0; 047 private int maxTableNameLength = 0; 048 private int maxTablesInSelect = 0; 049 private int maxUserNameLength = 0; 050 private int resultSetHoldability = 1; // 1 == ResultSet.HOLD_CURSORS_OVER_COMMIT 051 private int sqlStateType = sqlStateSQL99; 052 private RowIdLifetime rowIdLifetime = RowIdLifetime.ROWID_VALID_TRANSACTION; 053 private boolean autoCommitFailureClosesAllResultSets = false; 054 private boolean allProceduresAreCallable = true; 055 private boolean allTablesAreSelectable = true; 056 private boolean dataDefinitionCausesTransactionCommit = false; 057 private boolean dataDefinitionIgnoredInTransactions = false; 058 private boolean doesMaxRowSizeIncludeBlobs = false; 059 private boolean isCatalogAtStart = false; 060 private boolean isReadOnly = false; 061 private boolean locatorsUpdateCopy = false; 062 private boolean nullPlusNonNullIsNull = false; 063 private boolean nullsAreSortedAtEnd = false; 064 private boolean nullsAreSortedAtStart = false; 065 private boolean nullsAreSortedHigh = false; 066 private boolean nullsAreSortedLow = false; 067 private boolean storesLowerCaseIdentifiers = true; 068 private boolean storesLowerCaseQuotedIdentifiers = true; 069 private boolean storesMixedCaseIdentifiers = true; 070 private boolean storesMixedCaseQuotedIdentifiers = true; 071 private boolean storesUpperCaseIdentifiers = true; 072 private boolean storesUpperCaseQuotedIdentifiers = true; 073 private boolean supportsANSI92EntryLevelSQL = true; 074 private boolean supportsANSI92FullSQL = true; 075 private boolean supportsANSI92IntermediateSQL = true; 076 private boolean supportsAlterTableWithAddColumn = true; 077 private boolean supportsAlterTableWithDropColumn = true; 078 private boolean supportsBatchUpdates = true; 079 private boolean supportsCatalogsInDataManipulation = true; 080 private boolean supportsCatalogsInIndexDefinitions = true; 081 private boolean supportsCatalogsInPrivilegeDefinitions = true; 082 private boolean supportsCatalogsInProcedureCalls = true; 083 private boolean supportsCatalogsInTableDefinitions = true; 084 private boolean supportsColumnAliasing = true; 085 private boolean supportsConvert = true; 086 private boolean supportsCoreSQLGrammar = true; 087 private boolean supportsCorrelatedSubqueries = true; 088 private boolean supportsDataDefinitionAndDataManipulationTransactions = true; 089 private boolean supportsDataManipulationTransactionsOnly = false; 090 private boolean supportsDifferentTableCorrelationNames; 091 private boolean supportsExpressionsInOrderBy = true; 092 private boolean supportsExtendedSQLGrammar = true; 093 private boolean supportsFullOuterJoins = true; 094 private boolean supportsGetGeneratedKeys = true; 095 private boolean supportsGroupBy = true; 096 private boolean supportsGroupByBeyondSelect = true; 097 private boolean supportsGroupByUnrelated = true; 098 private boolean supportsIntegrityEnhancementFacility = true; 099 private boolean supportsLikeEscapeClause = true; 100 private boolean supportsLimitedOuterJoins = true; 101 private boolean supportsMinimumSQLGrammar = true;; 102 private boolean supportsMixedCaseIdentifiers = true; 103 private boolean supportsMixedCaseQuotedIdentifiers = true; 104 private boolean supportsMultipleOpenResults = true; 105 private boolean supportsMultipleResultSets = true; 106 private boolean supportsMultipleTransactions = true; 107 private boolean supportsNamedParameters = true; 108 private boolean supportsNonNullableColumns = true; 109 private boolean supportsOpenCursorsAcrossCommit = true; 110 private boolean supportsOpenCursorsAcrossRollback = true; 111 private boolean supportsOpenStatementsAcrossCommit = true; 112 private boolean supportsOpenStatementsAcrossRollback = true; 113 private boolean supportsOrderByUnrelated = true; 114 private boolean supportsOuterJoins = true; 115 private boolean supportsPositionedDelete = true; 116 private boolean supportsPositionedUpdate = true; 117 private boolean supportsSavepoints = true; 118 private boolean supportsSchemasInDataManipulation = true; 119 private boolean supportsSchemasInIndexDefinitions = true; 120 private boolean supportsSchemasInPrivilegeDefinitions = true; 121 private boolean supportsSchemasInProcedureCalls = true; 122 private boolean supportsSchemasInTableDefinitions = true; 123 private boolean supportsSelectForUpdate = true; 124 private boolean supportsStatementPooling = true; 125 private boolean supportsStoredProcedures = true; 126 private boolean supportsSubqueriesInComparisons = true; 127 private boolean supportsSubqueriesInExists = true; 128 private boolean supportsSubqueriesInIns = true; 129 private boolean supportsSubqueriesInQuantifieds = true; 130 private boolean supportsTableCorrelationNames = true; 131 private boolean supportsTransactions = true;; 132 private boolean supportsUnion = true; 133 private boolean supportsUnionAll = true; 134 private boolean usesLocalFilePerTable = false; 135 private boolean usesLocalFiles = true; 136 private boolean deletesAreDetected = true; 137 private boolean insertsAreDetected = true; 138 private boolean othersDeletesAreVisible = true; 139 private boolean othersInsertsAreVisible = true; 140 private boolean othersUpdatesAreVisible = true; 141 private boolean ownDeletesAreVisible = true; 142 private boolean ownInsertsAreVisible = true; 143 private boolean ownUpdatesAreVisible = true; 144 private boolean supportsResultSetHoldability = true; 145 private boolean supportsResultSetType = true; 146 private boolean supportsTransactionIsolationLevel = true; 147 private boolean updatesAreDetected = true; 148 private boolean supportsResultSetConcurrency = true; 149 private boolean supportsStoredFunctionsUsingCallSyntax = true; 150 private String catalogSeparator = "."; 151 private String catalogTerm = "database"; 152 private String databaseProductName = "MockDatabase"; 153 private String databaseProductVersion = "1.0"; 154 private String driverName = MockDriver.class.getName(); 155 private String driverVersion = "1.0"; 156 private String extraNameCharacters = ""; 157 private String identifierQuoteString = " "; 158 private String numericFunctions = ""; 159 private String procedureTerm = ""; 160 private String sqlKeywords = ""; 161 private String schemaTerm = ""; 162 private String searchStringEscape = "\\"; 163 private String stringFunctions = ""; 164 private String systemFunctions = ""; 165 private String timeDateFunctions = ""; 166 private String url; 167 private String userName; 168 private Connection connection; 169 private ResultSet catalogs; 170 private ResultSet tableTypes; 171 private ResultSet typeInfo; 172 private ResultSet clientInfoProperties; 173 private Map schemasMap = new HashMap(); 174 private Map exportedKeysMap = new HashMap(); 175 private Map importedKeysMap = new HashMap(); 176 private Map primaryKeysMap = new HashMap(); 177 private Map proceduresMap = new HashMap(); 178 private Map functionsMap = new HashMap(); 179 private Map superTablesMap = new HashMap(); 180 private Map superTypesMap = new HashMap(); 181 private Map tablePrivilegesMap = new HashMap(); 182 private Map versionColumnsMap = new HashMap(); 183 private Map bestRowIdentifierMap = new HashMap(); 184 private Map indexInfoMap = new HashMap(); 185 private Map udtsMap = new HashMap(); 186 private Map attributesMap = new HashMap(); 187 private Map columnPrivilegesMap = new HashMap(); 188 private Map columnsMap = new HashMap(); 189 private Map procedureColumnsMap = new HashMap(); 190 private Map functionColumnsMap = new HashMap(); 191 private Map tablesMap = new HashMap(); 192 private Map crossReferenceMap = new HashMap(); 193 194 /** 195 * Set if matching of catalogs, schemas, tables and columns 196 * is case sensitive. Defaults to <code>false</code>. 197 * @param caseSensitive is matching case sensitive 198 */ 199 public void setCaseSensitive(boolean caseSensitive) 200 { 201 this.caseSensitive = caseSensitive; 202 } 203 204 public int getDatabaseMajorVersion() throws SQLException 205 { 206 return databaseMajorVersion; 207 } 208 209 public void setDatabaseMajorVersion(int version) 210 { 211 databaseMajorVersion = version; 212 } 213 214 public int getDatabaseMinorVersion() throws SQLException 215 { 216 return databaseMinorVersion; 217 } 218 219 public void setDatabaseMinorVersion(int version) 220 { 221 databaseMinorVersion = version; 222 } 223 224 public int getDefaultTransactionIsolation() throws SQLException 225 { 226 return defaultTransactionLevel; 227 } 228 229 public void setDefaultTransactionIsolation(int defaultTransactionLevel) 230 { 231 this.defaultTransactionLevel = defaultTransactionLevel; 232 } 233 234 public int getDriverMajorVersion() 235 { 236 return driverMajorVersion; 237 } 238 239 public void setDriverMajorVersion(int driverMajorVersion) 240 { 241 this.driverMajorVersion = driverMajorVersion; 242 } 243 244 public int getDriverMinorVersion() 245 { 246 return driverMinorVersion; 247 } 248 249 public void setDriverMinorVersion(int driverMinorVersion) 250 { 251 this.driverMinorVersion = driverMinorVersion; 252 } 253 254 public int getJDBCMajorVersion() throws SQLException 255 { 256 return jdbcMajorVersion; 257 } 258 259 public void setJDBCMajorVersion(int jdbcMajorVersion) 260 { 261 this.jdbcMajorVersion = jdbcMajorVersion; 262 } 263 264 public int getJDBCMinorVersion() throws SQLException 265 { 266 return jdbcMinorVersion; 267 } 268 269 public void setJDBCMinorVersion(int jdbcMinorVersion) 270 { 271 this.jdbcMinorVersion = jdbcMinorVersion; 272 } 273 274 public int getMaxBinaryLiteralLength() throws SQLException 275 { 276 return maxBinaryLiteralLength; 277 } 278 279 public void setMaxBinaryLiteralLength(int maxBinaryLiteralLength) 280 { 281 this.maxBinaryLiteralLength = maxBinaryLiteralLength; 282 } 283 284 public int getMaxCatalogNameLength() throws SQLException 285 { 286 return maxCatalogNameLength; 287 } 288 289 public void setetMaxCatalogNameLength(int maxCatalogNameLength) 290 { 291 this.maxCatalogNameLength = maxCatalogNameLength; 292 } 293 294 public int getMaxCharLiteralLength() throws SQLException 295 { 296 return maxCharLiteralLength; 297 } 298 299 public void setMaxCharLiteralLength(int maxCharLiteralLength) 300 { 301 this.maxCharLiteralLength = maxCharLiteralLength; 302 } 303 304 public int getMaxColumnNameLength() throws SQLException 305 { 306 return maxColumnNameLength; 307 } 308 309 public void setMaxColumnNameLength(int maxColumnNameLength) 310 { 311 this.maxColumnNameLength = maxColumnNameLength; 312 } 313 314 public int getMaxColumnsInGroupBy() throws SQLException 315 { 316 return maxColumnsInGroupBy; 317 } 318 319 public void setMaxColumnsInGroupBy(int maxColumnsInGroupBy) 320 { 321 this.maxColumnsInGroupBy = maxColumnsInGroupBy; 322 } 323 324 public int getMaxColumnsInIndex() throws SQLException 325 { 326 return maxColumnsInIndex; 327 } 328 329 public void setMaxColumnsInIndex(int maxColumnsInIndex) 330 { 331 this.maxColumnsInIndex = maxColumnsInIndex; 332 } 333 334 public int getMaxColumnsInOrderBy() throws SQLException 335 { 336 return maxColumnsInOrderBy; 337 } 338 339 public void setMaxColumnsInOrderBy(int maxColumnsInOrderBy) 340 { 341 this.maxColumnsInOrderBy = maxColumnsInOrderBy; 342 } 343 344 public int getMaxColumnsInSelect() throws SQLException 345 { 346 return maxColumnsInSelect; 347 } 348 349 public void setMaxColumnsInSelect(int maxColumnsInSelect) 350 { 351 this.maxColumnsInSelect = maxColumnsInSelect; 352 } 353 354 public int getMaxColumnsInTable() throws SQLException 355 { 356 return maxColumnsInTable; 357 } 358 359 public void setMaxColumnsInTable(int maxColumnsInTable) 360 { 361 this.maxColumnsInTable = maxColumnsInTable; 362 } 363 364 public int getMaxConnections() throws SQLException 365 { 366 return maxConnections; 367 } 368 369 public void setMaxConnections(int maxConnections) 370 { 371 this.maxConnections = maxConnections; 372 } 373 374 public int getMaxCursorNameLength() throws SQLException 375 { 376 return maxCursorNameLength; 377 } 378 379 public void setMaxCursorNameLength(int maxCursorNameLength) 380 { 381 this.maxCursorNameLength = maxCursorNameLength; 382 } 383 384 public int getMaxIndexLength() throws SQLException 385 { 386 return maxIndexLength; 387 } 388 389 public void setMaxIndexLength(int maxIndexLength) 390 { 391 this.maxIndexLength = maxIndexLength; 392 } 393 394 public int getMaxProcedureNameLength() throws SQLException 395 { 396 return maxProcedureNameLength; 397 } 398 399 public void setMaxProcedureNameLength(int maxProcedureNameLength) 400 { 401 this.maxProcedureNameLength = maxProcedureNameLength; 402 } 403 404 public int getMaxRowSize() throws SQLException 405 { 406 return maxRowSize; 407 } 408 409 public void setMaxRowSize(int maxRowSize) 410 { 411 this.maxRowSize = maxRowSize; 412 } 413 414 public int getMaxSchemaNameLength() throws SQLException 415 { 416 return maxSchemaNameLength; 417 } 418 419 public void setMaxSchemaNameLength(int maxSchemaNameLength) 420 { 421 this.maxSchemaNameLength = maxSchemaNameLength; 422 } 423 424 public int getMaxStatementLength() throws SQLException 425 { 426 return maxStatementLength; 427 } 428 429 public void setMaxStatementLength(int maxStatementLength) 430 { 431 this.maxStatementLength = maxStatementLength; 432 } 433 434 public int getMaxStatements() throws SQLException 435 { 436 return maxStatements; 437 } 438 439 public void setMaxStatements(int maxStatements) 440 { 441 this.maxStatements = maxStatements; 442 } 443 444 public int getMaxTableNameLength() throws SQLException 445 { 446 return maxTableNameLength; 447 } 448 449 public void setMaxTableNameLength(int maxTableNameLength) 450 { 451 this.maxTableNameLength = maxTableNameLength; 452 } 453 454 public int getMaxTablesInSelect() throws SQLException 455 { 456 return maxTablesInSelect; 457 } 458 459 public void setMaxTablesInSelect(int maxTablesInSelect) 460 { 461 this.maxTablesInSelect = maxTablesInSelect; 462 } 463 464 public int getMaxUserNameLength() throws SQLException 465 { 466 return maxUserNameLength; 467 } 468 469 public void setMaxUserNameLength(int maxUserNameLength) 470 { 471 this.maxUserNameLength = maxUserNameLength; 472 } 473 474 public int getResultSetHoldability() throws SQLException 475 { 476 return resultSetHoldability; 477 } 478 479 public void setResultSetHoldability(int resultSetHoldability) 480 { 481 this.resultSetHoldability = resultSetHoldability; 482 } 483 484 public int getSQLStateType() throws SQLException 485 { 486 return sqlStateType; 487 } 488 489 public void setSQLStateType(int sqlStateType) 490 { 491 this.sqlStateType = sqlStateType; 492 } 493 494 public RowIdLifetime getRowIdLifetime() throws SQLException 495 { 496 return rowIdLifetime; 497 } 498 499 public void setRowIdLifetime(RowIdLifetime rowIdLifetime) 500 { 501 this.rowIdLifetime = rowIdLifetime; 502 } 503 504 public boolean autoCommitFailureClosesAllResultSets() throws SQLException 505 { 506 return autoCommitFailureClosesAllResultSets; 507 } 508 509 public void setAutoCommitFailureClosesAllResultSets(boolean closesAllResultSets) 510 { 511 autoCommitFailureClosesAllResultSets = closesAllResultSets; 512 } 513 514 public boolean allProceduresAreCallable() throws SQLException 515 { 516 return allProceduresAreCallable; 517 } 518 519 public void setAllProceduresAreCallable(boolean callable) 520 { 521 allProceduresAreCallable = callable; 522 } 523 524 public boolean allTablesAreSelectable() throws SQLException 525 { 526 return allTablesAreSelectable; 527 } 528 529 public void setAllTablesAreSelectable(boolean selectable) 530 { 531 allTablesAreSelectable = selectable; 532 } 533 534 public boolean dataDefinitionCausesTransactionCommit() throws SQLException 535 { 536 return dataDefinitionCausesTransactionCommit; 537 } 538 539 public void setDataDefinitionCausesTransactionCommit(boolean causesCommit) 540 { 541 dataDefinitionCausesTransactionCommit = causesCommit; 542 } 543 544 public boolean dataDefinitionIgnoredInTransactions() throws SQLException 545 { 546 return dataDefinitionIgnoredInTransactions; 547 } 548 549 public void setDataDefinitionIgnoredInTransactions(boolean ignored) 550 { 551 dataDefinitionIgnoredInTransactions = ignored; 552 } 553 554 public boolean doesMaxRowSizeIncludeBlobs() throws SQLException 555 { 556 return doesMaxRowSizeIncludeBlobs; 557 } 558 559 public void setDoesMaxRowSizeIncludeBlobs(boolean includeBlobs) 560 { 561 doesMaxRowSizeIncludeBlobs = includeBlobs; 562 } 563 564 public boolean isCatalogAtStart() throws SQLException 565 { 566 return isCatalogAtStart; 567 } 568 569 public void setIsCatalogAtStart(boolean isCatalogAtStart) 570 { 571 this.isCatalogAtStart = isCatalogAtStart; 572 } 573 574 public boolean isReadOnly() throws SQLException 575 { 576 return isReadOnly; 577 } 578 579 public void setIsReadOnly(boolean isReadOnly) 580 { 581 this.isReadOnly = isReadOnly; 582 } 583 584 public boolean locatorsUpdateCopy() throws SQLException 585 { 586 return locatorsUpdateCopy; 587 } 588 589 public void setLocatorsUpdateCopy(boolean locatorsUpdateCopy) 590 { 591 this.locatorsUpdateCopy = locatorsUpdateCopy; 592 } 593 594 public boolean nullPlusNonNullIsNull() throws SQLException 595 { 596 return nullPlusNonNullIsNull; 597 } 598 599 public void setNullPlusNonNullIsNull(boolean nullPlusNonNullIsNull) 600 { 601 this.nullPlusNonNullIsNull = nullPlusNonNullIsNull; 602 } 603 604 public boolean nullsAreSortedAtEnd() throws SQLException 605 { 606 return nullsAreSortedAtEnd; 607 } 608 609 public void setNullsAreSortedAtEnd(boolean nullsAreSortedAtEnd) 610 { 611 this.nullsAreSortedAtEnd = nullsAreSortedAtEnd; 612 } 613 614 public boolean nullsAreSortedAtStart() throws SQLException 615 { 616 return nullsAreSortedAtStart; 617 } 618 619 public void setNullsAreSortedAtStart(boolean nullsAreSortedAtStart) 620 { 621 this.nullsAreSortedAtStart = nullsAreSortedAtStart; 622 } 623 624 public boolean nullsAreSortedHigh() throws SQLException 625 { 626 return nullsAreSortedHigh; 627 } 628 629 public void setNullsAreSortedHigh(boolean nullsAreSortedHigh) 630 { 631 this.nullsAreSortedHigh = nullsAreSortedHigh; 632 } 633 634 public boolean nullsAreSortedLow() throws SQLException 635 { 636 return nullsAreSortedLow; 637 } 638 639 public void setNullsAreSortedLow(boolean nullsAreSortedLow) 640 { 641 this.nullsAreSortedLow = nullsAreSortedLow; 642 } 643 644 public boolean storesLowerCaseIdentifiers() throws SQLException 645 { 646 return storesLowerCaseIdentifiers; 647 } 648 649 public void setStoresLowerCaseIdentifiers(boolean storesLowerCaseIdentifiers) 650 { 651 this.storesLowerCaseIdentifiers = storesLowerCaseIdentifiers; 652 } 653 654 public boolean storesLowerCaseQuotedIdentifiers() throws SQLException 655 { 656 return storesLowerCaseQuotedIdentifiers; 657 } 658 659 public void setStoresLowerCaseQuotedIdentifiers(boolean storesLowerCaseQuotedIdentifiers) 660 { 661 this.storesLowerCaseQuotedIdentifiers = storesLowerCaseQuotedIdentifiers; 662 } 663 664 public boolean storesMixedCaseIdentifiers() throws SQLException 665 { 666 return storesMixedCaseIdentifiers; 667 } 668 669 public void setStoresMixedCaseIdentifiers(boolean storesMixedCaseIdentifiers) 670 { 671 this.storesMixedCaseIdentifiers = storesMixedCaseIdentifiers; 672 } 673 674 public boolean storesMixedCaseQuotedIdentifiers() throws SQLException 675 { 676 return storesMixedCaseQuotedIdentifiers; 677 } 678 679 public void setStoresMixedCaseQuotedIdentifiers(boolean storesMixedCaseQuotedIdentifiers) 680 { 681 this.storesMixedCaseQuotedIdentifiers = storesMixedCaseQuotedIdentifiers; 682 } 683 684 public boolean storesUpperCaseIdentifiers() throws SQLException 685 { 686 return storesUpperCaseIdentifiers; 687 } 688 689 public void setStoresUpperCaseIdentifiers(boolean storesUpperCaseIdentifiers) 690 { 691 this.storesUpperCaseIdentifiers = storesUpperCaseIdentifiers; 692 } 693 694 public boolean storesUpperCaseQuotedIdentifiers() throws SQLException 695 { 696 return storesUpperCaseQuotedIdentifiers; 697 } 698 699 public void setStoresUpperCaseQuotedIdentifiers(boolean storesUpperCaseQuotedIdentifiers) 700 { 701 this.storesUpperCaseQuotedIdentifiers = storesUpperCaseQuotedIdentifiers; 702 } 703 704 public boolean supportsANSI92EntryLevelSQL() throws SQLException 705 { 706 return supportsANSI92EntryLevelSQL; 707 } 708 709 public void setSupportsANSI92EntryLevelSQL(boolean supportsANSI92EntryLevelSQL) 710 { 711 this.supportsANSI92EntryLevelSQL = supportsANSI92EntryLevelSQL; 712 } 713 714 public boolean supportsANSI92FullSQL() throws SQLException 715 { 716 return supportsANSI92FullSQL; 717 } 718 719 public void setSupportsANSI92FullSQL(boolean supportsANSI92FullSQL) 720 { 721 this.supportsANSI92FullSQL = supportsANSI92FullSQL; 722 } 723 724 public boolean supportsANSI92IntermediateSQL() throws SQLException 725 { 726 return supportsANSI92IntermediateSQL; 727 } 728 729 public void setSupportsANSI92IntermediateSQL(boolean supportsANSI92IntermediateSQL) 730 { 731 this.supportsANSI92IntermediateSQL = supportsANSI92IntermediateSQL; 732 } 733 734 public boolean supportsAlterTableWithAddColumn() throws SQLException 735 { 736 return supportsAlterTableWithAddColumn; 737 } 738 739 public void setSupportsAlterTableWithAddColumn(boolean supportsAlterTableWithAddColumn) 740 { 741 this.supportsAlterTableWithAddColumn = supportsAlterTableWithAddColumn; 742 } 743 744 public boolean supportsAlterTableWithDropColumn() throws SQLException 745 { 746 return supportsAlterTableWithDropColumn; 747 } 748 749 public void setSupportsAlterTableWithDropColumn(boolean supportsAlterTableWithDropColumn) 750 { 751 this.supportsAlterTableWithDropColumn = supportsAlterTableWithDropColumn; 752 } 753 754 public boolean supportsBatchUpdates() throws SQLException 755 { 756 return supportsBatchUpdates; 757 } 758 759 public void setSupportsBatchUpdates(boolean supportsBatchUpdates) 760 { 761 this.supportsBatchUpdates = supportsBatchUpdates; 762 } 763 764 public boolean supportsCatalogsInDataManipulation() throws SQLException 765 { 766 return supportsCatalogsInDataManipulation; 767 } 768 769 public void setSupportsCatalogsInDataManipulation(boolean supportsCatalogsInDataManipulation) 770 { 771 this.supportsCatalogsInDataManipulation = supportsCatalogsInDataManipulation; 772 } 773 774 public boolean supportsCatalogsInIndexDefinitions() throws SQLException 775 { 776 return supportsCatalogsInIndexDefinitions; 777 } 778 779 public void setSupportsCatalogsInIndexDefinitions(boolean supportsCatalogsInIndexDefinitions) 780 { 781 this.supportsCatalogsInIndexDefinitions = supportsCatalogsInIndexDefinitions; 782 } 783 784 public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException 785 { 786 return supportsCatalogsInPrivilegeDefinitions; 787 } 788 789 public void setSupportsCatalogsInPrivilegeDefinitions(boolean supportsCatalogsInPrivilegeDefinitions) 790 { 791 this.supportsCatalogsInPrivilegeDefinitions = supportsCatalogsInPrivilegeDefinitions; 792 } 793 794 public boolean supportsCatalogsInProcedureCalls() throws SQLException 795 { 796 return supportsCatalogsInProcedureCalls; 797 } 798 799 public void setSupportsCatalogsInProcedureCalls(boolean supportsCatalogsInProcedureCalls) 800 { 801 this.supportsCatalogsInProcedureCalls = supportsCatalogsInProcedureCalls; 802 } 803 804 public boolean supportsCatalogsInTableDefinitions() throws SQLException 805 { 806 return supportsCatalogsInTableDefinitions; 807 } 808 809 public void setSupportsCatalogsInTableDefinitions(boolean supportsCatalogsInTableDefinitions) 810 { 811 this.supportsCatalogsInTableDefinitions = supportsCatalogsInTableDefinitions; 812 } 813 814 public boolean supportsColumnAliasing() throws SQLException 815 { 816 return supportsColumnAliasing; 817 } 818 819 public void setSupportsColumnAliasing(boolean supportsColumnAliasing) 820 { 821 this.supportsColumnAliasing = supportsColumnAliasing; 822 } 823 824 public boolean supportsConvert() throws SQLException 825 { 826 return supportsConvert; 827 } 828 829 public void setSupportsConvert(boolean supportsConvert) 830 { 831 this.supportsConvert = supportsConvert; 832 } 833 834 public boolean supportsCoreSQLGrammar() throws SQLException 835 { 836 return supportsCoreSQLGrammar; 837 } 838 839 public void setSupportsCoreSQLGrammar(boolean supportsCoreSQLGrammar) 840 { 841 this.supportsCoreSQLGrammar = supportsCoreSQLGrammar; 842 } 843 844 public boolean supportsCorrelatedSubqueries() throws SQLException 845 { 846 return supportsCorrelatedSubqueries; 847 } 848 849 public void setSupportsCorrelatedSubqueries(boolean supportsCorrelatedSubqueries) 850 { 851 this.supportsCorrelatedSubqueries = supportsCorrelatedSubqueries; 852 } 853 854 public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException 855 { 856 return supportsDataDefinitionAndDataManipulationTransactions; 857 } 858 859 public void setSupportsDataDefinitionAndDataManipulationTransactions(boolean supportsDataDefinitionAndDataManipulationTransactions) 860 { 861 this.supportsDataDefinitionAndDataManipulationTransactions = supportsDataDefinitionAndDataManipulationTransactions; 862 } 863 864 public boolean supportsDataManipulationTransactionsOnly() throws SQLException 865 { 866 return supportsDataManipulationTransactionsOnly; 867 } 868 869 public void setSupportsDataManipulationTransactionsOnly(boolean supportsDataManipulationTransactionsOnly) 870 { 871 this.supportsDataManipulationTransactionsOnly = supportsDataManipulationTransactionsOnly; 872 } 873 874 public boolean supportsDifferentTableCorrelationNames() throws SQLException 875 { 876 return supportsDifferentTableCorrelationNames; 877 } 878 879 public void setSupportsDifferentTableCorrelationNames(boolean supportsDifferentTableCorrelationNames) 880 { 881 this.supportsDifferentTableCorrelationNames = supportsDifferentTableCorrelationNames; 882 } 883 884 public boolean supportsExpressionsInOrderBy() throws SQLException 885 { 886 return supportsExpressionsInOrderBy; 887 } 888 889 public void setSupportsExpressionsInOrderBy(boolean supportsExpressionsInOrderBy) 890 { 891 this.supportsExpressionsInOrderBy = supportsExpressionsInOrderBy; 892 } 893 894 public boolean supportsExtendedSQLGrammar() throws SQLException 895 { 896 return supportsExtendedSQLGrammar; 897 } 898 899 public void setSupportsExtendedSQLGrammar(boolean supportsExtendedSQLGrammar) 900 { 901 this.supportsExtendedSQLGrammar = supportsExtendedSQLGrammar; 902 } 903 904 public boolean supportsFullOuterJoins() throws SQLException 905 { 906 return supportsFullOuterJoins; 907 } 908 909 public void setSupportsFullOuterJoins(boolean supportsFullOuterJoins) 910 { 911 this.supportsFullOuterJoins = supportsFullOuterJoins; 912 } 913 914 public boolean supportsGetGeneratedKeys() throws SQLException 915 { 916 return supportsGetGeneratedKeys; 917 } 918 919 public void setSupportsGetGeneratedKeys(boolean supportsGetGeneratedKeys) 920 { 921 this.supportsGetGeneratedKeys = supportsGetGeneratedKeys; 922 } 923 924 public boolean supportsGroupBy() throws SQLException 925 { 926 return supportsGroupBy; 927 } 928 929 public void setSupportsGroupBy(boolean supportsGroupBy) 930 { 931 this.supportsGroupBy = supportsGroupBy; 932 } 933 934 public boolean supportsGroupByBeyondSelect() throws SQLException 935 { 936 return supportsGroupByBeyondSelect; 937 } 938 939 public void setSupportsGroupByBeyondSelect(boolean supportsGroupByBeyondSelect) 940 { 941 this.supportsGroupByBeyondSelect = supportsGroupByBeyondSelect; 942 } 943 944 public boolean supportsGroupByUnrelated() throws SQLException 945 { 946 return supportsGroupByUnrelated; 947 } 948 949 public void setSupportsGroupByUnrelated(boolean supportsGroupByUnrelated) 950 { 951 this.supportsGroupByUnrelated = supportsGroupByUnrelated; 952 } 953 954 public boolean supportsIntegrityEnhancementFacility() throws SQLException 955 { 956 return supportsIntegrityEnhancementFacility; 957 } 958 959 public void setSupportsIntegrityEnhancementFacility(boolean supportsIntegrityEnhancementFacility) 960 { 961 this.supportsIntegrityEnhancementFacility = supportsIntegrityEnhancementFacility; 962 } 963 964 public boolean supportsLikeEscapeClause() throws SQLException 965 { 966 return supportsLikeEscapeClause; 967 } 968 969 public void setSupportsLikeEscapeClause(boolean supportsLikeEscapeClause) 970 { 971 this.supportsLikeEscapeClause = supportsLikeEscapeClause; 972 } 973 974 public boolean supportsLimitedOuterJoins() throws SQLException 975 { 976 return supportsLimitedOuterJoins; 977 } 978 979 public void setSupportsLimitedOuterJoins(boolean supportsLimitedOuterJoins) 980 { 981 this.supportsLimitedOuterJoins = supportsLimitedOuterJoins; 982 } 983 984 public boolean supportsMinimumSQLGrammar() throws SQLException 985 { 986 return supportsMinimumSQLGrammar; 987 } 988 989 public void setSupportsMinimumSQLGrammar(boolean supportsMinimumSQLGrammar) 990 { 991 this.supportsMinimumSQLGrammar = supportsMinimumSQLGrammar; 992 } 993 994 public boolean supportsMixedCaseIdentifiers() throws SQLException 995 { 996 return supportsMixedCaseIdentifiers; 997 } 998 999 public void setSupportsMixedCaseIdentifiers(boolean supportsMixedCaseIdentifiers) 1000 { 1001 this.supportsMixedCaseIdentifiers = supportsMixedCaseIdentifiers; 1002 } 1003 1004 public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException 1005 { 1006 return supportsMixedCaseQuotedIdentifiers; 1007 } 1008 1009 public void setSupportsMixedCaseQuotedIdentifiers(boolean supportsMixedCaseQuotedIdentifiers) 1010 { 1011 this.supportsMixedCaseQuotedIdentifiers = supportsMixedCaseQuotedIdentifiers; 1012 } 1013 1014 public boolean supportsMultipleOpenResults() throws SQLException 1015 { 1016 return supportsMultipleOpenResults; 1017 } 1018 1019 public void setSupportsMultipleOpenResults(boolean supportsMultipleOpenResults) 1020 { 1021 this.supportsMultipleOpenResults = supportsMultipleOpenResults; 1022 } 1023 1024 public boolean supportsMultipleResultSets() throws SQLException 1025 { 1026 return supportsMultipleResultSets; 1027 } 1028 1029 public void setSupportsMultipleResultSets(boolean supportsMultipleResultSets) 1030 { 1031 this.supportsMultipleResultSets = supportsMultipleResultSets; 1032 } 1033 1034 public boolean supportsMultipleTransactions() throws SQLException 1035 { 1036 return supportsMultipleTransactions; 1037 } 1038 1039 public void setSupportsMultipleTransactions(boolean supportsMultipleTransactions) 1040 { 1041 this.supportsMultipleTransactions = supportsMultipleTransactions; 1042 } 1043 1044 public boolean supportsNamedParameters() throws SQLException 1045 { 1046 return supportsNamedParameters; 1047 } 1048 1049 public void setSupportsNamedParameters(boolean supportsNamedParameters) 1050 { 1051 this.supportsNamedParameters = supportsNamedParameters; 1052 } 1053 1054 public boolean supportsNonNullableColumns() throws SQLException 1055 { 1056 return supportsNonNullableColumns; 1057 } 1058 1059 public void setSupportsNonNullableColumns(boolean supportsNonNullableColumns) 1060 { 1061 this.supportsNonNullableColumns = supportsNonNullableColumns; 1062 } 1063 1064 public boolean supportsOpenCursorsAcrossCommit() throws SQLException 1065 { 1066 return supportsOpenCursorsAcrossCommit; 1067 } 1068 1069 public void setSupportsOpenCursorsAcrossCommit(boolean supportsOpenCursorsAcrossCommit) 1070 { 1071 this.supportsOpenCursorsAcrossCommit = supportsOpenCursorsAcrossCommit; 1072 } 1073 1074 public boolean supportsOpenCursorsAcrossRollback() throws SQLException 1075 { 1076 return supportsOpenCursorsAcrossRollback; 1077 } 1078 1079 public void setSupportsOpenCursorsAcrossRollback(boolean supportsOpenCursorsAcrossRollback) 1080 { 1081 this.supportsOpenCursorsAcrossRollback = supportsOpenCursorsAcrossRollback; 1082 } 1083 1084 public boolean supportsOpenStatementsAcrossCommit() throws SQLException 1085 { 1086 return supportsOpenStatementsAcrossCommit; 1087 } 1088 1089 public void setSupportsOpenStatementsAcrossCommit(boolean supportsOpenStatementsAcrossCommit) 1090 { 1091 this.supportsOpenStatementsAcrossCommit = supportsOpenStatementsAcrossCommit; 1092 } 1093 1094 public boolean supportsOpenStatementsAcrossRollback() throws SQLException 1095 { 1096 return supportsOpenStatementsAcrossRollback; 1097 } 1098 1099 public void setSupportsOpenStatementsAcrossRollback(boolean supportsOpenStatementsAcrossRollback) 1100 { 1101 this.supportsOpenStatementsAcrossRollback = supportsOpenStatementsAcrossRollback; 1102 } 1103 1104 public boolean supportsOrderByUnrelated() throws SQLException 1105 { 1106 return supportsOrderByUnrelated; 1107 } 1108 1109 public void setSupportsOrderByUnrelated(boolean supportsOrderByUnrelated) 1110 { 1111 this.supportsOrderByUnrelated = supportsOrderByUnrelated; 1112 } 1113 1114 public boolean supportsOuterJoins() throws SQLException 1115 { 1116 return supportsOuterJoins; 1117 } 1118 1119 public void setSupportsOuterJoins(boolean supportsOuterJoins) 1120 { 1121 this.supportsOuterJoins = supportsOuterJoins; 1122 } 1123 1124 public boolean supportsPositionedDelete() throws SQLException 1125 { 1126 return supportsPositionedDelete; 1127 } 1128 1129 public void setSupportsPositionedDelete(boolean supportsPositionedDelete) 1130 { 1131 this.supportsPositionedDelete = supportsPositionedDelete; 1132 } 1133 1134 public boolean supportsPositionedUpdate() throws SQLException 1135 { 1136 return supportsPositionedUpdate; 1137 } 1138 1139 public void setSupportsPositionedUpdate(boolean supportsPositionedUpdate) 1140 { 1141 this.supportsPositionedUpdate = supportsPositionedUpdate; 1142 } 1143 1144 public boolean supportsSavepoints() throws SQLException 1145 { 1146 return supportsSavepoints; 1147 } 1148 1149 public void setSupportsSavepoints(boolean supportsSavepoints) 1150 { 1151 this.supportsSavepoints = supportsSavepoints; 1152 } 1153 1154 public boolean supportsSchemasInDataManipulation() throws SQLException 1155 { 1156 return supportsSchemasInDataManipulation; 1157 } 1158 1159 public void setSupportsSchemasInDataManipulation(boolean supportsSchemasInDataManipulation) 1160 { 1161 this.supportsSchemasInDataManipulation = supportsSchemasInDataManipulation; 1162 } 1163 1164 public boolean supportsSchemasInIndexDefinitions() throws SQLException 1165 { 1166 return supportsSchemasInIndexDefinitions; 1167 } 1168 1169 public void setSupportsSchemasInIndexDefinitions(boolean supportsSchemasInIndexDefinitions) 1170 { 1171 this.supportsSchemasInIndexDefinitions = supportsSchemasInIndexDefinitions; 1172 } 1173 1174 public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException 1175 { 1176 return supportsSchemasInPrivilegeDefinitions; 1177 } 1178 1179 public void setSupportsSchemasInPrivilegeDefinitions(boolean supportsSchemasInPrivilegeDefinitions) 1180 { 1181 this.supportsSchemasInPrivilegeDefinitions = supportsSchemasInPrivilegeDefinitions; 1182 } 1183 1184 public boolean supportsSchemasInProcedureCalls() throws SQLException 1185 { 1186 return supportsSchemasInProcedureCalls; 1187 } 1188 1189 public void setSupportsSchemasInProcedureCalls(boolean supportsSchemasInProcedureCalls) 1190 { 1191 this.supportsSchemasInProcedureCalls = supportsSchemasInProcedureCalls; 1192 } 1193 1194 public boolean supportsSchemasInTableDefinitions() throws SQLException 1195 { 1196 return supportsSchemasInTableDefinitions; 1197 } 1198 1199 public void setSupportsSchemasInTableDefinitions(boolean supportsSchemasInTableDefinitions) 1200 { 1201 this.supportsSchemasInTableDefinitions = supportsSchemasInTableDefinitions; 1202 } 1203 1204 public boolean supportsSelectForUpdate() throws SQLException 1205 { 1206 return supportsSelectForUpdate; 1207 } 1208 1209 public void setSupportsSelectForUpdate(boolean supportsSelectForUpdate) 1210 { 1211 this.supportsSelectForUpdate = supportsSelectForUpdate; 1212 } 1213 1214 public boolean supportsStatementPooling() throws SQLException 1215 { 1216 return supportsStatementPooling; 1217 } 1218 1219 public void setSupportsStatementPooling(boolean supportsStatementPooling) 1220 { 1221 this.supportsStatementPooling = supportsStatementPooling; 1222 } 1223 1224 public boolean supportsStoredProcedures() throws SQLException 1225 { 1226 return supportsStoredProcedures; 1227 } 1228 1229 public void setSupportsStoredProcedures(boolean supportsStoredProcedures) 1230 { 1231 this.supportsStoredProcedures = supportsStoredProcedures; 1232 } 1233 1234 public boolean supportsSubqueriesInComparisons() throws SQLException 1235 { 1236 return supportsSubqueriesInComparisons; 1237 } 1238 1239 public void setSupportsSubqueriesInComparisons(boolean supportsSubqueriesInComparisons) 1240 { 1241 this.supportsSubqueriesInComparisons = supportsSubqueriesInComparisons; 1242 } 1243 1244 public boolean supportsSubqueriesInExists() throws SQLException 1245 { 1246 return supportsSubqueriesInExists; 1247 } 1248 1249 public void setSupportsSubqueriesInExists(boolean supportsSubqueriesInExists) 1250 { 1251 this.supportsSubqueriesInExists = supportsSubqueriesInExists; 1252 } 1253 1254 public boolean supportsSubqueriesInIns() throws SQLException 1255 { 1256 return supportsSubqueriesInIns; 1257 } 1258 1259 public void setSupportsSubqueriesInIns(boolean supportsSubqueriesInIns) 1260 { 1261 this.supportsSubqueriesInIns = supportsSubqueriesInIns; 1262 } 1263 1264 public boolean supportsSubqueriesInQuantifieds() throws SQLException 1265 { 1266 return supportsSubqueriesInQuantifieds; 1267 } 1268 1269 public void setSupportsSubqueriesInQuantifieds(boolean supportsSubqueriesInQuantifieds) 1270 { 1271 this.supportsSubqueriesInQuantifieds = supportsSubqueriesInQuantifieds; 1272 } 1273 1274 public boolean supportsTableCorrelationNames() throws SQLException 1275 { 1276 return supportsTableCorrelationNames; 1277 } 1278 1279 public void setSupportsTableCorrelationNames(boolean supportsTableCorrelationNames) 1280 { 1281 this.supportsTableCorrelationNames = supportsTableCorrelationNames; 1282 } 1283 1284 public boolean supportsTransactions() throws SQLException 1285 { 1286 return supportsTransactions; 1287 } 1288 1289 public void setSupportsTransactions(boolean supportsTransactions) 1290 { 1291 this.supportsTransactions = supportsTransactions; 1292 } 1293 1294 public boolean supportsUnion() throws SQLException 1295 { 1296 return supportsUnion; 1297 } 1298 1299 public void setSupportsUnion(boolean supportsUnion) 1300 { 1301 this.supportsUnion = supportsUnion; 1302 } 1303 1304 public boolean supportsUnionAll() throws SQLException 1305 { 1306 return supportsUnionAll; 1307 } 1308 1309 public void setSupportsUnionAll(boolean supportsUnionAll) 1310 { 1311 this.supportsUnionAll = supportsUnionAll; 1312 } 1313 1314 public boolean usesLocalFilePerTable() throws SQLException 1315 { 1316 return usesLocalFilePerTable; 1317 } 1318 1319 public void setUsesLocalFilePerTable(boolean usesLocalFilePerTable) 1320 { 1321 this.usesLocalFilePerTable = usesLocalFilePerTable; 1322 } 1323 1324 public boolean usesLocalFiles() throws SQLException 1325 { 1326 return usesLocalFiles; 1327 } 1328 1329 public void setUsesLocalFiles(boolean usesLocalFiles) 1330 { 1331 this.usesLocalFiles = usesLocalFiles; 1332 } 1333 1334 public boolean deletesAreDetected(int type) throws SQLException 1335 { 1336 return deletesAreDetected; 1337 } 1338 1339 public void setDeletesAreDetected(boolean deletesAreDetected) 1340 { 1341 this.deletesAreDetected = deletesAreDetected; 1342 } 1343 1344 public boolean insertsAreDetected(int type) throws SQLException 1345 { 1346 return insertsAreDetected; 1347 } 1348 1349 public void setInsertsAreDetected(boolean insertsAreDetected) 1350 { 1351 this.insertsAreDetected = insertsAreDetected; 1352 } 1353 1354 public boolean othersDeletesAreVisible(int type) throws SQLException 1355 { 1356 return othersDeletesAreVisible; 1357 } 1358 1359 public void setOthersDeletesAreVisible(boolean othersDeletesAreVisible) 1360 { 1361 this.othersDeletesAreVisible = othersDeletesAreVisible; 1362 } 1363 1364 public boolean othersInsertsAreVisible(int type) throws SQLException 1365 { 1366 return othersInsertsAreVisible; 1367 } 1368 1369 public void setOthersInsertsAreVisible(boolean othersInsertsAreVisible) 1370 { 1371 this.othersInsertsAreVisible = othersInsertsAreVisible; 1372 } 1373 1374 public boolean othersUpdatesAreVisible(int type) throws SQLException 1375 { 1376 return othersUpdatesAreVisible; 1377 } 1378 1379 public void setOthersUpdatesAreVisible(boolean othersUpdatesAreVisible) 1380 { 1381 this.othersUpdatesAreVisible = othersUpdatesAreVisible; 1382 } 1383 1384 public boolean ownDeletesAreVisible(int type) throws SQLException 1385 { 1386 return ownDeletesAreVisible; 1387 } 1388 1389 public void setOwnDeletesAreVisible(boolean ownDeletesAreVisible) 1390 { 1391 this.ownDeletesAreVisible = ownDeletesAreVisible; 1392 } 1393 1394 public boolean ownInsertsAreVisible(int type) throws SQLException 1395 { 1396 return ownInsertsAreVisible; 1397 } 1398 1399 public void setOwnInsertsAreVisible(boolean ownInsertsAreVisible) 1400 { 1401 this.ownInsertsAreVisible = ownInsertsAreVisible; 1402 } 1403 1404 public boolean ownUpdatesAreVisible(int type) throws SQLException 1405 { 1406 return ownUpdatesAreVisible; 1407 } 1408 1409 public void setOwnUpdatesAreVisible(boolean ownUpdatesAreVisible) 1410 { 1411 this.ownUpdatesAreVisible = ownUpdatesAreVisible; 1412 } 1413 1414 public boolean supportsResultSetHoldability(int holdability) throws SQLException 1415 { 1416 return supportsResultSetHoldability; 1417 } 1418 1419 public void setSupportsResultSetHoldability(boolean supportsResultSetHoldability) 1420 { 1421 this.supportsResultSetHoldability = supportsResultSetHoldability; 1422 } 1423 1424 public boolean supportsResultSetType(int type) throws SQLException 1425 { 1426 return supportsResultSetType; 1427 } 1428 1429 public void setSupportsResultSetType(boolean supportsResultSetType) 1430 { 1431 this.supportsResultSetType = supportsResultSetType; 1432 } 1433 1434 public boolean supportsTransactionIsolationLevel(int level) throws SQLException 1435 { 1436 return supportsTransactionIsolationLevel; 1437 } 1438 1439 public void setSupportsTransactionIsolationLevel(boolean supportsTransactionIsolationLevel) 1440 { 1441 this.supportsTransactionIsolationLevel = supportsTransactionIsolationLevel; 1442 } 1443 1444 public boolean updatesAreDetected(int type) throws SQLException 1445 { 1446 return updatesAreDetected; 1447 } 1448 1449 public void setUpdatesAreDetected(boolean updatesAreDetected) 1450 { 1451 this.updatesAreDetected = updatesAreDetected; 1452 } 1453 1454 public boolean supportsConvert(int fromType, int toType) throws SQLException 1455 { 1456 return supportsConvert; 1457 } 1458 1459 public boolean supportsResultSetConcurrency(int type, int concurrency) throws SQLException 1460 { 1461 return supportsResultSetConcurrency; 1462 } 1463 1464 public void setSupportsResultSetConcurrency(boolean supportsResultSetConcurrency) 1465 { 1466 this.supportsResultSetConcurrency = supportsResultSetConcurrency; 1467 } 1468 1469 public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException 1470 { 1471 return supportsStoredFunctionsUsingCallSyntax; 1472 } 1473 1474 public void setSupportsStoredFunctionsUsingCallSyntax(boolean supportsStoredFunctions) 1475 { 1476 supportsStoredFunctionsUsingCallSyntax = supportsStoredFunctions; 1477 } 1478 1479 public String getCatalogSeparator() throws SQLException 1480 { 1481 return catalogSeparator; 1482 } 1483 1484 public void setCatalogSeparator(String catalogSeparator) 1485 { 1486 this.catalogSeparator = catalogSeparator; 1487 } 1488 1489 public String getCatalogTerm() throws SQLException 1490 { 1491 return catalogTerm; 1492 } 1493 1494 public void setCatalogTerm(String catalogTerm) 1495 { 1496 this.catalogTerm = catalogTerm; 1497 } 1498 1499 public String getDatabaseProductName() throws SQLException 1500 { 1501 return databaseProductName; 1502 } 1503 1504 public void setDatabaseProductName(String databaseProductName) 1505 { 1506 this.databaseProductName = databaseProductName; 1507 } 1508 1509 public String getDatabaseProductVersion() throws SQLException 1510 { 1511 return databaseProductVersion; 1512 } 1513 1514 public void setDatabaseProductVersion(String databaseProductVersion) 1515 { 1516 this.databaseProductVersion = databaseProductVersion; 1517 } 1518 1519 public String getDriverName() throws SQLException 1520 { 1521 return driverName; 1522 } 1523 1524 public void setDriverName(String driverName) 1525 { 1526 this.driverName = driverName; 1527 } 1528 1529 public String getDriverVersion() throws SQLException 1530 { 1531 return driverVersion; 1532 } 1533 1534 public void setDriverVersion(String driverVersion) 1535 { 1536 this.driverVersion = driverVersion; 1537 } 1538 1539 public String getExtraNameCharacters() throws SQLException 1540 { 1541 return extraNameCharacters; 1542 } 1543 1544 public void setExtraNameCharacters(String extraNameCharacters) 1545 { 1546 this.extraNameCharacters = extraNameCharacters; 1547 } 1548 1549 public String getIdentifierQuoteString() throws SQLException 1550 { 1551 return identifierQuoteString; 1552 } 1553 1554 public void setIdentifierQuoteString(String identifierQuoteString) 1555 { 1556 this.identifierQuoteString = identifierQuoteString; 1557 } 1558 1559 public String getNumericFunctions() throws SQLException 1560 { 1561 return numericFunctions; 1562 } 1563 1564 public void setNumericFunctions(String numericFunctions) 1565 { 1566 this.numericFunctions = numericFunctions; 1567 } 1568 1569 public String getProcedureTerm() throws SQLException 1570 { 1571 return procedureTerm; 1572 } 1573 1574 public void setProcedureTerm(String procedureTerm) 1575 { 1576 this.procedureTerm = procedureTerm; 1577 } 1578 1579 public String getSQLKeywords() throws SQLException 1580 { 1581 return sqlKeywords; 1582 } 1583 1584 public void setSQLKeywords(String sqlKeywords) 1585 { 1586 this.sqlKeywords = sqlKeywords; 1587 } 1588 1589 public String getSchemaTerm() throws SQLException 1590 { 1591 return schemaTerm; 1592 } 1593 1594 public void setSchemaTerm(String schemaTerm) 1595 { 1596 this.schemaTerm = schemaTerm; 1597 } 1598 1599 public String getSearchStringEscape() throws SQLException 1600 { 1601 return searchStringEscape; 1602 } 1603 1604 public void setSearchStringEscape(String searchStringEscape) 1605 { 1606 this.searchStringEscape = searchStringEscape; 1607 } 1608 1609 public String getStringFunctions() throws SQLException 1610 { 1611 return stringFunctions; 1612 } 1613 1614 public void setStringFunctions(String stringFunctions) 1615 { 1616 this.stringFunctions = stringFunctions; 1617 } 1618 1619 public String getSystemFunctions() throws SQLException 1620 { 1621 return systemFunctions; 1622 } 1623 1624 public void setSystemFunctions(String systemFunctions) 1625 { 1626 this.systemFunctions = systemFunctions; 1627 } 1628 1629 public String getTimeDateFunctions() throws SQLException 1630 { 1631 return timeDateFunctions; 1632 } 1633 1634 public void setTimeDateFunctions(String timeDateFunctions) 1635 { 1636 this.timeDateFunctions = timeDateFunctions; 1637 } 1638 1639 public String getURL() throws SQLException 1640 { 1641 return url; 1642 } 1643 1644 public void setURL(String url) 1645 { 1646 this.url = url; 1647 } 1648 1649 public String getUserName() throws SQLException 1650 { 1651 return userName; 1652 } 1653 1654 public void setUserName(String userName) 1655 { 1656 this.userName = userName; 1657 } 1658 1659 public Connection getConnection() throws SQLException 1660 { 1661 return connection; 1662 } 1663 1664 public void setConnection(Connection connection) 1665 { 1666 this.connection = connection; 1667 } 1668 1669 public ResultSet getCatalogs() throws SQLException 1670 { 1671 return catalogs; 1672 } 1673 1674 public void setCatalogs(ResultSet catalogs) 1675 { 1676 this.catalogs = catalogs; 1677 } 1678 1679 public ResultSet getSchemas() throws SQLException 1680 { 1681 return getAll(schemasMap); 1682 } 1683 1684 public ResultSet getSchemas(String catalog, String schemaPattern) throws SQLException 1685 { 1686 DatabaseIdentifier expected = new DatabaseIdentifierImpl(catalog, schemaPattern, "", true, false); 1687 return findMatchingDatabaseIdentifier(expected, schemasMap); 1688 } 1689 1690 public void setSchemas(ResultSet schemas) 1691 { 1692 schemasMap.put(new DatabaseIdentifierImpl(), schemas); 1693 } 1694 1695 public void setSchemas(String catalog, String schemaPattern, ResultSet schemas) 1696 { 1697 schemasMap.put(new DatabaseIdentifierImpl(catalog, schemaPattern, ""), schemas); 1698 } 1699 1700 public void clearSchemas() 1701 { 1702 schemasMap.clear(); 1703 } 1704 1705 public ResultSet getTableTypes() throws SQLException 1706 { 1707 return tableTypes; 1708 } 1709 1710 public void setTableTypes(ResultSet tableTypes) 1711 { 1712 this.tableTypes = tableTypes; 1713 } 1714 1715 public ResultSet getTypeInfo() throws SQLException 1716 { 1717 return typeInfo; 1718 } 1719 1720 public void setTypeInfo(ResultSet typeInfo) 1721 { 1722 this.typeInfo = typeInfo; 1723 } 1724 1725 public ResultSet getClientInfoProperties() throws SQLException 1726 { 1727 return clientInfoProperties; 1728 } 1729 1730 public void setClientInfoProperties(ResultSet clientInfoProperties) 1731 { 1732 this.clientInfoProperties = clientInfoProperties; 1733 } 1734 1735 public ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException 1736 { 1737 DatabaseIdentifier expected = new DatabaseIdentifierImpl(catalog, schema, table); 1738 return findMatchingDatabaseIdentifier(expected, exportedKeysMap); 1739 } 1740 1741 public void setExportedKeys(ResultSet exportedKeys) 1742 { 1743 exportedKeysMap.put(new DatabaseIdentifierImpl(), exportedKeys); 1744 } 1745 1746 public void setExportedKeys(String catalog, String schema, String table, ResultSet exportedKeys) 1747 { 1748 exportedKeysMap.put(new DatabaseIdentifierImpl(catalog, schema, table), exportedKeys); 1749 } 1750 1751 public void clearExportedKeys() 1752 { 1753 exportedKeysMap.clear(); 1754 } 1755 1756 public ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException 1757 { 1758 DatabaseIdentifier expected = new DatabaseIdentifierImpl(catalog, schema, table); 1759 return findMatchingDatabaseIdentifier(expected, importedKeysMap); 1760 } 1761 1762 public void setImportedKeys(ResultSet importedKeys) 1763 { 1764 importedKeysMap.put(new DatabaseIdentifierImpl(), importedKeys); 1765 } 1766 1767 public void setImportedKeys(String catalog, String schema, String table, ResultSet importedKeys) 1768 { 1769 importedKeysMap.put(new DatabaseIdentifierImpl(catalog, schema, table), importedKeys); 1770 } 1771 1772 public void clearImportedKeys() 1773 { 1774 importedKeysMap.clear(); 1775 } 1776 1777 public ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException 1778 { 1779 DatabaseIdentifier expected = new DatabaseIdentifierImpl(catalog, schema, table); 1780 return findMatchingDatabaseIdentifier(expected, primaryKeysMap); 1781 } 1782 1783 public void setPrimaryKeys(ResultSet primaryKeys) 1784 { 1785 primaryKeysMap.put(new DatabaseIdentifierImpl(), primaryKeys); 1786 } 1787 1788 public void setPrimaryKeys(String catalog, String schema, String table, ResultSet primaryKeys) 1789 { 1790 primaryKeysMap.put(new DatabaseIdentifierImpl(catalog, schema, table), primaryKeys); 1791 } 1792 1793 public void clearPrimaryKeys() 1794 { 1795 primaryKeysMap.clear(); 1796 } 1797 1798 public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException 1799 { 1800 DatabaseIdentifier expected = new DatabaseIdentifierImpl(catalog, schemaPattern, procedureNamePattern, true, true); 1801 return findMatchingDatabaseIdentifier(expected, proceduresMap); 1802 } 1803 1804 public void setProcedures(ResultSet procedures) 1805 { 1806 proceduresMap.put(new DatabaseIdentifierImpl(), procedures); 1807 } 1808 1809 public void setProcedures(String catalog, String schemaPattern, String procedureNamePattern, ResultSet procedures) 1810 { 1811 proceduresMap.put(new DatabaseIdentifierImpl(catalog, schemaPattern, procedureNamePattern), procedures); 1812 } 1813 1814 public void clearProcedures() 1815 { 1816 proceduresMap.clear(); 1817 } 1818 1819 public ResultSet getFunctions(String catalog, String schemaPattern, String functionNamePattern) throws SQLException 1820 { 1821 DatabaseIdentifier expected = new DatabaseIdentifierImpl(catalog, schemaPattern, functionNamePattern, true, true); 1822 return findMatchingDatabaseIdentifier(expected, functionsMap); 1823 } 1824 1825 public void setFunctions(ResultSet functions) 1826 { 1827 functionsMap.put(new DatabaseIdentifierImpl(), functions); 1828 } 1829 1830 public void setFunctions(String catalog, String schemaPattern, String functionNamePattern, ResultSet functions) 1831 { 1832 functionsMap.put(new DatabaseIdentifierImpl(catalog, schemaPattern, functionNamePattern), functions); 1833 } 1834 1835 public void clearFunctions() 1836 { 1837 functionsMap.clear(); 1838 } 1839 1840 public ResultSet getSuperTables(String catalog, String schemaPattern, String tableNamePattern) throws SQLException 1841 { 1842 DatabaseIdentifier expected = new DatabaseIdentifierImpl(catalog, schemaPattern, tableNamePattern, true, true); 1843 return findMatchingDatabaseIdentifier(expected, superTablesMap); 1844 } 1845 1846 public void setSuperTables(ResultSet superTables) 1847 { 1848 superTablesMap.put(new DatabaseIdentifierImpl(), superTables); 1849 } 1850 1851 public void setSuperTables(String catalog, String schemaPattern, String tableName, ResultSet superTables) 1852 { 1853 superTablesMap.put(new DatabaseIdentifierImpl(catalog, schemaPattern, tableName), superTables); 1854 } 1855 1856 public void clearSuperTables() 1857 { 1858 superTablesMap.clear(); 1859 } 1860 1861 public ResultSet getSuperTypes(String catalog, String schemaPattern, String typeNamePattern) throws SQLException 1862 { 1863 DatabaseIdentifier expected = new DatabaseIdentifierImpl(catalog, schemaPattern, typeNamePattern, true, true); 1864 return findMatchingDatabaseIdentifier(expected, superTypesMap); 1865 } 1866 1867 public void setSuperTypes(ResultSet superTypes) 1868 { 1869 superTypesMap.put(new DatabaseIdentifierImpl(), superTypes); 1870 } 1871 1872 public void setSuperTypes(String catalog, String schemaPattern, String typeNamePattern, ResultSet superTypes) 1873 { 1874 superTypesMap.put(new DatabaseIdentifierImpl(catalog, schemaPattern, typeNamePattern), superTypes); 1875 } 1876 1877 public void clearSuperTypes() 1878 { 1879 superTypesMap.clear(); 1880 } 1881 1882 public ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern) throws SQLException 1883 { 1884 DatabaseIdentifier expected = new DatabaseIdentifierImpl(catalog, schemaPattern, tableNamePattern, true, true); 1885 return findMatchingDatabaseIdentifier(expected, tablePrivilegesMap); 1886 } 1887 1888 public void setTablePrivileges(ResultSet tablePrivileges) 1889 { 1890 tablePrivilegesMap.put(new DatabaseIdentifierImpl(), tablePrivileges); 1891 } 1892 1893 public void setTablePrivileges(String catalog, String schemaPattern, String tableNamePattern, ResultSet tablePrivileges) 1894 { 1895 tablePrivilegesMap.put(new DatabaseIdentifierImpl(catalog, schemaPattern, tableNamePattern), tablePrivileges); 1896 } 1897 1898 public void clearTablePrivileges() 1899 { 1900 tablePrivilegesMap.clear(); 1901 } 1902 1903 public ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException 1904 { 1905 DatabaseIdentifier expected = new DatabaseIdentifierImpl(catalog, schema, table); 1906 return findMatchingDatabaseIdentifier(expected, versionColumnsMap); 1907 } 1908 1909 public void setVersionColumns(ResultSet versionColumns) 1910 { 1911 versionColumnsMap.put(new DatabaseIdentifierImpl(), versionColumns); 1912 } 1913 1914 public void setVersionColumns(String catalog, String schema, String table, ResultSet versionColumns) 1915 { 1916 versionColumnsMap.put(new DatabaseIdentifierImpl(catalog, schema, table), versionColumns); 1917 } 1918 1919 public void clearVersionColumns() 1920 { 1921 versionColumnsMap.clear(); 1922 } 1923 1924 public ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable) throws SQLException 1925 { 1926 DatabaseIdentifier expected = new RowIdentifierDatabaseIdentifierImpl(catalog, schema, table, scope, nullable); 1927 return findMatchingDatabaseIdentifier(expected, bestRowIdentifierMap); 1928 } 1929 1930 public void setBestRowIdentifier(ResultSet bestRowIdentifier) 1931 { 1932 bestRowIdentifierMap.put(new RowIdentifierDatabaseIdentifierImpl(), bestRowIdentifier); 1933 } 1934 1935 public void setBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable, ResultSet bestRowIdentifier) 1936 { 1937 bestRowIdentifierMap.put(new RowIdentifierDatabaseIdentifierImpl(catalog, schema, table, scope, nullable), bestRowIdentifier); 1938 } 1939 1940 public void clearBestRowIdentifier() 1941 { 1942 bestRowIdentifierMap.clear(); 1943 } 1944 1945 public ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate) throws SQLException 1946 { 1947 DatabaseIdentifier expected = new IndexInfoDatabaseIdentifierImpl(catalog, schema, table, unique, approximate); 1948 return findMatchingDatabaseIdentifier(expected, indexInfoMap); 1949 } 1950 1951 public void setIndexInfo(ResultSet indexInfo) 1952 { 1953 indexInfoMap.put(new IndexInfoDatabaseIdentifierImpl(), indexInfo); 1954 } 1955 1956 public void setIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate, ResultSet indexInfo) 1957 { 1958 indexInfoMap.put(new IndexInfoDatabaseIdentifierImpl(catalog, schema, table, unique, approximate), indexInfo); 1959 } 1960 1961 public void clearIndexInfo() 1962 { 1963 indexInfoMap.clear(); 1964 } 1965 1966 public ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types) throws SQLException 1967 { 1968 DatabaseIdentifier expected = new UDTDatabaseIdentifierImpl(catalog, schemaPattern, typeNamePattern, true, true, types); 1969 return findMatchingDatabaseIdentifier(expected, udtsMap); 1970 } 1971 1972 public void setUDTs(ResultSet udts) 1973 { 1974 udtsMap.put(new UDTDatabaseIdentifierImpl(), udts); 1975 } 1976 1977 public void setUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types, ResultSet udts) 1978 { 1979 udtsMap.put(new UDTDatabaseIdentifierImpl(catalog, schemaPattern, typeNamePattern, types), udts); 1980 } 1981 1982 public void clearUDTs() 1983 { 1984 udtsMap.clear(); 1985 } 1986 1987 public ResultSet getAttributes(String catalog, String schemaPattern, String typeNamePattern, String attributeNamePattern) throws SQLException 1988 { 1989 DatabaseIdentifier expected = new AttributesDatabaseIdentifierImpl(catalog, schemaPattern, typeNamePattern, true, true, attributeNamePattern); 1990 return findMatchingDatabaseIdentifier(expected, attributesMap); 1991 } 1992 1993 public void setAttributes(ResultSet attributes) 1994 { 1995 attributesMap.put(new AttributesDatabaseIdentifierImpl(), attributes); 1996 } 1997 1998 public void setAttributes(String catalog, String schemaPattern, String typeNamePattern, String attributeNamePattern, ResultSet attributes) 1999 { 2000 attributesMap.put(new AttributesDatabaseIdentifierImpl(catalog, schemaPattern, typeNamePattern, attributeNamePattern), attributes); 2001 } 2002 2003 public void clearAttributes() 2004 { 2005 attributesMap.clear(); 2006 } 2007 2008 public ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern) throws SQLException 2009 { 2010 DatabaseIdentifier expected = new ColumnDatabaseIdentifierImpl(catalog, schema, table, columnNamePattern); 2011 return findMatchingDatabaseIdentifier(expected, columnPrivilegesMap); 2012 } 2013 2014 public void setColumnPrivileges(ResultSet columnPrivileges) 2015 { 2016 columnPrivilegesMap.put(new ColumnDatabaseIdentifierImpl(), columnPrivileges); 2017 } 2018 2019 public void setColumnPrivileges(String catalog, String schema, String table, String columnNamePattern, ResultSet columnPrivileges) 2020 { 2021 columnPrivilegesMap.put(new ColumnDatabaseIdentifierImpl(catalog, schema, table, columnNamePattern), columnPrivileges); 2022 } 2023 2024 public void clearColumnPrivileges() 2025 { 2026 columnPrivilegesMap.clear(); 2027 } 2028 2029 public ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException 2030 { 2031 DatabaseIdentifier expected = new ColumnDatabaseIdentifierImpl(catalog, schemaPattern, tableNamePattern, true, true, columnNamePattern); 2032 return findMatchingDatabaseIdentifier(expected, columnsMap); 2033 } 2034 2035 public void setColumns(ResultSet columns) 2036 { 2037 columnsMap.put(new ColumnDatabaseIdentifierImpl(), columns); 2038 } 2039 2040 public void setColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern, ResultSet columns) 2041 { 2042 columnsMap.put(new ColumnDatabaseIdentifierImpl(catalog, schemaPattern, tableNamePattern, columnNamePattern), columns); 2043 } 2044 2045 public void clearColumns() 2046 { 2047 columnsMap.clear(); 2048 } 2049 2050 public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException 2051 { 2052 DatabaseIdentifier expected = new ColumnDatabaseIdentifierImpl(catalog, schemaPattern, procedureNamePattern, true, true, columnNamePattern); 2053 return findMatchingDatabaseIdentifier(expected, procedureColumnsMap); 2054 } 2055 2056 public void setProcedureColumns(ResultSet procedureColumns) 2057 { 2058 procedureColumnsMap.put(new ColumnDatabaseIdentifierImpl(), procedureColumns); 2059 } 2060 2061 public void setProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern, ResultSet procedureColumns) 2062 { 2063 procedureColumnsMap.put(new ColumnDatabaseIdentifierImpl(catalog, schemaPattern, procedureNamePattern, columnNamePattern), procedureColumns); 2064 } 2065 2066 public void clearProcedureColumns() 2067 { 2068 procedureColumnsMap.clear(); 2069 } 2070 2071 public ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern) throws SQLException 2072 { 2073 DatabaseIdentifier expected = new ColumnDatabaseIdentifierImpl(catalog, schemaPattern, functionNamePattern, true, true, columnNamePattern); 2074 return findMatchingDatabaseIdentifier(expected, functionColumnsMap); 2075 } 2076 2077 public void setFunctionColumns(ResultSet functionColumns) 2078 { 2079 functionColumnsMap.put(new ColumnDatabaseIdentifierImpl(), functionColumns); 2080 } 2081 2082 public void setFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern, ResultSet functionColumns) 2083 { 2084 functionColumnsMap.put(new ColumnDatabaseIdentifierImpl(catalog, schemaPattern, functionNamePattern, columnNamePattern), functionColumns); 2085 } 2086 2087 public void clearFunctionColumns() 2088 { 2089 functionColumnsMap.clear(); 2090 } 2091 2092 public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types) throws SQLException 2093 { 2094 DatabaseIdentifier expected = new TableDatabaseIdentifierImpl(catalog, schemaPattern, true, true, tableNamePattern, types); 2095 return findMatchingDatabaseIdentifier(expected, tablesMap); 2096 } 2097 2098 public void setTables(ResultSet tables) 2099 { 2100 tablesMap.put(new TableDatabaseIdentifierImpl(), tables); 2101 } 2102 2103 public void setTables(String catalog, String schemaPattern, String tableNamePattern, String[] types, ResultSet tables) 2104 { 2105 tablesMap.put(new TableDatabaseIdentifierImpl(catalog, schemaPattern, tableNamePattern, types), tables); 2106 } 2107 2108 public void clearTables() 2109 { 2110 tablesMap.clear(); 2111 } 2112 2113 public ResultSet getCrossReference(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException 2114 { 2115 DatabaseIdentifier identifier1 = new DatabaseIdentifierImpl(primaryCatalog, primarySchema, primaryTable); 2116 DatabaseIdentifier identifier2 = new DatabaseIdentifierImpl(foreignCatalog, foreignSchema, foreignTable); 2117 DatabaseIdentifier expected = new DatabaseIdentifierImplWrapper(identifier1, identifier2); 2118 return findMatchingDatabaseIdentifier(expected, crossReferenceMap); 2119 } 2120 2121 public void setCrossReference(ResultSet crossReference) 2122 { 2123 DatabaseIdentifier identifier1 = new DatabaseIdentifierImpl(); 2124 DatabaseIdentifier identifier2 = new DatabaseIdentifierImpl(); 2125 crossReferenceMap.put(new DatabaseIdentifierImplWrapper(identifier1, identifier2), crossReference); 2126 } 2127 2128 public void setCrossReference(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable, ResultSet crossReference) 2129 { 2130 DatabaseIdentifier identifier1 = new DatabaseIdentifierImpl(primaryCatalog, primarySchema, primaryTable); 2131 DatabaseIdentifier identifier2 = new DatabaseIdentifierImpl(foreignCatalog, foreignSchema, foreignTable); 2132 crossReferenceMap.put(new DatabaseIdentifierImplWrapper(identifier1, identifier2), crossReference); 2133 } 2134 2135 public void clearCrossReference() 2136 { 2137 crossReferenceMap.clear(); 2138 } 2139 2140 public boolean isWrapperFor(Class iface) throws SQLException 2141 { 2142 return false; 2143 } 2144 2145 public Object unwrap(Class iface) throws SQLException 2146 { 2147 throw new SQLException("No object found for " + iface); 2148 } 2149 2150 /* 2151 * If there is only one matching DatabaseIdentifier, then return its 2152 * ResultSet otherwise return a PolyResultSet with the ResultSet of each 2153 * matching DatabaseIdentifier. 2154 */ 2155 private ResultSet findMatchingDatabaseIdentifier(DatabaseIdentifier expected, Map theMap) 2156 { 2157 List list = new ArrayList(); 2158 for(Iterator it = theMap.entrySet().iterator(); it.hasNext(); ) 2159 { 2160 Map.Entry entry = (Map.Entry)it.next(); 2161 DatabaseIdentifier next = (DatabaseIdentifier)entry.getKey(); 2162 if(next.isGlobal() || expected.matches(next)) 2163 { 2164 list.add(entry.getValue()); 2165 } 2166 } 2167 if(list.isEmpty()) return null; 2168 if(list.size() == 1) return (ResultSet)list.get(0); 2169 return new PolyResultSet(list); 2170 } 2171 2172 private ResultSet getAll(Map theMap) 2173 { 2174 List list = new ArrayList(); 2175 list.addAll(theMap.values()); 2176 if(list.isEmpty()) return null; 2177 if(list.size() == 1) return (ResultSet)list.get(0); 2178 return new PolyResultSet(list); 2179 } 2180 2181 private interface DatabaseIdentifier 2182 { 2183 public boolean isGlobal(); 2184 2185 public boolean matches(DatabaseIdentifier other); 2186 } 2187 2188 private class DatabaseIdentifierImpl implements DatabaseIdentifier 2189 { 2190 private boolean isGlobal; 2191 private String catalog; 2192 private String schema; 2193 private String table; 2194 private boolean useSchemaPattern; 2195 private boolean useTablePattern; 2196 2197 public DatabaseIdentifierImpl() 2198 { 2199 isGlobal = true; 2200 } 2201 2202 public DatabaseIdentifierImpl(String catalog, String schema, String table) 2203 { 2204 this(catalog, schema, table, false, false); 2205 } 2206 2207 public DatabaseIdentifierImpl(String catalog, String schema, String table, boolean useSchemaPattern, boolean useTablePattern) 2208 { 2209 isGlobal = false; 2210 this.catalog = catalog; 2211 this.schema = schema; 2212 this.table = table; 2213 this.useSchemaPattern = useSchemaPattern; 2214 this.useTablePattern = useTablePattern; 2215 } 2216 2217 public String getCatalog() 2218 { 2219 return catalog; 2220 } 2221 2222 public boolean isGlobal() 2223 { 2224 return isGlobal; 2225 } 2226 2227 public String getSchema() 2228 { 2229 return schema; 2230 } 2231 2232 public String getTable() 2233 { 2234 return table; 2235 } 2236 2237 protected String convert(String name) 2238 { 2239 if(name.indexOf('%') != -1) 2240 { 2241 name = StringUtil.replaceAll(name, "%", ".*"); 2242 } 2243 if(name.indexOf('_') != -1) 2244 { 2245 name = StringUtil.replaceAll(name, "_", "."); 2246 } 2247 return name; 2248 } 2249 2250 public boolean matches(DatabaseIdentifier object) 2251 { 2252 if(null == object) return false; 2253 if(!object.getClass().equals(this.getClass())) return false; 2254 DatabaseIdentifierImpl other = (DatabaseIdentifierImpl)object; 2255 if(isGlobal != other.isGlobal()) return false; 2256 if(!matchesCatalog(other)) return false; 2257 if(!matchesSchema(other)) return false; 2258 return matchesTable(other); 2259 } 2260 2261 private boolean matchesCatalog(DatabaseIdentifierImpl other) 2262 { 2263 if(null == getCatalog()) return true; 2264 if(catalog.length() == 0) 2265 { 2266 return (other.getCatalog() == null) || (other.getCatalog().length() == 0); 2267 } 2268 else 2269 { 2270 if(other.getCatalog() == null) return false; 2271 return StringUtil.matchesExact(other.getCatalog(), catalog, caseSensitive); 2272 } 2273 } 2274 2275 private boolean matchesSchema(DatabaseIdentifierImpl other) 2276 { 2277 if(null == getSchema()) return true; 2278 if(schema.length() == 0) 2279 { 2280 return (other.getSchema() == null) || (other.getSchema().length() == 0); 2281 } 2282 else 2283 { 2284 if(other.getSchema() == null) return false; 2285 if(!useSchemaPattern) 2286 { 2287 return StringUtil.matchesExact(other.getSchema(), schema, caseSensitive); 2288 } 2289 else 2290 { 2291 return StringUtil.matchesPerl5(other.getSchema(), convert(schema), caseSensitive); 2292 } 2293 } 2294 } 2295 2296 private boolean matchesTable(DatabaseIdentifierImpl other) 2297 { 2298 if(null == table) return false; 2299 if(null == other.getTable()) return false; 2300 if(!useTablePattern) 2301 { 2302 return StringUtil.matchesExact(other.getTable(), table, caseSensitive); 2303 } 2304 else 2305 { 2306 return StringUtil.matchesPerl5(other.getTable(), convert(table), caseSensitive); 2307 } 2308 } 2309 2310 public boolean equals(Object object) 2311 { 2312 if(null == object) return false; 2313 if(!object.getClass().equals(this.getClass())) return false; 2314 DatabaseIdentifierImpl other = (DatabaseIdentifierImpl)object; 2315 if(isGlobal != other.isGlobal()) return false; 2316 if(null != catalog && !catalog.equals(other.getCatalog())) return false; 2317 if(null != other.getCatalog() && !other.getCatalog().equals(catalog)) return false; 2318 if(null != schema && !schema.equals(other.getSchema())) return false; 2319 if(null != other.getSchema() && !other.getSchema().equals(schema)) return false; 2320 if(null != table && !table.equals(other.getTable())) return false; 2321 if(null != other.getTable() && !other.getTable().equals(table)) return false; 2322 return true; 2323 } 2324 2325 public int hashCode() 2326 { 2327 int hashCode = 17; 2328 if(null != catalog) hashCode = (31 * hashCode) + catalog.hashCode(); 2329 if(null != schema) hashCode = (31 * hashCode) + schema.hashCode(); 2330 if(null != table) hashCode = (31 * hashCode) + table.hashCode(); 2331 return hashCode; 2332 } 2333 } 2334 2335 private class AttributesDatabaseIdentifierImpl extends DatabaseIdentifierImpl 2336 { 2337 private String attributeNamePattern; 2338 2339 public AttributesDatabaseIdentifierImpl() 2340 { 2341 2342 } 2343 2344 public AttributesDatabaseIdentifierImpl(String catalog, String schema, String table, String attributeNamePattern) 2345 { 2346 super(catalog, schema, table); 2347 this.attributeNamePattern = attributeNamePattern; 2348 } 2349 2350 public AttributesDatabaseIdentifierImpl(String catalog, String schema, String table, boolean useSchemaPattern, boolean useTablePattern, String attributeNamePattern) 2351 { 2352 super(catalog, schema, table, useSchemaPattern, useTablePattern); 2353 this.attributeNamePattern = attributeNamePattern; 2354 } 2355 2356 public String getAttributeNamePattern() 2357 { 2358 return attributeNamePattern; 2359 } 2360 2361 public boolean matches(DatabaseIdentifier object) 2362 { 2363 if(!super.matches(object)) return false; 2364 AttributesDatabaseIdentifierImpl other = (AttributesDatabaseIdentifierImpl)object; 2365 if(null == attributeNamePattern) return false; 2366 if(null == other.getAttributeNamePattern()) return false; 2367 return StringUtil.matchesPerl5(other.getAttributeNamePattern(), convert(attributeNamePattern), caseSensitive); 2368 } 2369 2370 public boolean equals(Object object) 2371 { 2372 if(!super.equals(object)) return false; 2373 AttributesDatabaseIdentifierImpl other = (AttributesDatabaseIdentifierImpl)object; 2374 if(null != attributeNamePattern && !attributeNamePattern.equals(other.getAttributeNamePattern())) return false; 2375 if(null != other.getAttributeNamePattern() && !other.getAttributeNamePattern().equals(attributeNamePattern)) return false; 2376 return true; 2377 } 2378 2379 public int hashCode() 2380 { 2381 int hashCode = super.hashCode(); 2382 if(null != attributeNamePattern) hashCode = (31 * hashCode) + attributeNamePattern.hashCode(); 2383 return hashCode; 2384 } 2385 } 2386 2387 private class ColumnDatabaseIdentifierImpl extends DatabaseIdentifierImpl 2388 { 2389 private String columnNamePattern; 2390 2391 public ColumnDatabaseIdentifierImpl() 2392 { 2393 2394 } 2395 2396 public ColumnDatabaseIdentifierImpl(String catalog, String schema, String table, String columnNamePattern) 2397 { 2398 super(catalog, schema, table); 2399 this.columnNamePattern = columnNamePattern; 2400 } 2401 2402 public ColumnDatabaseIdentifierImpl(String catalog, String schema, String table, boolean useSchemaPattern, boolean useTablePattern, String columnNamePattern) 2403 { 2404 super(catalog, schema, table, useSchemaPattern, useTablePattern); 2405 this.columnNamePattern = columnNamePattern; 2406 } 2407 2408 public String getColumnNamePattern() 2409 { 2410 return columnNamePattern; 2411 } 2412 2413 public boolean matches(DatabaseIdentifier object) 2414 { 2415 if(!super.matches(object)) return false; 2416 ColumnDatabaseIdentifierImpl other = (ColumnDatabaseIdentifierImpl)object; 2417 if(null == columnNamePattern) return false; 2418 if(null == other.getColumnNamePattern()) return false; 2419 return StringUtil.matchesPerl5(other.getColumnNamePattern(), convert(columnNamePattern), caseSensitive); 2420 } 2421 2422 public boolean equals(Object object) 2423 { 2424 if(!super.equals(object)) return false; 2425 ColumnDatabaseIdentifierImpl other = (ColumnDatabaseIdentifierImpl)object; 2426 if(null != columnNamePattern && !columnNamePattern.equals(other.getColumnNamePattern())) return false; 2427 if(null != other.getColumnNamePattern() && !other.getColumnNamePattern().equals(columnNamePattern)) return false; 2428 return true; 2429 } 2430 2431 public int hashCode() 2432 { 2433 int hashCode = super.hashCode(); 2434 if(null != columnNamePattern) hashCode = (31 * hashCode) + columnNamePattern.hashCode(); 2435 return hashCode; 2436 } 2437 } 2438 2439 private class RowIdentifierDatabaseIdentifierImpl extends DatabaseIdentifierImpl 2440 { 2441 private int scope; 2442 private boolean nullable; 2443 2444 public RowIdentifierDatabaseIdentifierImpl() 2445 { 2446 2447 } 2448 2449 public RowIdentifierDatabaseIdentifierImpl(String catalog, String schema, String table, int scope, boolean nullable) 2450 { 2451 super(catalog, schema, table); 2452 this.scope = scope; 2453 this.nullable = nullable; 2454 } 2455 2456 public boolean isNullable() 2457 { 2458 return nullable; 2459 } 2460 2461 public int getScope() 2462 { 2463 return scope; 2464 } 2465 2466 public boolean matches(DatabaseIdentifier object) 2467 { 2468 if(!super.matches(object)) return false; 2469 return isEqual(object); 2470 } 2471 2472 public boolean equals(Object object) 2473 { 2474 if(!super.equals(object)) return false; 2475 return isEqual(object); 2476 } 2477 2478 private boolean isEqual(Object object) 2479 { 2480 RowIdentifierDatabaseIdentifierImpl other = (RowIdentifierDatabaseIdentifierImpl)object; 2481 if(scope != other.getScope()) return false; 2482 if(nullable != other.isNullable()) return false; 2483 return true; 2484 } 2485 2486 public int hashCode() 2487 { 2488 int hashCode = (super.hashCode() * 31) + scope; 2489 hashCode = (31 * hashCode) + (nullable ? 31 : 62); 2490 return hashCode; 2491 } 2492 } 2493 2494 private class IndexInfoDatabaseIdentifierImpl extends DatabaseIdentifierImpl 2495 { 2496 private boolean unique; 2497 private boolean approximate; 2498 2499 public IndexInfoDatabaseIdentifierImpl() 2500 { 2501 2502 } 2503 2504 public IndexInfoDatabaseIdentifierImpl(String catalog, String schema, String table, boolean unique, boolean approximate) 2505 { 2506 super(catalog, schema, table); 2507 this.unique = unique; 2508 this.approximate = approximate; 2509 } 2510 2511 public boolean isApproximate() 2512 { 2513 return approximate; 2514 } 2515 2516 public boolean isUnique() 2517 { 2518 return unique; 2519 } 2520 2521 public boolean matches(DatabaseIdentifier object) 2522 { 2523 if(!super.matches(object)) return false; 2524 return isEqual(object); 2525 } 2526 2527 public boolean equals(Object object) 2528 { 2529 if(!super.equals(object)) return false; 2530 return isEqual(object); 2531 } 2532 2533 private boolean isEqual(Object object) 2534 { 2535 IndexInfoDatabaseIdentifierImpl other = (IndexInfoDatabaseIdentifierImpl)object; 2536 if(unique != other.isUnique()) return false; 2537 if(approximate != other.isApproximate()) return false; 2538 return true; 2539 } 2540 2541 public int hashCode() 2542 { 2543 int hashCode = super.hashCode(); 2544 hashCode = (31 * hashCode) + (unique ? 31 : 62); 2545 hashCode = (31 * hashCode) + (approximate ? (3 * 31) : (4 * 31)); 2546 return hashCode; 2547 } 2548 } 2549 2550 private class TableDatabaseIdentifierImpl extends DatabaseIdentifierImpl 2551 { 2552 private String[] types; 2553 2554 public TableDatabaseIdentifierImpl() 2555 { 2556 2557 } 2558 2559 public TableDatabaseIdentifierImpl(String catalog, String schema, String table, String[] types) 2560 { 2561 super(catalog, schema, table); 2562 this.types = types; 2563 } 2564 2565 public TableDatabaseIdentifierImpl(String catalog, String schema, boolean useSchemaPattern, boolean useTablePattern, String table, String[] types) 2566 { 2567 super(catalog, schema, table, useSchemaPattern, useTablePattern); 2568 this.types = types; 2569 } 2570 2571 public String[] getTypes() 2572 { 2573 return types; 2574 } 2575 2576 public boolean matches(DatabaseIdentifier object) 2577 { 2578 if(!super.matches(object)) return false; 2579 TableDatabaseIdentifierImpl other = (TableDatabaseIdentifierImpl)object; 2580 if(null == types) return true; 2581 if(null == other.getTypes()) return false; 2582 return matchesTypes(other); 2583 } 2584 2585 private boolean matchesTypes(TableDatabaseIdentifierImpl other) 2586 { 2587 String[] otherTypes = other.getTypes(); 2588 for(int ii = 0; ii < types.length; ii++) 2589 { 2590 String type = types[ii]; 2591 for(int jj = 0; jj < otherTypes.length; jj++) 2592 { 2593 if(type.equals(otherTypes[jj])) return true; 2594 } 2595 } 2596 return false; 2597 } 2598 2599 public boolean equals(Object object) 2600 { 2601 if(!super.equals(object)) return false; 2602 TableDatabaseIdentifierImpl other = (TableDatabaseIdentifierImpl)object; 2603 if(null == types && null == other.getTypes()) return true; 2604 if(null == types) return false; 2605 if(null == other.getTypes()) return false; 2606 return Arrays.equals(types, other.getTypes()); 2607 } 2608 2609 public int hashCode() 2610 { 2611 int hashCode = super.hashCode(); 2612 if(null != types) 2613 { 2614 for(int ii = 0; ii < types.length; ii++) 2615 { 2616 if(null != types[ii]) 2617 { 2618 hashCode = (31 * hashCode) + types[ii].hashCode(); 2619 } 2620 } 2621 } 2622 return hashCode; 2623 } 2624 } 2625 2626 private class UDTDatabaseIdentifierImpl extends DatabaseIdentifierImpl 2627 { 2628 private int[] types; 2629 2630 public UDTDatabaseIdentifierImpl() 2631 { 2632 2633 } 2634 2635 public UDTDatabaseIdentifierImpl(String catalog, String schema, String table, int[] types) 2636 { 2637 super(catalog, schema, table); 2638 this.types = types; 2639 } 2640 2641 public UDTDatabaseIdentifierImpl(String catalog, String schema, String table, boolean useSchemaPattern, boolean useTablePattern, int[] types) 2642 { 2643 super(catalog, schema, table, useSchemaPattern, useTablePattern); 2644 this.types = types; 2645 } 2646 2647 public int[] getTypes() 2648 { 2649 return types; 2650 } 2651 2652 public boolean matches(DatabaseIdentifier object) 2653 { 2654 if(!super.matches(object)) return false; 2655 UDTDatabaseIdentifierImpl other = (UDTDatabaseIdentifierImpl)object; 2656 if(null == types) return true; 2657 if(null == other.getTypes()) return false; 2658 return matchesTypes(other); 2659 } 2660 2661 private boolean matchesTypes(UDTDatabaseIdentifierImpl other) 2662 { 2663 int[] otherTypes = other.getTypes(); 2664 for(int ii = 0; ii < types.length; ii++) 2665 { 2666 int type = types[ii]; 2667 for(int jj = 0; jj < otherTypes.length; jj++) 2668 { 2669 if (type == otherTypes[jj]) return true; 2670 } 2671 } 2672 return false; 2673 } 2674 2675 public boolean equals(Object object) 2676 { 2677 if(!super.equals(object)) return false; 2678 UDTDatabaseIdentifierImpl other = (UDTDatabaseIdentifierImpl)object; 2679 if(null == types && null == other.getTypes()) return true; 2680 if(null == types) return false; 2681 if(null == other.getTypes()) return false; 2682 return Arrays.equals(types, other.getTypes()); 2683 } 2684 2685 public int hashCode() 2686 { 2687 int hashCode = super.hashCode(); 2688 if(null != types) 2689 { 2690 for(int ii = 0; ii < types.length; ii++) 2691 { 2692 hashCode = (31 * hashCode) + types[ii]; 2693 } 2694 } 2695 return hashCode; 2696 } 2697 } 2698 2699 private class DatabaseIdentifierImplWrapper implements DatabaseIdentifier 2700 { 2701 private DatabaseIdentifier identifier1; 2702 private DatabaseIdentifier identifier2; 2703 2704 public DatabaseIdentifierImplWrapper(DatabaseIdentifier identifier1, DatabaseIdentifier identifier2) 2705 { 2706 this.identifier1 = identifier1; 2707 this.identifier2 = identifier2; 2708 } 2709 2710 public DatabaseIdentifier getIdentifier1() 2711 { 2712 return identifier1; 2713 } 2714 2715 public DatabaseIdentifier getIdentifier2() 2716 { 2717 return identifier2; 2718 } 2719 2720 public boolean isGlobal() 2721 { 2722 if(null == identifier1) return false; 2723 if(null == identifier2) return false; 2724 return (identifier1.isGlobal() && identifier1.isGlobal()); 2725 } 2726 2727 public boolean matches(DatabaseIdentifier object) 2728 { 2729 if(null == object) return false; 2730 if(!object.getClass().equals(this.getClass())) return false; 2731 DatabaseIdentifierImplWrapper other = (DatabaseIdentifierImplWrapper)object; 2732 if(null != identifier1 && !identifier1.matches(other.getIdentifier1())) return false; 2733 if(null != identifier2 && !identifier2.matches(other.getIdentifier2())) return false; 2734 return true; 2735 } 2736 2737 public boolean equals(Object object) 2738 { 2739 if(null == object) return false; 2740 if(!object.getClass().equals(this.getClass())) return false; 2741 DatabaseIdentifierImplWrapper other = (DatabaseIdentifierImplWrapper)object; 2742 if(null != identifier1 && !identifier1.equals(other.getIdentifier1())) return false; 2743 if(null != other.getIdentifier1() && !other.getIdentifier1().equals(identifier1)) return false; 2744 if(null != identifier2 && !identifier2.equals(other.getIdentifier2())) return false; 2745 if(null != other.getIdentifier2() && !other.getIdentifier2().equals(identifier2)) return false; 2746 return true; 2747 } 2748 2749 public int hashCode() 2750 { 2751 int hashCode = 0; 2752 if(null != identifier1) hashCode = (31 * hashCode) + identifier1.hashCode(); 2753 if(null != identifier2) hashCode = (31 * hashCode) + identifier2.hashCode(); 2754 return hashCode; 2755 } 2756 } 2757 } 2758