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