001: /*
002: * Copyright (c) 1998-2008 Caucho Technology -- all rights reserved
003: *
004: * This file is part of Resin(R) Open Source
005: *
006: * Each copy or derived work must preserve the copyright notice and this
007: * notice unmodified.
008: *
009: * Resin Open Source is free software; you can redistribute it and/or modify
010: * it under the terms of the GNU General Public License as published by
011: * the Free Software Foundation; either version 2 of the License, or
012: * (at your option) any later version.
013: *
014: * Resin Open Source is distributed in the hope that it will be useful,
015: * but WITHOUT ANY WARRANTY; without even the implied warranty of
016: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
017: * of NON-INFRINGEMENT. See the GNU General Public License for more
018: * details.
019: *
020: * You should have received a copy of the GNU General Public License
021: * along with Resin Open Source; if not, write to the
022: * Free SoftwareFoundation, Inc.
023: * 59 Temple Place, Suite 330
024: * Boston, MA 02111-1307 USA
025: *
026: * @author Scott Ferguson
027: */
028:
029: package com.caucho.db.jdbc;
030:
031: import java.sql.Connection;
032: import java.sql.DatabaseMetaData;
033: import java.sql.ResultSet;
034: import java.sql.RowIdLifetime;
035: import java.sql.SQLException;
036: import java.sql.Types;
037:
038: class DatabaseMetaDataImpl implements DatabaseMetaData {
039: private Connection _conn;
040:
041: DatabaseMetaDataImpl(Connection conn) {
042: _conn = conn;
043: }
044:
045: public java.sql.Connection getConnection() {
046: return _conn;
047: }
048:
049: public String getCatalogTerm() {
050: return "database";
051: }
052:
053: /**
054: * Returns the types supported by mysql.
055: */
056: public java.sql.ResultSet getTypeInfo() throws SQLException {
057: DummyResultSet dummy = new DummyResultSet();
058: dummy.addColumn("TYPE_NAME", Types.VARCHAR);
059: dummy.addColumn("DATA_TYPE", Types.SMALLINT);
060: dummy.addColumn("PRECISION", Types.INTEGER);
061: dummy.addColumn("LITERAL_PREFIX", Types.VARCHAR);
062: dummy.addColumn("LITERAL_SUFFIX", Types.VARCHAR);
063: dummy.addColumn("CREATE_PARAMS", Types.VARCHAR);
064: dummy.addColumn("NULLABLE", Types.SMALLINT);
065: dummy.addColumn("CASE_SENSITIVE", Types.BIT);
066: dummy.addColumn("SEARCHABLE", Types.SMALLINT);
067: dummy.addColumn("UNSIGNED_ATTRIBUTE", Types.BIT);
068: dummy.addColumn("FIXED_PREC_SCALE", Types.BIT);
069: dummy.addColumn("AUTO_INCREMENT", Types.BIT);
070: dummy.addColumn("LOCAL_TYPE_NAME", Types.VARCHAR);
071: dummy.addColumn("MINIMUM_SCALE", Types.SMALLINT);
072: dummy.addColumn("MAXIMUM_SCALE", Types.SMALLINT);
073: dummy.addColumn("SQL_DATA_TYPE", Types.INTEGER);
074: dummy.addColumn("SQL_DATETIME_SUB", Types.INTEGER);
075: dummy.addColumn("NUM_PREC_RADIX", Types.INTEGER);
076:
077: // boolean
078: dummy.addRow("CHAR:16:1::::1:1:1:1:0:0:CHAR:0:0:1::10");
079:
080: // bit
081: dummy.addRow("TINYINT:-7:1::::1:1:1:1:0:0:TINYINT:0:0:254::10");
082:
083: // byte
084: dummy.addRow("TINYINT:-6:3::::1:0:1:1:0:1:TINYINT:0:0:1::10");
085:
086: // short
087: dummy.addRow("SMALLINT:5:5::::1:0:1:1:0:1:SMALLINT:0:0:2::10");
088:
089: // int
090: dummy.addRow("INTEGER:4:10::::1:0:1:1:0:1:INTEGER:0:0:3::10");
091:
092: // long
093: dummy.addRow("BIGINT:-5:20::::1:0:1:1:0:1:BIGINT:0:0:8::10");
094:
095: // float
096: dummy
097: .addRow("FLOAT:6:10:::(M,D) ZEROFILL:1:0:0:1:0:1:FLOAT:3:3:8::10");
098:
099: // real
100: dummy
101: .addRow("FLOAT:7:10:::(M,D) ZEROFILL:1:0:0:1:0:1:FLOAT:3:3:8::10");
102:
103: // double
104: dummy
105: .addRow("DOUBLE:8:10:::(M,D) ZEROFILL:1:0:0:1:0:1:FLOAT:3:3:8::10");
106:
107: // char
108: dummy
109: .addRow("CHAR:1:255:':':(M) BINARY:1:1:1:1:0:0:CHAR:0:0:254::10");
110:
111: // varchar
112: dummy
113: .addRow("VARCHAR:12:255:':':(M) BINARY:1:1:1:1:0:0:VARCHAR:0:0:253::10");
114:
115: // timestamp
116: dummy
117: .addRow("DATETIME:93:0:':'::1:1:1:1:0:0:DATETIME:0:0:253::10");
118:
119: // date
120: dummy
121: .addRow("DATETIME:91:0:':'::1:1:1:1:0:0:DATETIME:0:0:253::10");
122:
123: // time
124: dummy
125: .addRow("DATETIME:92:0:':'::1:1:1:1:0:0:DATETIME:0:0:253::10");
126:
127: // numeric
128: dummy
129: .addRow("NUMERIC:2:10:::(M,D) ZEROFILL:1:0:0:0:1:0:NUMERIC:0:20:3::10");
130: dummy
131: .addRow("NUMERIC:3:10:::(M,D) ZEROFILL:1:0:0:0:1:0:NUMERIC:0:20:3::10");
132:
133: return dummy;
134: }
135:
136: private int typeNameToTypes(String typeName) {
137: int p = typeName.indexOf('(');
138: if (p > 0)
139: typeName = typeName.substring(0, p);
140:
141: if ("varchar".equals(typeName))
142: return Types.VARCHAR;
143: else if ("char".equals(typeName))
144: return Types.VARCHAR;
145: else if ("timestamp".equals(typeName))
146: return Types.TIMESTAMP;
147: else if ("tinyint".equals(typeName))
148: return Types.TINYINT;
149: else if ("integer".equals(typeName))
150: return Types.INTEGER;
151: else if ("bigint".equals(typeName))
152: return Types.BIGINT;
153: else if ("double".equals(typeName))
154: return Types.DOUBLE;
155: else
156: return Types.VARCHAR;
157: }
158:
159: public boolean allProceduresAreCallable() throws SQLException {
160: return true;
161: }
162:
163: public boolean allTablesAreSelectable() throws SQLException {
164: return true;
165: }
166:
167: public String getURL() throws SQLException {
168: return "jdbc:mysql_caucho://localhost:3306/test";
169: }
170:
171: public String getUserName() throws SQLException {
172: return "fergie";
173: }
174:
175: public boolean isReadOnly() throws SQLException {
176: return false;
177: }
178:
179: public boolean nullsAreSortedHigh() throws SQLException {
180: return false;
181: }
182:
183: public boolean nullsAreSortedLow() throws SQLException {
184: return false;
185: }
186:
187: public boolean nullsAreSortedAtStart() throws SQLException {
188: return false;
189: }
190:
191: public boolean nullsAreSortedAtEnd() throws SQLException {
192: return true;
193: }
194:
195: public String getDatabaseProductName() throws SQLException {
196: return "Resin";
197: }
198:
199: public String getDatabaseProductVersion() throws SQLException {
200: return "1.1";
201: }
202:
203: public String getDriverName() throws SQLException {
204: return "Resin Driver";
205: }
206:
207: public String getDriverVersion() throws SQLException {
208: return "1.0";
209: }
210:
211: public int getDriverMajorVersion() {
212: return 1;
213: }
214:
215: public int getDriverMinorVersion() {
216: return 2;
217: }
218:
219: public boolean usesLocalFiles() throws SQLException {
220: return true;
221: }
222:
223: public boolean usesLocalFilePerTable() throws SQLException {
224: return true;
225: }
226:
227: public boolean supportsMixedCaseIdentifiers() throws SQLException {
228: return true;
229: }
230:
231: public boolean storesUpperCaseIdentifiers() throws SQLException {
232: return false;
233: }
234:
235: public boolean storesLowerCaseIdentifiers() throws SQLException {
236: return false;
237: }
238:
239: public boolean storesMixedCaseIdentifiers() throws SQLException {
240: return true;
241: }
242:
243: public boolean supportsMixedCaseQuotedIdentifiers()
244: throws SQLException {
245: return true;
246: }
247:
248: public boolean storesUpperCaseQuotedIdentifiers()
249: throws SQLException {
250: return false;
251: }
252:
253: public boolean storesLowerCaseQuotedIdentifiers()
254: throws SQLException {
255: return false;
256: }
257:
258: public boolean storesMixedCaseQuotedIdentifiers()
259: throws SQLException {
260: return true;
261: }
262:
263: public String getIdentifierQuoteString() throws SQLException {
264: return "`";
265: }
266:
267: public String getSQLKeywords() throws SQLException {
268: return "";
269: }
270:
271: public String getNumericFunctions() throws SQLException {
272: return "";
273: }
274:
275: public String getStringFunctions() throws SQLException {
276: return "";
277: }
278:
279: public String getSystemFunctions() throws SQLException {
280: return "";
281: }
282:
283: public String getTimeDateFunctions() throws SQLException {
284: return "";
285: }
286:
287: public String getSearchStringEscape() throws SQLException {
288: return "\\";
289: }
290:
291: public String getExtraNameCharacters() throws SQLException {
292: return "";
293: }
294:
295: public boolean supportsAlterTableWithAddColumn()
296: throws SQLException {
297: return false;
298: }
299:
300: public boolean supportsAlterTableWithDropColumn()
301: throws SQLException {
302: return false;
303: }
304:
305: public boolean supportsColumnAliasing() throws SQLException {
306: return true;
307: }
308:
309: public boolean nullPlusNonNullIsNull() throws SQLException {
310: return true;
311: }
312:
313: public boolean supportsConvert() throws SQLException {
314: return false;
315: }
316:
317: public boolean supportsConvert(int fromType, int toType)
318: throws SQLException {
319: return false;
320: }
321:
322: public boolean supportsTableCorrelationNames() throws SQLException {
323: return true;
324: }
325:
326: public boolean supportsDifferentTableCorrelationNames()
327: throws SQLException {
328: return false;
329: }
330:
331: public boolean supportsExpressionsInOrderBy() throws SQLException {
332: return false;
333: }
334:
335: public boolean supportsOrderByUnrelated() throws SQLException {
336: return false;
337: }
338:
339: public boolean supportsGroupBy() throws SQLException {
340: return false;
341: }
342:
343: public boolean supportsGroupByUnrelated() throws SQLException {
344: return false;
345: }
346:
347: public boolean supportsGroupByBeyondSelect() throws SQLException {
348: return false;
349: }
350:
351: public boolean supportsLikeEscapeClause() throws SQLException {
352: return false;
353: }
354:
355: public boolean supportsMultipleResultSets() throws SQLException {
356: return false;
357: }
358:
359: public boolean supportsMultipleTransactions() throws SQLException {
360: return false;
361: }
362:
363: public boolean supportsNonNullableColumns() throws SQLException {
364: return true;
365: }
366:
367: public boolean supportsMinimumSQLGrammar() throws SQLException {
368: return true;
369: }
370:
371: public boolean supportsCoreSQLGrammar() throws SQLException {
372: return true;
373: }
374:
375: public boolean supportsExtendedSQLGrammar() throws SQLException {
376: return false;
377: }
378:
379: public boolean supportsANSI92EntryLevelSQL() throws SQLException {
380: return true;
381: }
382:
383: public boolean supportsANSI92IntermediateSQL() throws SQLException {
384: return false;
385: }
386:
387: public boolean supportsANSI92FullSQL() throws SQLException {
388: return false;
389: }
390:
391: public boolean supportsIntegrityEnhancementFacility()
392: throws SQLException {
393: return false;
394: }
395:
396: public boolean supportsOuterJoins() throws SQLException {
397: return false;
398: }
399:
400: public boolean supportsFullOuterJoins() throws SQLException {
401: return false;
402: }
403:
404: public boolean supportsLimitedOuterJoins() throws SQLException {
405: return false;
406: }
407:
408: public String getSchemaTerm() throws SQLException {
409: return "schema";
410: }
411:
412: public String getProcedureTerm() throws SQLException {
413: return "procedure";
414: }
415:
416: public boolean isCatalogAtStart() throws SQLException {
417: return true;
418: }
419:
420: public String getCatalogSeparator() throws SQLException {
421: return ".";
422: }
423:
424: public boolean supportsSchemasInDataManipulation()
425: throws SQLException {
426: return false;
427: }
428:
429: public boolean supportsSchemasInProcedureCalls()
430: throws SQLException {
431: return false;
432: }
433:
434: public boolean supportsSchemasInTableDefinitions()
435: throws SQLException {
436: return false;
437: }
438:
439: public boolean supportsSchemasInIndexDefinitions()
440: throws SQLException {
441: return false;
442: }
443:
444: public boolean supportsSchemasInPrivilegeDefinitions()
445: throws SQLException {
446: return false;
447: }
448:
449: public boolean supportsCatalogsInDataDefinitions()
450: throws SQLException {
451: return false;
452: }
453:
454: public boolean supportsCatalogsInProcedureCalls()
455: throws SQLException {
456: return false;
457: }
458:
459: public boolean supportsCatalogsInTableDefinitions()
460: throws SQLException {
461: return false;
462: }
463:
464: public boolean supportsCatalogsInIndexDefinitions()
465: throws SQLException {
466: return false;
467: }
468:
469: public boolean supportsCatalogsInPrivilegeDefinitions()
470: throws SQLException {
471: return false;
472: }
473:
474: public boolean supportsPositionedDelete() throws SQLException {
475: return false;
476: }
477:
478: public boolean supportsPositionedUpdate() throws SQLException {
479: return false;
480: }
481:
482: public boolean supportsSelectForUpdate() throws SQLException {
483: return false;
484: }
485:
486: public boolean supportsStoredProcedures() throws SQLException {
487: return false;
488: }
489:
490: public boolean supportsSubqueriesInComparisons()
491: throws SQLException {
492: return false;
493: }
494:
495: public boolean supportsSubqueriesInExists() throws SQLException {
496: return false;
497: }
498:
499: public boolean supportsSubqueriesInIns() throws SQLException {
500: return false;
501: }
502:
503: public boolean supportsSubqueriesInQuantifieds()
504: throws SQLException {
505: return false;
506: }
507:
508: public boolean supportsCorrelatedSubqueries() throws SQLException {
509: return false;
510: }
511:
512: public boolean supportsUnion() throws SQLException {
513: return true;
514: }
515:
516: public boolean supportsUnionAll() throws SQLException {
517: return true;
518: }
519:
520: public boolean supportsOpenCursorsAcrossCommit()
521: throws SQLException {
522: return false;
523: }
524:
525: public boolean supportsOpenCursorsAcrossRollback()
526: throws SQLException {
527: return false;
528: }
529:
530: public boolean supportsOpenStatementsAcrossCommit()
531: throws SQLException {
532: return true;
533: }
534:
535: public boolean supportsOpenStatementsAcrossRollback()
536: throws SQLException {
537: return true;
538: }
539:
540: public int getMaxBinaryLiteralLength() throws SQLException {
541: return 16;
542: }
543:
544: public int getMaxCharLiteralLength() throws SQLException {
545: return 254;
546: }
547:
548: public int getMaxColumnNameLength() throws SQLException {
549: return 64;
550: }
551:
552: public int getMaxColumnsInGroupBy() throws SQLException {
553: return 16;
554: }
555:
556: public int getMaxColumnsInIndex() throws SQLException {
557: return 16;
558: }
559:
560: public int getMaxColumnsInOrderBy() throws SQLException {
561: return 16;
562: }
563:
564: public int getMaxColumnsInSelect() throws SQLException {
565: return 16;
566: }
567:
568: public int getMaxColumnsInTable() throws SQLException {
569: return 16;
570: }
571:
572: public int getMaxConnections() throws SQLException {
573: return 16;
574: }
575:
576: public int getMaxCursorNameLength() throws SQLException {
577: return 254;
578: }
579:
580: public int getMaxIndexLength() throws SQLException {
581: return 254;
582: }
583:
584: public int getMaxSchemaNameLength() throws SQLException {
585: return 254;
586: }
587:
588: public int getMaxProcedureNameLength() throws SQLException {
589: return 254;
590: }
591:
592: public int getMaxCatalogNameLength() throws SQLException {
593: return 64;
594: }
595:
596: public int getMaxRowSize() throws SQLException {
597: return 65536;
598: }
599:
600: public int getMaxRowSizeIncludeBlobs() throws SQLException {
601: return 65536;
602: }
603:
604: public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
605: return false;
606: }
607:
608: public int getMaxStatementLength() throws SQLException {
609: return 65536;
610: }
611:
612: public int getMaxStatements() throws SQLException {
613: return 0;
614: }
615:
616: public int getMaxTableNameLength() throws SQLException {
617: return 64;
618: }
619:
620: public int getMaxTablesInSelect() throws SQLException {
621: return 0;
622: }
623:
624: public int getMaxUserNameLength() throws SQLException {
625: return 0;
626: }
627:
628: public int getDefaultTransactionIsolation() throws SQLException {
629: return Connection.TRANSACTION_NONE;
630: }
631:
632: public boolean supportsTransactions() throws SQLException {
633: return true;
634: }
635:
636: public boolean supportsTransactionIsolationLevel(int level)
637: throws SQLException {
638: return false;
639: }
640:
641: public boolean supportsDataDefinitionAndDataManipulationTransactions()
642: throws SQLException {
643: return false;
644: }
645:
646: public boolean supportsDataManipulationTransactionsOnly()
647: throws SQLException {
648: return false;
649: }
650:
651: public boolean supportsCatalogsInDataManipulation()
652: throws SQLException {
653: return false;
654: }
655:
656: public boolean dataDefinitionCausesTransactionCommit()
657: throws SQLException {
658: return false;
659: }
660:
661: public boolean dataDefinitionIgnoredInTransactions()
662: throws SQLException {
663: return false;
664: }
665:
666: public java.sql.ResultSet getProcedures(String catalog,
667: String schemaPattern, String procedureNamePattern)
668: throws SQLException {
669: return null;
670: }
671:
672: public java.sql.ResultSet getProcedureColumns(String catalog,
673: String schemaPattern, String procedureNamePattern,
674: String columnNamePatterns) throws SQLException {
675: return null;
676: }
677:
678: public java.sql.ResultSet getTables(String catalog,
679: String schemaPattern, String tableNamePattern,
680: String[] types) throws SQLException {
681: DummyResultSet dummy = new DummyResultSet();
682:
683: dummy.addColumn("TABLE_CAT", Types.VARCHAR);
684: dummy.addColumn("TABLE_SCHEM", Types.VARCHAR);
685: dummy.addColumn("TABLE_NAME", Types.VARCHAR);
686: dummy.addColumn("TABLE_TYPE", Types.VARCHAR);
687: dummy.addColumn("REMARKS", Types.VARCHAR);
688:
689: return dummy;
690: }
691:
692: public java.sql.ResultSet getSchemas() throws SQLException {
693: return null;
694: }
695:
696: public java.sql.ResultSet getCatalogs() throws SQLException {
697: return null;
698: }
699:
700: public java.sql.ResultSet getTableTypes() throws SQLException {
701: return null;
702: }
703:
704: public java.sql.ResultSet getColumns(String catalog,
705: String schemaPattern, String tableNamePattern,
706: String columnNamePattern) throws SQLException {
707: DummyResultSet dummy = new DummyResultSet();
708:
709: dummy.addColumn("TABLE_CAT", Types.VARCHAR);
710: dummy.addColumn("TABLE_SCHEM", Types.VARCHAR);
711: dummy.addColumn("TABLE_NAME", Types.VARCHAR);
712: dummy.addColumn("COLUMN_NAME", Types.VARCHAR);
713: dummy.addColumn("DATA_TYPE", Types.SMALLINT);
714: dummy.addColumn("TYPE_NAME", Types.VARCHAR);
715: dummy.addColumn("COLUMN_SIZE", Types.INTEGER);
716: dummy.addColumn("BUFFER_LENGTH", Types.INTEGER);
717: dummy.addColumn("DECIMAL_DIGITS", Types.INTEGER);
718: dummy.addColumn("NUM_PREC_RADIX", Types.INTEGER);
719: dummy.addColumn("NULLABLE", Types.INTEGER);
720: dummy.addColumn("REMARKS", Types.VARCHAR);
721: dummy.addColumn("COLUMN_DEF", Types.VARCHAR);
722: dummy.addColumn("SQL_DATA_TYPE", Types.INTEGER);
723: dummy.addColumn("SQL_DATETIME_SUB", Types.INTEGER);
724: dummy.addColumn("CHAR_OCTET_LENGTH", Types.INTEGER);
725: dummy.addColumn("ORDINAL_POSITION", Types.INTEGER);
726: dummy.addColumn("IS_NULLABLE", Types.VARCHAR);
727:
728: return dummy;
729: }
730:
731: public java.sql.ResultSet getColumnPrivileges(String catalog,
732: String schemaPattern, String tableNamePattern,
733: String columnNamePattern) throws SQLException {
734: return new DummyResultSet();
735: }
736:
737: public java.sql.ResultSet getTable(String catalog,
738: String schemaPattern, String tableNamePattern)
739: throws SQLException {
740: return new DummyResultSet();
741: }
742:
743: public java.sql.ResultSet getTablePrivileges(String catalog,
744: String schemaPattern, String tableNamePattern)
745: throws SQLException {
746: return new DummyResultSet();
747: }
748:
749: public java.sql.ResultSet getBestRowIdentifier(String catalog,
750: String schema, String table, int scope, boolean nullable)
751: throws SQLException {
752: return new DummyResultSet();
753: }
754:
755: public java.sql.ResultSet getVersionColumns(String catalog,
756: String schema, String table) throws SQLException {
757: return new DummyResultSet();
758: }
759:
760: public java.sql.ResultSet getPrimaryKeys(String catalog,
761: String schema, String table) throws SQLException {
762: return new DummyResultSet();
763: }
764:
765: public java.sql.ResultSet getImportedKeys(String catalog,
766: String schema, String table) throws SQLException {
767: return new DummyResultSet();
768: }
769:
770: public java.sql.ResultSet getExportedKeys(String catalog,
771: String schema, String table) throws SQLException {
772: return new DummyResultSet();
773: }
774:
775: public java.sql.ResultSet getCrossReference(String primaryCatalog,
776: String primarySchema, String primaryTable,
777: String foreignCatalog, String foreignSchema,
778: String foreignTable) throws SQLException {
779: return new DummyResultSet();
780: }
781:
782: public java.sql.ResultSet getIndexInfo(String catalog,
783: String schema, String table, boolean unique,
784: boolean approximate) throws SQLException {
785: return new DummyResultSet();
786: }
787:
788: public boolean supportsResultSetType(int type) throws SQLException {
789: return false;
790: }
791:
792: public boolean supportsResultSetConcurrency(int type,
793: int concurrency) throws SQLException {
794: return false;
795: }
796:
797: public boolean ownUpdatesAreVisible(int type) throws SQLException {
798: return false;
799: }
800:
801: public boolean ownDeletesAreVisible(int type) throws SQLException {
802: return false;
803: }
804:
805: public boolean ownInsertsAreVisible(int type) throws SQLException {
806: return false;
807: }
808:
809: public boolean othersUpdatesAreVisible(int type)
810: throws SQLException {
811: return false;
812: }
813:
814: public boolean othersDeletesAreVisible(int type)
815: throws SQLException {
816: return false;
817: }
818:
819: public boolean othersInsertsAreVisible(int type)
820: throws SQLException {
821: return false;
822: }
823:
824: public boolean updatesAreDetected(int type) throws SQLException {
825: return false;
826: }
827:
828: public boolean deletesAreDetected(int type) throws SQLException {
829: return false;
830: }
831:
832: public boolean insertsAreDetected(int type) throws SQLException {
833: return false;
834: }
835:
836: public boolean supportsBatchUpdates() throws SQLException {
837: return false;
838: }
839:
840: public boolean supportsStatementPooling() throws SQLException {
841: return false;
842: }
843:
844: public boolean supportsUpdateCpy() throws SQLException {
845: return false;
846: }
847:
848: public boolean locatorsUpdateCopy() throws SQLException {
849: return false;
850: }
851:
852: public int getSQLStateType() throws SQLException {
853: return 0;
854: }
855:
856: public int getJDBCMajorVersion() throws SQLException {
857: return 2;
858: }
859:
860: public int getJDBCMinorVersion() throws SQLException {
861: return 0;
862: }
863:
864: public int getResultSetHoldability() throws SQLException {
865: return 0;
866: }
867:
868: public boolean supportsResultSetHoldability() throws SQLException {
869: return false;
870: }
871:
872: public boolean supportsResultSetHoldability(int holdability)
873: throws SQLException {
874: return false;
875: }
876:
877: public java.sql.ResultSet getAttributes(String a, String b,
878: String c, String g) throws SQLException {
879: return null;
880: }
881:
882: public java.sql.ResultSet getSuperTypes(String a, String b, String c)
883: throws SQLException {
884: return null;
885: }
886:
887: public java.sql.ResultSet getSuperTables(String a, String b,
888: String c) throws SQLException {
889: return null;
890: }
891:
892: public boolean supportsGetGeneratedKeys() throws SQLException {
893: return true;
894: }
895:
896: public boolean supportsMultipleOpenResults() throws SQLException {
897: return false;
898: }
899:
900: public boolean supportsNamedParameters() throws SQLException {
901: return false;
902: }
903:
904: public boolean supportsSavepoints() throws SQLException {
905: return false;
906: }
907:
908: public int getDatabaseMajorVersion() throws SQLException {
909: return 0;
910: }
911:
912: public int getDatabaseMinorVersion() throws SQLException {
913: return 0;
914: }
915:
916: public java.sql.ResultSet getUDTs(String catalog,
917: String schemaPattern, String typeNamePattern, int[] types)
918: throws SQLException {
919: return null;
920: }
921:
922: public String toString() {
923: return "DatabaseMetaDataImpl[]";
924: }
925:
926: public RowIdLifetime getRowIdLifetime() throws SQLException {
927: throw new UnsupportedOperationException("Not supported yet.");
928: }
929:
930: public ResultSet getSchemas(String catalog, String schemaPattern)
931: throws SQLException {
932: throw new UnsupportedOperationException("Not supported yet.");
933: }
934:
935: public boolean supportsStoredFunctionsUsingCallSyntax()
936: throws SQLException {
937: throw new UnsupportedOperationException("Not supported yet.");
938: }
939:
940: public boolean autoCommitFailureClosesAllResultSets()
941: throws SQLException {
942: throw new UnsupportedOperationException("Not supported yet.");
943: }
944:
945: public ResultSet getClientInfoProperties() throws SQLException {
946: throw new UnsupportedOperationException("Not supported yet.");
947: }
948:
949: public ResultSet getFunctions(String catalog, String schemaPattern,
950: String functionNamePattern) throws SQLException {
951: throw new UnsupportedOperationException("Not supported yet.");
952: }
953:
954: public ResultSet getFunctionColumns(String catalog,
955: String schemaPattern, String functionNamePattern,
956: String columnNamePattern) throws SQLException {
957: throw new UnsupportedOperationException("Not supported yet.");
958: }
959:
960: public <T> T unwrap(Class<T> iface) throws SQLException {
961: throw new UnsupportedOperationException("Not supported yet.");
962: }
963:
964: public boolean isWrapperFor(Class<?> iface) throws SQLException {
965: throw new UnsupportedOperationException("Not supported yet.");
966: }
967: }
|