KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > h2 > test > jdbc > TestMetaData


1 /*
2  * Copyright 2004-2006 H2 Group. Licensed under the H2 License, Version 1.0 (http://h2database.com/html/license.html).
3  * Initial Developer: H2 Group
4  */

5 package org.h2.test.jdbc;
6
7 import java.sql.*;
8
9 import org.h2.engine.Constants;
10 import org.h2.test.TestBase;
11 import org.h2.value.DataType;
12
13 public class TestMetaData extends TestBase {
14
15     Connection conn;
16     DatabaseMetaData meta;
17     Statement stat;
18     String JavaDoc catalog = "METADATA";
19
20     public void test() throws Exception JavaDoc {
21         deleteDb("metaData");
22         conn = getConnection("metaData");
23
24         testCrossReferences();
25         testProcedureColumns();
26
27         stat = conn.createStatement();
28         meta = conn.getMetaData();
29         testStatic();
30         // TODO test remaining meta data
31

32         stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
33         stat.execute("CREATE INDEX IDXNAME ON TEST(NAME)");
34
35         ResultSet rs;
36
37         rs=meta.getCatalogs();
38         rs.next();
39         check(rs.getString(1), catalog);
40         checkFalse(rs.next());
41
42         rs = meta.getSchemas();
43         rs.next();
44         check(rs.getString("TABLE_SCHEM"), "INFORMATION_SCHEMA");
45         rs.next();
46         check(rs.getString("TABLE_SCHEM"), "PUBLIC");
47         checkFalse(rs.next());
48
49         rs = meta.getTableTypes();
50         rs.next();
51         check(rs.getString("TABLE_TYPE"), "SYSTEM TABLE");
52         rs.next();
53         check(rs.getString("TABLE_TYPE"), "TABLE");
54         rs.next();
55         check(rs.getString("TABLE_TYPE"), "TABLE LINK");
56         rs.next();
57         check(rs.getString("TABLE_TYPE"), "VIEW");
58         checkFalse(rs.next());
59
60         rs = meta.getTables(null, Constants.SCHEMA_MAIN, null, new String JavaDoc[]{"TABLE"});
61         rs.next();
62         check(rs.getString("TABLE_NAME"), "TEST");
63         checkFalse(rs.next());
64
65         rs = meta.getTables(null, "INFORMATION_SCHEMA", null, new String JavaDoc[]{"TABLE", "SYSTEM TABLE"});
66         rs.next();
67         check("CATALOGS", rs.getString("TABLE_NAME"));
68         rs.next();
69         check("COLLATIONS", rs.getString("TABLE_NAME"));
70         rs.next();
71         check("COLUMNS", rs.getString("TABLE_NAME"));
72         rs.next();
73         check("COLUMN_PRIVILEGES", rs.getString("TABLE_NAME"));
74         rs.next();
75         check("CONSTANTS", rs.getString("TABLE_NAME"));
76         rs.next();
77         check("CONSTRAINTS", rs.getString("TABLE_NAME"));
78         rs.next();
79         check("CROSS_REFERENCES", rs.getString("TABLE_NAME"));
80         rs.next();
81         check("DOMAINS", rs.getString("TABLE_NAME"));
82         rs.next();
83         check("FUNCTION_ALIASES", rs.getString("TABLE_NAME"));
84         rs.next();
85         check("FUNCTION_COLUMNS", rs.getString("TABLE_NAME"));
86         rs.next();
87         check("HELP", rs.getString("TABLE_NAME"));
88         rs.next();
89         check("INDEXES", rs.getString("TABLE_NAME"));
90         rs.next();
91         check("IN_DOUBT", rs.getString("TABLE_NAME"));
92         rs.next();
93         check("RIGHTS", rs.getString("TABLE_NAME"));
94         rs.next();
95         check("ROLES", rs.getString("TABLE_NAME"));
96         rs.next();
97         check("SCHEMATA", rs.getString("TABLE_NAME"));
98         rs.next();
99         check("SEQUENCES", rs.getString("TABLE_NAME"));
100         rs.next();
101         check("SETTINGS", rs.getString("TABLE_NAME"));
102         rs.next();
103         check("TABLES", rs.getString("TABLE_NAME"));
104         rs.next();
105         check("TABLE_PRIVILEGES", rs.getString("TABLE_NAME"));
106         rs.next();
107         check("TABLE_TYPES", rs.getString("TABLE_NAME"));
108         rs.next();
109         check("TRIGGERS", rs.getString("TABLE_NAME"));
110         rs.next();
111         check("TYPE_INFO", rs.getString("TABLE_NAME"));
112         rs.next();
113         check("USERS", rs.getString("TABLE_NAME"));
114         rs.next();
115         check("VIEWS", rs.getString("TABLE_NAME"));
116         checkFalse(rs.next());
117
118         rs = meta.getColumns(null, null, "TEST", null);
119         rs.next();
120         check(rs.getString("COLUMN_NAME"), "ID");
121         rs.next();
122         check(rs.getString("COLUMN_NAME"), "NAME");
123         checkFalse(rs.next());
124
125         rs = meta.getPrimaryKeys(null, null, "TEST");
126         rs.next();
127         check(rs.getString("COLUMN_NAME"), "ID");
128         checkFalse(rs.next());
129
130         rs = meta.getBestRowIdentifier(null, null, "TEST", DatabaseMetaData.bestRowSession, false);
131         rs.next();
132         check(rs.getString("COLUMN_NAME"), "ID");
133         checkFalse(rs.next());
134
135         rs = meta.getIndexInfo(null, null, "TEST", false, false);
136         rs.next();
137         String JavaDoc index = rs.getString("INDEX_NAME");
138         check(index.startsWith("PRIMARY_KEY"));
139         check(rs.getString("COLUMN_NAME"), "ID");
140         rs.next();
141         check(rs.getString("INDEX_NAME"), "IDXNAME");
142         check(rs.getString("COLUMN_NAME"), "NAME");
143         checkFalse(rs.next());
144
145         rs = meta.getIndexInfo(null, null, "TEST", true, false);
146         rs.next();
147         index = rs.getString("INDEX_NAME");
148         check(index.startsWith("PRIMARY_KEY"));
149         check(rs.getString("COLUMN_NAME"), "ID");
150         checkFalse(rs.next());
151
152         rs = meta.getVersionColumns(null, null, "TEST");
153         checkFalse(rs.next());
154
155         stat.execute("DROP TABLE TEST");
156
157         rs = stat.executeQuery("SELECT * FROM INFORMATION_SCHEMA.SETTINGS");
158         while(rs.next()) {
159             String JavaDoc name = rs.getString("NAME");
160             String JavaDoc value = rs.getString("VALUE");
161             trace(name+"="+value);
162         }
163
164         test(conn);
165
166 // meta.getTablePrivileges()
167

168         // meta.getAttributes()
169
// meta.getColumnPrivileges()
170
// meta.getSuperTables()
171
// meta.getSuperTypes()
172
// meta.getTypeInfo()
173
// meta.getUDTs()
174

175         conn.close();
176         testTempTable();
177
178     }
179
180     private void testProcedureColumns() throws Exception JavaDoc {
181         DatabaseMetaData meta = conn.getMetaData();
182         ResultSet rs;
183         Statement stat = conn.createStatement();
184         stat.execute("CREATE ALIAS PROP FOR \"java.lang.System.getProperty(java.lang.String)\"");
185         stat.execute("CREATE ALIAS EXIT FOR \"java.lang.System.exit\"");
186         rs = meta.getProcedures(null, null, "EX%");
187         testResultSetMeta(rs, 8, new String JavaDoc[] { "PROCEDURE_CAT", "PROCEDURE_SCHEM",
188                 "PROCEDURE_NAME", "NUM_INPUT_PARAMS", "NUM_OUTPUT_PARAMS", "NUM_RESULT_SETS",
189                 "REMARKS", "PROCEDURE_TYPE"}, new int[] { Types.VARCHAR,
190                 Types.VARCHAR, Types.VARCHAR, Types.INTEGER,
191                 Types.INTEGER, Types.INTEGER, Types.VARCHAR,
192                 Types.SMALLINT}, null, null);
193         testResultSetOrdered(rs, new String JavaDoc[][] {
194                 { catalog, Constants.SCHEMA_MAIN, "EXIT", "0", "0", "0", "", ""+DatabaseMetaData.procedureNoResult },
195                 });
196         rs = meta.getProcedureColumns(null, null, null, null);
197         testResultSetMeta(rs, 13, new String JavaDoc[] { "PROCEDURE_CAT", "PROCEDURE_SCHEM",
198                 "PROCEDURE_NAME", "COLUMN_NAME", "COLUMN_TYPE", "DATA_TYPE", "TYPE_NAME",
199                 "PRECISION", "LENGTH", "SCALE", "RADIX", "NULLABLE", "REMARKS"},
200                 new int[] { Types.VARCHAR,
201                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.SMALLINT, Types.INTEGER,
202                 Types.VARCHAR, Types.INTEGER, Types.INTEGER, Types.SMALLINT,
203                 Types.SMALLINT, Types.SMALLINT, Types.VARCHAR}, null, null);
204         testResultSetOrdered(rs, new String JavaDoc[][] {
205                 { catalog, Constants.SCHEMA_MAIN, "EXIT", "P1", "" + DatabaseMetaData.procedureColumnIn,
206                     "" + Types.INTEGER, "INTEGER",
207                     "10", "10", "0", "10", ""+DatabaseMetaData.procedureNoNulls},
208                 { catalog, Constants.SCHEMA_MAIN, "PROP", "P1", "" + DatabaseMetaData.procedureColumnIn,
209                     "" + Types.VARCHAR, "VARCHAR",
210                     "" + Integer.MAX_VALUE, "" + Integer.MAX_VALUE, "0", "10", ""+DatabaseMetaData.procedureNullable},
211                 });
212         stat.execute("DROP ALIAS EXIT");
213         stat.execute("DROP ALIAS PROP");
214     }
215
216     private void testCrossReferences() throws Exception JavaDoc {
217         DatabaseMetaData meta = conn.getMetaData();
218         ResultSet rs;
219         Statement stat = conn.createStatement();
220         stat.execute("CREATE TABLE PARENT(A INT, B INT, PRIMARY KEY(A, B))");
221         stat.execute("CREATE TABLE CHILD(ID INT PRIMARY KEY, PA INT, PB INT, CONSTRAINT AB FOREIGN KEY(PA, PB) REFERENCES PARENT(A, B))");
222         rs = meta.getCrossReference(null, "PUBLIC", "PARENT", null, "PUBLIC", "CHILD");
223         checkCrossRef(rs);
224         rs = meta.getImportedKeys(null, "PUBLIC", "CHILD");
225         checkCrossRef(rs);
226         rs = meta.getExportedKeys(null, "PUBLIC", "PARENT");
227         checkCrossRef(rs);
228         stat.execute("DROP TABLE PARENT");
229         stat.execute("DROP TABLE CHILD");
230     }
231
232     private void checkCrossRef(ResultSet rs) throws Exception JavaDoc {
233         testResultSetMeta(rs, 14, new String JavaDoc[] {
234                 "PKTABLE_CAT", "PKTABLE_SCHEM", "PKTABLE_NAME", "PKCOLUMN_NAME",
235                 "FKTABLE_CAT", "FKTABLE_SCHEM", "FKTABLE_NAME", "FKCOLUMN_NAME",
236                 "KEY_SEQ", "UPDATE_RULE", "DELETE_RULE",
237                 "FK_NAME", "PK_NAME", "DEFERRABILITY"
238         }, new int[] {
239                 Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,
240                 Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,
241                 Types.SMALLINT,Types.SMALLINT,Types.SMALLINT,
242                 Types.VARCHAR,Types.VARCHAR,Types.SMALLINT
243         }, null, null);
244         testResultSetOrdered(rs, new String JavaDoc[][] { {
245                     catalog, Constants.SCHEMA_MAIN, "PARENT", "A",
246                     catalog, Constants.SCHEMA_MAIN, "CHILD", "PA",
247                     "1", ""+DatabaseMetaData.importedKeyRestrict, ""+DatabaseMetaData.importedKeyRestrict, "AB", null,
248                     ""+DatabaseMetaData.importedKeyNotDeferrable
249                 },{
250                     catalog, Constants.SCHEMA_MAIN, "PARENT", "B",
251                     catalog, Constants.SCHEMA_MAIN, "CHILD", "PB",
252                     "2", ""+DatabaseMetaData.importedKeyRestrict, ""+DatabaseMetaData.importedKeyRestrict, "AB", null,
253                     ""+DatabaseMetaData.importedKeyNotDeferrable
254         } } );
255     }
256
257     void testTempTable() throws Exception JavaDoc {
258         Connection conn = getConnection("metaData");
259         Statement stat = conn.createStatement();
260         stat.execute("DROP TABLE IF EXISTS TEST_TEMP");
261         stat.execute("CREATE TEMP TABLE TEST_TEMP(ID INT PRIMARY KEY, NAME VARCHAR(255))");
262         stat.execute("CREATE INDEX IDX_NAME ON TEST_TEMP(NAME)");
263         stat.execute("ALTER TABLE TEST_TEMP ADD FOREIGN KEY(ID) REFERENCES(ID)");
264         conn.close();
265
266         conn = getConnection("metaData");
267         stat = conn.createStatement();
268         stat.execute("CREATE TEMP TABLE TEST_TEMP(ID INT PRIMARY KEY, NAME VARCHAR(255))");
269         ResultSet rs = stat.executeQuery("SELECT STORAGE_TYPE FROM "
270                 + "INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME='TEST_TEMP'");
271         rs.next();
272         check(rs.getString("STORAGE_TYPE"), "GLOBAL TEMPORARY");
273         stat.execute("DROP TABLE IF EXISTS TEST_TEMP");
274         conn.close();
275     }
276
277     void testStatic() throws Exception JavaDoc {
278         Driver dr = (Driver) Class.forName("org.h2.Driver").newInstance();
279
280         check(dr.getMajorVersion(), meta.getDriverMajorVersion());
281         check(dr.getMinorVersion(), meta.getDriverMinorVersion());
282         check(dr.jdbcCompliant());
283
284         check(dr.getPropertyInfo(null, null).length, 0);
285         check(dr.connect("jdbc:test:false", null) == null);
286
287         check(meta.getNumericFunctions().length()>0);
288         check(meta.getStringFunctions().length()>0);
289         check(meta.getSystemFunctions().length()>0);
290         check(meta.getTimeDateFunctions().length()>0);
291
292         check(meta.allProceduresAreCallable());
293         check(meta.allTablesAreSelectable());
294         check(meta.dataDefinitionCausesTransactionCommit());
295         checkFalse(meta.dataDefinitionIgnoredInTransactions());
296         checkFalse(meta.deletesAreDetected(ResultSet.TYPE_FORWARD_ONLY));
297         checkFalse(meta.deletesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
298         checkFalse(meta.deletesAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
299         checkFalse(meta.doesMaxRowSizeIncludeBlobs());
300         check(meta.getCatalogSeparator(), ".");
301         check(meta.getCatalogTerm(), "catalog");
302         check(meta.getConnection()==conn);
303         if(config.jdk14) {
304             String JavaDoc versionStart = meta.getDatabaseMajorVersion()+"."+meta.getDatabaseMinorVersion();
305             check(meta.getDatabaseProductVersion().startsWith(versionStart));
306             check(meta.getDriverMajorVersion(), meta.getDatabaseMajorVersion());
307             check(meta.getDriverMinorVersion(), meta.getDatabaseMinorVersion());
308             check(meta.getJDBCMajorVersion(), 3);
309             check(meta.getJDBCMinorVersion(), 0);
310         }
311         check(meta.getDatabaseProductName(), "H2");
312         check(meta.getDefaultTransactionIsolation(), Connection.TRANSACTION_READ_COMMITTED);
313         check(meta.getDriverName(), "H2 JDBC Driver");
314
315         String JavaDoc versionStart = meta.getDriverMajorVersion()+"."+meta.getDriverMinorVersion();
316         check(meta.getDriverVersion().startsWith(versionStart));
317         check(meta.getExtraNameCharacters(), "");
318         check(meta.getIdentifierQuoteString(), "\"");
319         check(meta.getMaxBinaryLiteralLength(), 0);
320         check(meta.getMaxCatalogNameLength(), 0);
321         check(meta.getMaxCharLiteralLength(), 0);
322         check(meta.getMaxColumnNameLength(), 0);
323         check(meta.getMaxColumnsInGroupBy(), 0);
324         check(meta.getMaxColumnsInIndex(), 0);
325         check(meta.getMaxColumnsInOrderBy(), 0);
326         check(meta.getMaxColumnsInSelect(), 0);
327         check(meta.getMaxColumnsInTable(), 0);
328         check(meta.getMaxConnections(), 0);
329         check(meta.getMaxCursorNameLength(), 0);
330         check(meta.getMaxIndexLength(), 0);
331         check(meta.getMaxProcedureNameLength(), 0);
332         check(meta.getMaxRowSize(), 0);
333         check(meta.getMaxSchemaNameLength(), 0);
334         check(meta.getMaxStatementLength(), 0);
335         check(meta.getMaxStatements(), 0);
336         check(meta.getMaxTableNameLength(), 0);
337         check(meta.getMaxTablesInSelect(), 0);
338         check(meta.getMaxUserNameLength(), 0);
339         check(meta.getProcedureTerm(), "procedure");
340         if(config.jdk14) {
341             check(meta.getResultSetHoldability(), ResultSet.CLOSE_CURSORS_AT_COMMIT);
342             check(meta.getSQLStateType(), DatabaseMetaData.sqlStateSQL99);
343             checkFalse(meta.locatorsUpdateCopy());
344         }
345         check(meta.getSchemaTerm(), "schema");
346         check(meta.getSearchStringEscape(), "\\");
347         check(meta.getSQLKeywords(), "");
348
349         check(meta.getURL().startsWith("jdbc:h2:"));
350         check(meta.getUserName().length()>1);
351         checkFalse(meta.insertsAreDetected(ResultSet.TYPE_FORWARD_ONLY));
352         checkFalse(meta.insertsAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
353         checkFalse(meta.insertsAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
354         check(meta.isCatalogAtStart());
355         checkFalse(meta.isReadOnly());
356         check(meta.nullPlusNonNullIsNull());
357         checkFalse(meta.nullsAreSortedAtEnd());
358         checkFalse(meta.nullsAreSortedAtStart());
359         checkFalse(meta.nullsAreSortedHigh());
360         check(meta.nullsAreSortedLow());
361         checkFalse(meta.othersDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
362         checkFalse(meta.othersDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
363         checkFalse(meta.othersDeletesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
364         checkFalse(meta.othersInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY));
365         checkFalse(meta.othersInsertsAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
366         checkFalse(meta.othersInsertsAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
367         checkFalse(meta.othersUpdatesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
368         checkFalse(meta.othersUpdatesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
369         checkFalse(meta.othersUpdatesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
370         checkFalse(meta.ownDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
371         checkFalse(meta.ownDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
372         checkFalse(meta.ownDeletesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
373         checkFalse(meta.ownInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY));
374         checkFalse(meta.ownInsertsAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
375         checkFalse(meta.ownInsertsAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
376         checkFalse(meta.ownUpdatesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
377         checkFalse(meta.ownUpdatesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
378         checkFalse(meta.ownUpdatesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
379         checkFalse(meta.storesLowerCaseIdentifiers());
380         checkFalse(meta.storesLowerCaseQuotedIdentifiers());
381         checkFalse(meta.storesMixedCaseIdentifiers());
382         check(meta.storesMixedCaseQuotedIdentifiers());
383         check(meta.storesUpperCaseIdentifiers());
384         checkFalse(meta.storesUpperCaseQuotedIdentifiers());
385         check(meta.supportsAlterTableWithAddColumn());
386         check(meta.supportsAlterTableWithDropColumn());
387         check(meta.supportsANSI92EntryLevelSQL());
388         checkFalse(meta.supportsANSI92IntermediateSQL());
389         checkFalse(meta.supportsANSI92FullSQL());
390         check(meta.supportsBatchUpdates());
391         checkFalse(meta.supportsCatalogsInDataManipulation());
392         checkFalse(meta.supportsCatalogsInIndexDefinitions());
393         checkFalse(meta.supportsCatalogsInPrivilegeDefinitions());
394         checkFalse(meta.supportsCatalogsInProcedureCalls());
395         checkFalse(meta.supportsCatalogsInTableDefinitions());
396         check(meta.supportsColumnAliasing());
397         check(meta.supportsConvert());
398         check(meta.supportsConvert(Types.INTEGER, Types.VARCHAR));
399         check(meta.supportsCoreSQLGrammar());
400         check(meta.supportsCorrelatedSubqueries());
401         checkFalse(meta.supportsDataDefinitionAndDataManipulationTransactions());
402         check(meta.supportsDataManipulationTransactionsOnly());
403         checkFalse(meta.supportsDifferentTableCorrelationNames());
404         check(meta.supportsExpressionsInOrderBy());
405         checkFalse(meta.supportsExtendedSQLGrammar());
406         checkFalse(meta.supportsFullOuterJoins());
407         if(config.jdk14) {
408             check(meta.supportsGetGeneratedKeys());
409             check(meta.supportsMultipleOpenResults());
410             checkFalse(meta.supportsNamedParameters());
411         }
412         check(meta.supportsGroupBy());
413         check(meta.supportsGroupByBeyondSelect());
414         check(meta.supportsGroupByUnrelated());
415         check(meta.supportsIntegrityEnhancementFacility());
416         check(meta.supportsLikeEscapeClause());
417         check(meta.supportsLimitedOuterJoins());
418         check(meta.supportsMinimumSQLGrammar());
419         checkFalse(meta.supportsMixedCaseIdentifiers());
420         check(meta.supportsMixedCaseQuotedIdentifiers());
421         checkFalse(meta.supportsMultipleResultSets());
422         check(meta.supportsMultipleTransactions());
423         check(meta.supportsNonNullableColumns());
424         checkFalse(meta.supportsOpenCursorsAcrossCommit());
425         checkFalse(meta.supportsOpenCursorsAcrossRollback());
426         check(meta.supportsOpenStatementsAcrossCommit());
427         check(meta.supportsOpenStatementsAcrossRollback());
428         check(meta.supportsOrderByUnrelated());
429         check(meta.supportsOuterJoins());
430         check(meta.supportsPositionedDelete());
431         check(meta.supportsPositionedUpdate());
432         check(meta.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY));
433         check(meta.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE));
434         check(meta.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY));
435         check(meta.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE));
436         checkFalse(meta.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY));
437         checkFalse(meta.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE));
438         if(config.jdk14) {
439             checkFalse(meta.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT));
440             check(meta.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT));
441             check(meta.supportsSavepoints());
442             checkFalse(meta.supportsStatementPooling());
443         }
444         check(meta.supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY));
445         check(meta.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE));
446         checkFalse(meta.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE));
447         check(meta.supportsSchemasInDataManipulation());
448         check(meta.supportsSchemasInIndexDefinitions());
449         check(meta.supportsSchemasInPrivilegeDefinitions());
450         check(meta.supportsSchemasInProcedureCalls());
451         check(meta.supportsSchemasInTableDefinitions());
452         check(meta.supportsSelectForUpdate());
453         checkFalse(meta.supportsStoredProcedures());
454         check(meta.supportsSubqueriesInComparisons());
455         check(meta.supportsSubqueriesInExists());
456         check(meta.supportsSubqueriesInIns());
457         check(meta.supportsSubqueriesInQuantifieds());
458         check(meta.supportsTableCorrelationNames());
459         check(meta.supportsTransactions());
460         check(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_NONE));
461         check(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_COMMITTED));
462         check(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_UNCOMMITTED));
463         check(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_REPEATABLE_READ));
464         check(meta.supportsTransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE));
465         check(meta.supportsUnion());
466         check(meta.supportsUnionAll());
467         checkFalse(meta.updatesAreDetected(ResultSet.TYPE_FORWARD_ONLY));
468         checkFalse(meta.updatesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
469         checkFalse(meta.updatesAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
470         checkFalse(meta.usesLocalFilePerTable());
471         check(meta.usesLocalFiles());
472     }
473
474     void test(Connection conn) throws Exception JavaDoc {
475         DatabaseMetaData meta = conn.getMetaData();
476         Statement stat = conn.createStatement();
477         ResultSet rs;
478
479         conn.setReadOnly(true);
480         conn.setReadOnly(false);
481         checkFalse(conn.isReadOnly());
482         check(conn.isReadOnly() == meta.isReadOnly());
483
484         check(conn==meta.getConnection());
485
486         // currently, setCatalog is ignored
487
conn.setCatalog("XYZ");
488         trace(conn.getCatalog());
489
490         String JavaDoc product = meta.getDatabaseProductName();
491         trace("meta.getDatabaseProductName:" + product);
492
493         String JavaDoc version = meta.getDatabaseProductVersion();
494         trace("meta.getDatabaseProductVersion:" + version);
495
496         int major = meta.getDriverMajorVersion();
497         trace("meta.getDriverMajorVersion:" + major);
498
499         int minor = meta.getDriverMinorVersion();
500         trace("meta.getDriverMinorVersion:" + minor);
501
502         String JavaDoc drivername = meta.getDriverName();
503         trace("meta.getDriverName:" + drivername);
504
505         String JavaDoc driverversion = meta.getDriverVersion();
506         trace("meta.getDriverVersion:" + driverversion);
507
508         meta.getSearchStringEscape();
509
510         String JavaDoc url = meta.getURL();
511         trace("meta.getURL:" + url);
512
513         String JavaDoc user = meta.getUserName();
514         trace("meta.getUserName:" + user);
515
516         trace("meta.nullsAreSortedHigh:" + meta.nullsAreSortedHigh());
517         trace("meta.nullsAreSortedLow:" + meta.nullsAreSortedLow());
518         trace("meta.nullsAreSortedAtStart:" + meta.nullsAreSortedAtStart());
519         trace("meta.nullsAreSortedAtEnd:" + meta.nullsAreSortedAtEnd());
520         int count = (meta.nullsAreSortedHigh() ? 1 : 0)
521                 + (meta.nullsAreSortedLow() ? 1 : 0)
522                 + (meta.nullsAreSortedAtStart() ? 1 : 0)
523                 + (meta.nullsAreSortedAtEnd() ? 1 : 0);
524         check(count == 1);
525
526         trace("meta.allProceduresAreCallable:" + meta.allProceduresAreCallable());
527         check(meta.allProceduresAreCallable());
528
529         trace("meta.allTablesAreSelectable:" + meta.allTablesAreSelectable());
530         check(meta.allTablesAreSelectable());
531
532         trace("getTables");
533         rs = meta.getTables(null, Constants.SCHEMA_MAIN, null, new String JavaDoc[] { "TABLE"});
534         testResultSetMeta(rs, 6, new String JavaDoc[] { "TABLE_CAT", "TABLE_SCHEM",
535                 "TABLE_NAME", "TABLE_TYPE", "REMARKS", "SQL"}, new int[] {
536                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
537                 Types.VARCHAR, Types.VARCHAR}, null, null);
538         if (rs.next()) {
539             error("Database is not empty after dropping all tables");
540         }
541         stat.executeUpdate("CREATE TABLE TEST(" + "ID INT PRIMARY KEY,"
542                 + "TEXT_V VARCHAR(120)," + "DEC_V DECIMAL(12,3),"
543                 + "DATE_V DATETIME," + "BLOB_V BLOB," + "CLOB_V CLOB" + ")");
544         rs = meta.getTables(null, Constants.SCHEMA_MAIN, null, new String JavaDoc[]{"TABLE"});
545         testResultSetOrdered(rs, new String JavaDoc[][] { { catalog, Constants.SCHEMA_MAIN, "TEST",
546                 "TABLE", ""}});
547         trace("getColumns");
548         rs = meta.getColumns(null, null, "TEST", null);
549         testResultSetMeta(rs, 18, new String JavaDoc[] { "TABLE_CAT", "TABLE_SCHEM",
550                 "TABLE_NAME", "COLUMN_NAME", "DATA_TYPE", "TYPE_NAME",
551                 "COLUMN_SIZE", "BUFFER_LENGTH", "DECIMAL_DIGITS",
552                 "NUM_PREC_RADIX", "NULLABLE", "REMARKS", "COLUMN_DEF",
553                 "SQL_DATA_TYPE", "SQL_DATETIME_SUB", "CHAR_OCTET_LENGTH",
554                 "ORDINAL_POSITION", "IS_NULLABLE"}, new int[] { Types.VARCHAR,
555                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.SMALLINT,
556                 Types.VARCHAR, Types.INTEGER, Types.INTEGER, Types.INTEGER,
557                 Types.INTEGER, Types.SMALLINT, Types.VARCHAR, Types.VARCHAR,
558                 Types.SMALLINT, Types.INTEGER, Types.INTEGER, Types.INTEGER,
559                 Types.VARCHAR}, null, null);
560         testResultSetOrdered(rs, new String JavaDoc[][] {
561                 { catalog, Constants.SCHEMA_MAIN, "TEST", "ID", "" + Types.INTEGER, "INTEGER", "10",
562                         "10", "0", "10", "" + DatabaseMetaData.columnNoNulls,
563                         "", "", "" + Types.INTEGER, "0", "10", "1", "NO"},
564                 { catalog, Constants.SCHEMA_MAIN, "TEST", "TEXT_V", "" + Types.VARCHAR, "VARCHAR",
565                         "120", "120", "0", "10", "" + DatabaseMetaData.columnNullable,
566                         "", "", "" + Types.VARCHAR, "0", "120", "2", "YES"},
567                 { catalog, Constants.SCHEMA_MAIN, "TEST", "DEC_V", "" + Types.DECIMAL, "DECIMAL", "12",
568                             "12", "3", "10", "" + DatabaseMetaData.columnNullable, "", "", "" + Types.DECIMAL,
569                         "0", "12", "3", "YES"},
570                 { catalog, Constants.SCHEMA_MAIN, "TEST", "DATE_V", "" + Types.TIMESTAMP,
571                         "TIMESTAMP", "23", "23", "10", "10",
572                         "" + DatabaseMetaData.columnNullable, "", "", "" + Types.TIMESTAMP,
573                         "0", "23", "4", "YES"},
574                 { catalog, Constants.SCHEMA_MAIN, "TEST", "BLOB_V", "" + Types.BLOB, "BLOB",
575                         ""+Integer.MAX_VALUE, ""+Integer.MAX_VALUE, "0", "10",
576                         "" + DatabaseMetaData.columnNullable, "", "", "" + Types.BLOB,
577                         "0", ""+Integer.MAX_VALUE, "5", "YES"},
578                 { catalog, Constants.SCHEMA_MAIN, "TEST", "CLOB_V", "" + Types.CLOB, "CLOB",
579                             ""+Integer.MAX_VALUE, ""+Integer.MAX_VALUE, "0", "10",
580                         "" + DatabaseMetaData.columnNullable, "", "","" + Types.CLOB,
581                         "0", ""+Integer.MAX_VALUE, "6", "YES"}});
582         /*
583          * rs=meta.getColumns(null,null,"TEST",null); while(rs.next()) { int
584          * datatype=rs.getInt(5); }
585          */

586         trace("getIndexInfo");
587         stat.executeUpdate("CREATE INDEX IDX_TEXT_DEC ON TEST(TEXT_V,DEC_V)");
588         stat.executeUpdate("CREATE UNIQUE INDEX IDX_DATE ON TEST(DATE_V)");
589         rs = meta.getIndexInfo(null, null, "TEST", false, false);
590         testResultSetMeta(rs, 13, new String JavaDoc[] { "TABLE_CAT", "TABLE_SCHEM",
591                 "TABLE_NAME", "NON_UNIQUE", "INDEX_QUALIFIER", "INDEX_NAME",
592                 "TYPE", "ORDINAL_POSITION", "COLUMN_NAME", "ASC_OR_DESC",
593                 "CARDINALITY", "PAGES", "FILTER_CONDITION"}, new int[] {
594                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, DataType.TYPE_BOOLEAN,
595                 Types.VARCHAR, Types.VARCHAR, Types.SMALLINT, Types.SMALLINT,
596                 Types.VARCHAR, Types.VARCHAR, Types.INTEGER, Types.INTEGER,
597                 Types.VARCHAR}, null, null);
598         testResultSetOrdered(rs, new String JavaDoc[][] {
599                 { catalog, Constants.SCHEMA_MAIN, "TEST", "FALSE", catalog, "IDX_DATE",
600                         "" + DatabaseMetaData.tableIndexOther, "1", "DATE_V",
601                         "A", "0", "0", ""},
602                 { catalog, Constants.SCHEMA_MAIN, "TEST", "FALSE", catalog, "PRIMARY_KEY_1",
603                         "" + DatabaseMetaData.tableIndexOther, "1", "ID", "A",
604                         "0", "0", ""},
605                 { catalog, Constants.SCHEMA_MAIN, "TEST", "TRUE", catalog, "IDX_TEXT_DEC",
606                         "" + DatabaseMetaData.tableIndexOther, "1", "TEXT_V",
607                         "A", "0", "0", ""},
608                 { catalog, Constants.SCHEMA_MAIN, "TEST", "TRUE", catalog, "IDX_TEXT_DEC",
609                         "" + DatabaseMetaData.tableIndexOther, "2", "DEC_V",
610                         "A", "0", "0", ""},});
611         stat.executeUpdate("DROP INDEX IDX_TEXT_DEC");
612         stat.executeUpdate("DROP INDEX IDX_DATE");
613         rs = meta.getIndexInfo(null, null, "TEST", false, false);
614         testResultSetMeta(rs, 13, new String JavaDoc[] { "TABLE_CAT", "TABLE_SCHEM",
615                 "TABLE_NAME", "NON_UNIQUE", "INDEX_QUALIFIER", "INDEX_NAME",
616                 "TYPE", "ORDINAL_POSITION", "COLUMN_NAME", "ASC_OR_DESC",
617                 "CARDINALITY", "PAGES", "FILTER_CONDITION"}, new int[] {
618                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, DataType.TYPE_BOOLEAN,
619                 Types.VARCHAR, Types.VARCHAR, Types.SMALLINT, Types.SMALLINT,
620                 Types.VARCHAR, Types.VARCHAR, Types.INTEGER, Types.INTEGER,
621                 Types.VARCHAR}, null, null);
622         testResultSetOrdered(rs, new String JavaDoc[][] { { catalog, Constants.SCHEMA_MAIN, "TEST",
623                 "FALSE", catalog, "PRIMARY_KEY_1",
624                 "" + DatabaseMetaData.tableIndexOther, "1", "ID", "A", "0",
625                 "0", ""}});
626         trace("getPrimaryKeys");
627         rs = meta.getPrimaryKeys(null, null, "TEST");
628         testResultSetMeta(rs, 6, new String JavaDoc[] { "TABLE_CAT", "TABLE_SCHEM",
629                 "TABLE_NAME", "COLUMN_NAME", "KEY_SEQ", "PK_NAME"}, new int[] {
630                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
631                 Types.SMALLINT, Types.VARCHAR}, null, null);
632         testResultSetOrdered(rs, new String JavaDoc[][] { { catalog, Constants.SCHEMA_MAIN, "TEST", "ID",
633                 "1", "PRIMARY_KEY_1"},});
634         trace("getTables - using a wildcard");
635         stat.executeUpdate("CREATE TABLE T_2(B INT,A VARCHAR(6),C INT,PRIMARY KEY(C,A,B))");
636         stat.executeUpdate("CREATE TABLE TX2(B INT,A VARCHAR(6),C INT,PRIMARY KEY(C,A,B))");
637         rs = meta.getTables(null, null, "T_2", null);
638         testResultSetOrdered(rs, new String JavaDoc[][] {
639                 { catalog, Constants.SCHEMA_MAIN, "TX2", "TABLE", ""},
640                 { catalog, Constants.SCHEMA_MAIN, "T_2", "TABLE", ""}});
641         trace("getTables - using a quoted _ character");
642         rs = meta.getTables(null, null, "T\\_2", null);
643         testResultSetOrdered(rs, new String JavaDoc[][] { { catalog, Constants.SCHEMA_MAIN, "T_2", "TABLE",
644                 ""}});
645         trace("getTables - using the % wildcard");
646         rs = meta.getTables(null, Constants.SCHEMA_MAIN, "%", new String JavaDoc[]{"TABLE"});
647         testResultSetOrdered(rs, new String JavaDoc[][] {
648                 { catalog, Constants.SCHEMA_MAIN, "TEST", "TABLE", ""},
649                 { catalog, Constants.SCHEMA_MAIN, "TX2", "TABLE", ""},
650                 { catalog, Constants.SCHEMA_MAIN, "T_2", "TABLE", ""}});
651         stat.execute("DROP TABLE TEST");
652
653         trace("getColumns - using wildcards");
654         rs = meta.getColumns(null, null, "___", "B%");
655         testResultSetOrdered(rs, new String JavaDoc[][] {
656                 { catalog, Constants.SCHEMA_MAIN, "TX2", "B", "" + Types.INTEGER, "INTEGER", "10" /*,
657                         null, "0", "10", "" + DatabaseMetaData.columnNoNulls,
658                         null, null, null, null, null, "1", "NO" */
},
659                 { catalog, Constants.SCHEMA_MAIN, "T_2", "B", "" + Types.INTEGER, "INTEGER", "10" /*,
660                         null, "0", "10", "" + DatabaseMetaData.columnNoNulls,
661                         null, null, null, null, null, "1", "NO" */
},});
662         trace("getColumns - using wildcards");
663         rs = meta.getColumns(null, null, "_\\__", "%");
664         testResultSetOrdered(rs, new String JavaDoc[][] {
665                 { catalog, Constants.SCHEMA_MAIN, "T_2", "B", "" + Types.INTEGER, "INTEGER", "10" /*,
666                         null, "0", "10", "" + DatabaseMetaData.columnNoNulls,
667                         null, null, null, null, null, "1", "NO"*/
},
668                 { catalog, Constants.SCHEMA_MAIN, "T_2", "A", "" + Types.VARCHAR, "VARCHAR", "6" /*,
669                         null, "0", "10", "" + DatabaseMetaData.columnNoNulls,
670                         null, null, null, null, null, "2", "NO"*/
},
671                 { catalog, Constants.SCHEMA_MAIN, "T_2", "C", "" + Types.INTEGER, "INTEGER", "10" /*,
672                         null, "0", "10", "" + DatabaseMetaData.columnNoNulls,
673                         null, null, null, null, null, "3", "NO"*/
},});
674         trace("getIndexInfo");
675         stat.executeUpdate("CREATE UNIQUE INDEX A_INDEX ON TX2(B,C,A)");
676         stat.executeUpdate("CREATE INDEX B_INDEX ON TX2(A,B,C)");
677         rs = meta.getIndexInfo(null, null, "TX2", false, false);
678         testResultSetOrdered(rs, new String JavaDoc[][] {
679                 { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "A_INDEX",
680                         "" + DatabaseMetaData.tableIndexOther, "1", "B", "A" /*,
681                         null, null, null */
},
682                 { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "A_INDEX",
683                         "" + DatabaseMetaData.tableIndexOther, "2", "C", "A" /*,
684                         null, null, null*/
},
685                 { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "A_INDEX",
686                         "" + DatabaseMetaData.tableIndexOther, "3", "A", "A" /*,
687                         null, null, null*/
},
688                 { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "PRIMARY_KEY_3",
689                         "" + DatabaseMetaData.tableIndexOther, "1", "C", "A" /*,
690                         null, null, null*/
},
691                 { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "PRIMARY_KEY_3",
692                         "" + DatabaseMetaData.tableIndexOther, "2", "A", "A" /*,
693                         null, null, null*/
},
694                 { catalog, Constants.SCHEMA_MAIN, "TX2", "FALSE", catalog, "PRIMARY_KEY_3",
695                         "" + DatabaseMetaData.tableIndexOther, "3", "B", "A"/*,
696                         null, null, null*/
},
697                 { catalog, Constants.SCHEMA_MAIN, "TX2", "TRUE", catalog, "B_INDEX",
698                         "" + DatabaseMetaData.tableIndexOther, "1", "A", "A" /*,
699                         null, null, null*/
},
700                 { catalog, Constants.SCHEMA_MAIN, "TX2", "TRUE", catalog, "B_INDEX",
701                         "" + DatabaseMetaData.tableIndexOther, "2", "B", "A" /*,
702                         null, null, null*/
},
703                 { catalog, Constants.SCHEMA_MAIN, "TX2", "TRUE", catalog, "B_INDEX",
704                         "" + DatabaseMetaData.tableIndexOther, "3", "C", "A" /*,
705                         null, null, null*/
},});
706         trace("getPrimaryKeys");
707         rs = meta.getPrimaryKeys(null, null, "T_2");
708         testResultSetOrdered(rs, new String JavaDoc[][] {
709                 { catalog, Constants.SCHEMA_MAIN, "T_2", "A", "2", "PRIMARY_KEY_2"},
710                 { catalog, Constants.SCHEMA_MAIN, "T_2", "B", "3", "PRIMARY_KEY_2"},
711                 { catalog, Constants.SCHEMA_MAIN, "T_2", "C", "1", "PRIMARY_KEY_2"},});
712         stat.executeUpdate("DROP TABLE TX2");
713         stat.executeUpdate("DROP TABLE T_2");
714         stat.executeUpdate("CREATE TABLE PARENT(ID INT PRIMARY KEY)");
715         stat
716                 .executeUpdate("CREATE TABLE CHILD(P_ID INT,ID INT,PRIMARY KEY(P_ID,ID),FOREIGN KEY(P_ID) REFERENCES PARENT(ID))");
717
718         trace("getImportedKeys");
719         rs = meta.getImportedKeys(null, null, "CHILD");
720         testResultSetMeta(rs, 14, new String JavaDoc[] { "PKTABLE_CAT",
721                 "PKTABLE_SCHEM", "PKTABLE_NAME", "PKCOLUMN_NAME",
722                 "FKTABLE_CAT", "FKTABLE_SCHEM", "FKTABLE_NAME",
723                 "FKCOLUMN_NAME", "KEY_SEQ", "UPDATE_RULE", "DELETE_RULE",
724                 "FK_NAME", "PK_NAME", "DEFERRABILITY"}, new int[] {
725                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
726                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
727                 Types.SMALLINT, Types.SMALLINT, Types.SMALLINT, Types.VARCHAR,
728                 Types.VARCHAR, Types.SMALLINT}, null, null);
729         // TODO test
730
// testResultSetOrdered(rs, new String[][] { { null, null, "PARENT", "ID",
731
// null, null, "CHILD", "P_ID", "1",
732
// "" + DatabaseMetaData.importedKeyNoAction,
733
// "" + DatabaseMetaData.importedKeyNoAction, "FK_1", null,
734
// "" + DatabaseMetaData.importedKeyNotDeferrable}});
735

736         trace("getExportedKeys");
737         rs = meta.getExportedKeys(null, null, "PARENT");
738         testResultSetMeta(rs, 14, new String JavaDoc[] { "PKTABLE_CAT",
739                 "PKTABLE_SCHEM", "PKTABLE_NAME", "PKCOLUMN_NAME",
740                 "FKTABLE_CAT", "FKTABLE_SCHEM", "FKTABLE_NAME",
741                 "FKCOLUMN_NAME", "KEY_SEQ", "UPDATE_RULE", "DELETE_RULE",
742                 "FK_NAME", "PK_NAME", "DEFERRABILITY"}, new int[] {
743                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
744                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
745                 Types.SMALLINT, Types.SMALLINT, Types.SMALLINT, Types.VARCHAR,
746                 Types.VARCHAR, Types.SMALLINT}, null, null);
747         // TODO test
748
/*
749          * testResultSetOrdered(rs, new String[][]{ { null,null,"PARENT","ID",
750          * null,null,"CHILD","P_ID",
751          * "1",""+DatabaseMetaData.importedKeyNoAction,""+DatabaseMetaData.importedKeyNoAction,
752          * null,null,""+DatabaseMetaData.importedKeyNotDeferrable } } );
753          */

754         trace("getCrossReference");
755         rs = meta.getCrossReference(null, null, "PARENT", null, null, "CHILD");
756         testResultSetMeta(rs, 14, new String JavaDoc[] { "PKTABLE_CAT",
757                 "PKTABLE_SCHEM", "PKTABLE_NAME", "PKCOLUMN_NAME",
758                 "FKTABLE_CAT", "FKTABLE_SCHEM", "FKTABLE_NAME",
759                 "FKCOLUMN_NAME", "KEY_SEQ", "UPDATE_RULE", "DELETE_RULE",
760                 "FK_NAME", "PK_NAME", "DEFERRABILITY"}, new int[] {
761                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
762                 Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
763                 Types.SMALLINT, Types.SMALLINT, Types.SMALLINT, Types.VARCHAR,
764                 Types.VARCHAR, Types.SMALLINT}, null, null);
765         // TODO test
766
/*
767          * testResultSetOrdered(rs, new String[][]{ { null,null,"PARENT","ID",
768          * null,null,"CHILD","P_ID",
769          * "1",""+DatabaseMetaData.importedKeyNoAction,""+DatabaseMetaData.importedKeyNoAction,
770          * null,null,""+DatabaseMetaData.importedKeyNotDeferrable } } );
771          */

772
773
774
775         rs = meta.getSchemas();
776         testResultSetMeta(rs, 3, new String JavaDoc[] { "TABLE_SCHEM", "TABLE_CATALOG", "IS_DEFAULT"},
777                 new int[] { Types.VARCHAR, Types.VARCHAR, DataType.TYPE_BOOLEAN}, null, null);
778         check(rs.next());
779         check(rs.getString(1), "INFORMATION_SCHEMA");
780         check(rs.next());
781         check(rs.getString(1), "PUBLIC");
782         checkFalse(rs.next());
783
784         rs = meta.getCatalogs();
785         testResultSetMeta(rs, 1, new String JavaDoc[] { "TABLE_CAT"}, new int[] { Types.VARCHAR}, null, null);
786         testResultSetOrdered(rs, new String JavaDoc[][] { { catalog } });
787
788         rs = meta.getTableTypes();
789         testResultSetMeta(rs, 1, new String JavaDoc[] { "TABLE_TYPE"}, new int[] { Types.VARCHAR}, null, null);
790         testResultSetOrdered(rs, new String JavaDoc[][] { { "SYSTEM TABLE" }, { "TABLE" }, { "TABLE LINK" }, {"VIEW" } });
791
792         rs = meta.getTypeInfo();
793         testResultSetMeta(rs, 18, new String JavaDoc[]{
794                     "TYPE_NAME","DATA_TYPE","PRECISION","LITERAL_PREFIX",
795                     "LITERAL_SUFFIX","CREATE_PARAMS","NULLABLE","CASE_SENSITIVE",
796                     "SEARCHABLE","UNSIGNED_ATTRIBUTE","FIXED_PREC_SCALE",
797                     "AUTO_INCREMENT","LOCAL_TYPE_NAME","MINIMUM_SCALE",
798                     "MAXIMUM_SCALE","SQL_DATA_TYPE","SQL_DATETIME_SUB",
799                     "NUM_PREC_RADIX"
800                 },
801                 new int[]{
802                     Types.VARCHAR,Types.SMALLINT,Types.INTEGER,Types.VARCHAR,
803                     Types.VARCHAR,Types.VARCHAR,Types.SMALLINT,DataType.TYPE_BOOLEAN,
804                     Types.SMALLINT,DataType.TYPE_BOOLEAN,DataType.TYPE_BOOLEAN,DataType.TYPE_BOOLEAN,
805                     Types.VARCHAR,Types.SMALLINT,Types.SMALLINT,Types.SMALLINT,
806                     Types.INTEGER,Types.INTEGER
807                 } ,null, null
808         );
809
810         rs = meta.getTablePrivileges(null, null, null);
811         testResultSetMeta(rs, 7, new String JavaDoc[]{
812                     "TABLE_CAT","TABLE_SCHEM","TABLE_NAME","GRANTOR",
813                     "GRANTEE","PRIVILEGE","IS_GRANTABLE"
814                 },
815                 new int[]{
816                     Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,
817                     Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR
818                 } ,null, null
819         );
820
821         rs = meta.getColumnPrivileges(null, null, "TEST", null);
822         testResultSetMeta(rs, 8, new String JavaDoc[]{
823                     "TABLE_CAT","TABLE_SCHEM","TABLE_NAME","COLUMN_NAME","GRANTOR",
824                     "GRANTEE","PRIVILEGE","IS_GRANTABLE"
825                 },
826                 new int[]{
827                     Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,
828                     Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR
829                 } ,null, null
830         );
831
832         check(conn.getWarnings()==null);
833         conn.clearWarnings();
834         check(conn.getWarnings()==null);
835
836     }
837
838 }
839
Popular Tags