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