| products/sources/formale sprachen/PVS/Sturm/ |
|
Quellcode-Bibliothek© Kompilation durch diese Firma[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]Datei: DatabaseMetaData.java Sprache: JAVA |
|
||||||
|
/*
* Copyright (c) 1996, 2022, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.sql; /** * Comprehensive information about the database as a whole. * <P> * This interface is implemented by driver vendors to let users know the capabilities * of a Database Management System (DBMS) in combination with * the driver based on JDBC technology * ("JDBC driver") that is used with it. Different relational DBMSs often support * different features, implement features in different ways, and use different * data types. In addition, a driver may implement a feature on top of what the * DBMS offers. Information returned by methods in this interface applies * to the capabilities of a particular driver and a particular DBMS working * together. Note that as used in this documentation, the term "database" is * used generically to refer to both the driver and DBMS. * <P> * A user for this interface is commonly a tool that needs to discover how to * deal with the underlying DBMS. This is especially true for applications * that are intended to be used with more than one DBMS. For example, a tool might use the method * {@code getTypeInfo} to find out what data types can be used in a * {@code CREATE TABLE} statement. Or a user might call the method * {@code supportsCorrelatedSubqueries} to see if it is possible to use * a correlated subquery or {@code supportsBatchUpdates} to see if it is * possible to use batch updates. * <P> * Some {@code DatabaseMetaData} methods return lists of information * in the form of {@code ResultSet} objects. * Regular {@code ResultSet} methods, such as * {@code getString} and {@code getInt}, can be used * to retrieve the data from these {@code ResultSet} objects. If * a given form of metadata is not available, an empty {@code ResultSet} * will be returned. Additional columns beyond the columns defined to be * returned by the {@code ResultSet} object for a given method * can be defined by the JDBC driver vendor and must be accessed * by their <B>column label</B>. * <P> * Some {@code DatabaseMetaData} methods take arguments that are * String patterns. These arguments all have names such as fooPattern. * Within a pattern String, "%" means match any substring of 0 or more * characters, and "_" means match any one character. Only metadata * entries matching the search pattern are returned. If a search pattern * argument is set to {@code null}, that argument's criterion will * be dropped from the search. * * @since 1.1 */ public interface DatabaseMetaData extends Wrapper { //---------------------------------------------------------------------- // First, a variety of minor information about the target database. /** * Retrieves whether the current user can call all the procedures * returned by the method {@code getProcedures}. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean allProceduresAreCallable() throws SQLException; /** * Retrieves whether the current user can use all the tables returned * by the method {@code getTables} in a {@code SELECT} * statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean allTablesAreSelectable() throws SQLException; /** * Retrieves the URL for this DBMS. * * @return the URL for this DBMS or {@code null} if it cannot be * generated * @throws SQLException if a database access error occurs */ String getURL() throws SQLException; /** * Retrieves the user name as known to this database. * * @return the database user name * @throws SQLException if a database access error occurs */ String getUserName() throws SQLException; /** * Retrieves whether this database is in read-only mode. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean isReadOnly() throws SQLException; /** * Retrieves whether {@code NULL} values are sorted high. * Sorted high means that {@code NULL} values * sort higher than any other value in a domain. In an ascending order, * if this method returns {@code true}, {@code NULL} values * will appear at the end. By contrast, the method * {@code nullsAreSortedAtEnd} indicates whether {@code NULL} values * are sorted at the end regardless of sort order. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean nullsAreSortedHigh() throws SQLException; /** * Retrieves whether {@code NULL} values are sorted low. * Sorted low means that {@code NULL} values * sort lower than any other value in a domain. In an ascending order, * if this method returns {@code true}, {@code NULL} values * will appear at the beginning. By contrast, the method * {@code nullsAreSortedAtStart} indicates whether {@code NULL} values * are sorted at the beginning regardless of sort order. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean nullsAreSortedLow() throws SQLException; /** * Retrieves whether {@code NULL} values are sorted at the start regardless * of sort order. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean nullsAreSortedAtStart() throws SQLException; /** * Retrieves whether {@code NULL} values are sorted at the end regardless of * sort order. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean nullsAreSortedAtEnd() throws SQLException; /** * Retrieves the name of this database product. * * @return database product name * @throws SQLException if a database access error occurs */ String getDatabaseProductName() throws SQLException; /** * Retrieves the version number of this database product. * * @return database version number * @throws SQLException if a database access error occurs */ String getDatabaseProductVersion() throws SQLException; /** * Retrieves the name of this JDBC driver. * * @return JDBC driver name * @throws SQLException if a database access error occurs */ String getDriverName() throws SQLException; /** * Retrieves the version number of this JDBC driver as a {@code String}. * * @return JDBC driver version * @throws SQLException if a database access error occurs */ String getDriverVersion() throws SQLException; /** * Retrieves this JDBC driver's major version number. * * @return JDBC driver major version */ int getDriverMajorVersion(); /** * Retrieves this JDBC driver's minor version number. * * @return JDBC driver minor version number */ int getDriverMinorVersion(); /** * Retrieves whether this database stores tables in a local file. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean usesLocalFiles() throws SQLException; /** * Retrieves whether this database uses a file for each table. * * @return {@code true} if this database uses a local file for each table; * {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean usesLocalFilePerTable() throws SQLException; /** * Retrieves whether this database treats mixed case unquoted SQL identifiers as * case sensitive and as a result stores them in mixed case. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsMixedCaseIdentifiers() throws SQLException; /** * Retrieves whether this database treats mixed case unquoted SQL identifiers as * case insensitive and stores them in upper case. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean storesUpperCaseIdentifiers() throws SQLException; /** * Retrieves whether this database treats mixed case unquoted SQL identifiers as * case insensitive and stores them in lower case. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean storesLowerCaseIdentifiers() throws SQLException; /** * Retrieves whether this database treats mixed case unquoted SQL identifiers as * case insensitive and stores them in mixed case. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean storesMixedCaseIdentifiers() throws SQLException; /** * Retrieves whether this database treats mixed case quoted SQL identifiers as * case sensitive and as a result stores them in mixed case. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsMixedCaseQuotedIdentifiers() throws SQLException; /** * Retrieves whether this database treats mixed case quoted SQL identifiers as * case insensitive and stores them in upper case. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean storesUpperCaseQuotedIdentifiers() throws SQLException; /** * Retrieves whether this database treats mixed case quoted SQL identifiers as * case insensitive and stores them in lower case. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean storesLowerCaseQuotedIdentifiers() throws SQLException; /** * Retrieves whether this database treats mixed case quoted SQL identifiers as * case insensitive and stores them in mixed case. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean storesMixedCaseQuotedIdentifiers() throws SQLException; /** * Retrieves the string used to quote SQL identifiers. * This method returns a space " " if identifier quoting is not supported. * * @return the quoting string or a space if quoting is not supported * @throws SQLException if a database access error occurs */ String getIdentifierQuoteString() throws SQLException; /** * Retrieves a comma-separated list of all of this database's SQL keywords * that are NOT also SQL:2003 keywords. * * @return the list of this database's keywords that are not also * SQL:2003 keywords * @throws SQLException if a database access error occurs */ String getSQLKeywords() throws SQLException; /** * Retrieves a comma-separated list of math functions available with * this database. These are the Open /Open CLI math function names used in * the JDBC function escape clause. * * @return the list of math functions supported by this database * @throws SQLException if a database access error occurs */ String getNumericFunctions() throws SQLException; /** * Retrieves a comma-separated list of string functions available with * this database. These are the Open Group CLI string function names used * in the JDBC function escape clause. * * @return the list of string functions supported by this database * @throws SQLException if a database access error occurs */ String getStringFunctions() throws SQLException; /** * Retrieves a comma-separated list of system functions available with * this database. These are the Open Group CLI system function names used * in the JDBC function escape clause. * * @return a list of system functions supported by this database * @throws SQLException if a database access error occurs */ String getSystemFunctions() throws SQLException; /** * Retrieves a comma-separated list of the time and date functions available * with this database. * * @return the list of time and date functions supported by this database * @throws SQLException if a database access error occurs */ String getTimeDateFunctions() throws SQLException; /** * Retrieves the string that can be used to escape wildcard characters. * This is the string that can be used to escape '_' or '%' in * the catalog search parameters that are a pattern (and therefore use one * of the wildcard characters). * * <P>The '_' character represents any single character; * the '%' character represents any sequence of zero or * more characters. * * @return the string used to escape wildcard characters * @throws SQLException if a database access error occurs */ String getSearchStringEscape() throws SQLException; /** * Retrieves all the "extra" characters that can be used in unquoted * identifier names (those beyond a-z, A-Z, 0-9 and _). * * @return the string containing the extra characters * @throws SQLException if a database access error occurs */ String getExtraNameCharacters() throws SQLException; //-------------------------------------------------------------------- // Functions describing which features are supported. /** * Retrieves whether this database supports {@code ALTER TABLE} * with add column. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsAlterTableWithAddColumn() throws SQLException; /** * Retrieves whether this database supports {@code ALTER TABLE} * with drop column. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsAlterTableWithDropColumn() throws SQLException; /** * Retrieves whether this database supports column aliasing. * * <P>If so, the SQL AS clause can be used to provide names for * computed columns or to provide alias names for columns as * required. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsColumnAliasing() throws SQLException; /** * Retrieves whether this database supports concatenations between * {@code NULL} and non-{@code NULL} values being * {@code NULL}. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean nullPlusNonNullIsNull() throws SQLException; /** * Retrieves whether this database supports the JDBC scalar function * {@code CONVERT} for the conversion of one JDBC type to another. * The JDBC types are the generic SQL data types defined * in {@code java.sql.Types}. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsConvert() throws SQLException; /** * Retrieves whether this database supports the JDBC scalar function * {@code CONVERT} for conversions between the JDBC types <i>fromType</i> * and <i>toType</i>. The JDBC types are the generic SQL data types defined * in {@code java.sql.Types}. * * @param fromType the type to convert from; one of the type codes from * the class {@code java.sql.Types} * @param toType the type to convert to; one of the type codes from * the class {@code java.sql.Types} * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs * @see Types */ boolean supportsConvert(int fromType, int toType) throws SQLException; /** * Retrieves whether this database supports table correlation names. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsTableCorrelationNames() throws SQLException; /** * Retrieves whether, when table correlation names are supported, they * are restricted to being different from the names of the tables. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsDifferentTableCorrelationNames() throws SQLException; /** * Retrieves whether this database supports expressions in * {@code ORDER BY} lists. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsExpressionsInOrderBy() throws SQLException; /** * Retrieves whether this database supports using a column that is * not in the {@code SELECT} statement in an * {@code ORDER BY} clause. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsOrderByUnrelated() throws SQLException; /** * Retrieves whether this database supports some form of * {@code GROUP BY} clause. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsGroupBy() throws SQLException; /** * Retrieves whether this database supports using a column that is * not in the {@code SELECT} statement in a * {@code GROUP BY} clause. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsGroupByUnrelated() throws SQLException; /** * Retrieves whether this database supports using columns not included in * the {@code SELECT} statement in a {@code GROUP BY} clause * provided that all of the columns in the {@code SELECT} statement * are included in the {@code GROUP BY} clause. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsGroupByBeyondSelect() throws SQLException; /** * Retrieves whether this database supports specifying a * {@code LIKE} escape clause. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsLikeEscapeClause() throws SQLException; /** * Retrieves whether this database supports getting multiple * {@code ResultSet} objects from a single call to the * method {@code execute}. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsMultipleResultSets() throws SQLException; /** * Retrieves whether this database allows having multiple * transactions open at once (on different connections). * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsMultipleTransactions() throws SQLException; /** * Retrieves whether columns in this database may be defined as non-nullable. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsNonNullableColumns() throws SQLException; /** * Retrieves whether this database supports the ODBC Minimum SQL grammar. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsMinimumSQLGrammar() throws SQLException; /** * Retrieves whether this database supports the ODBC Core SQL grammar. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsCoreSQLGrammar() throws SQLException; /** * Retrieves whether this database supports the ODBC Extended SQL grammar. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsExtendedSQLGrammar() throws SQLException; /** * Retrieves whether this database supports the ANSI92 entry level SQL * grammar. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsANSI92EntryLevelSQL() throws SQLException; /** * Retrieves whether this database supports the ANSI92 intermediate SQL grammar supported. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsANSI92IntermediateSQL() throws SQLException; /** * Retrieves whether this database supports the ANSI92 full SQL grammar supported. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsANSI92FullSQL() throws SQLException; /** * Retrieves whether this database supports the SQL Integrity * Enhancement Facility. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsIntegrityEnhancementFacility() throws SQLException; /** * Retrieves whether this database supports some form of outer join. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsOuterJoins() throws SQLException; /** * Retrieves whether this database supports full nested outer joins. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsFullOuterJoins() throws SQLException; /** * Retrieves whether this database provides limited support for outer * joins. (This will be {@code true} if the method * {@code supportsFullOuterJoins} returns {@code true}). * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsLimitedOuterJoins() throws SQLException; /** * Retrieves the database vendor's preferred term for "schema". * * @return the vendor term for "schema" * @throws SQLException if a database access error occurs */ String getSchemaTerm() throws SQLException; /** * Retrieves the database vendor's preferred term for "procedure". * * @return the vendor term for "procedure" * @throws SQLException if a database access error occurs */ String getProcedureTerm() throws SQLException; /** * Retrieves the database vendor's preferred term for "catalog". * * @return the vendor term for "catalog" * @throws SQLException if a database access error occurs */ String getCatalogTerm() throws SQLException; /** * Retrieves whether a catalog appears at the start of a fully qualified * table name. If not, the catalog appears at the end. * * @return {@code true} if the catalog name appears at the beginning * of a fully qualified table name; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean isCatalogAtStart() throws SQLException; /** * Retrieves the {@code String} that this database uses as the * separator between a catalog and table name. * * @return the separator string * @throws SQLException if a database access error occurs */ String getCatalogSeparator() throws SQLException; /** * Retrieves whether a schema name can be used in a data manipulation statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsSchemasInDataManipulation() throws SQLException; /** * Retrieves whether a schema name can be used in a procedure call statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsSchemasInProcedureCalls() throws SQLException; /** * Retrieves whether a schema name can be used in a table definition statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsSchemasInTableDefinitions() throws SQLException; /** * Retrieves whether a schema name can be used in an index definition statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsSchemasInIndexDefinitions() throws SQLException; /** * Retrieves whether a schema name can be used in a privilege definition statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsSchemasInPrivilegeDefinitions() throws SQLException; /** * Retrieves whether a catalog name can be used in a data manipulation statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsCatalogsInDataManipulation() throws SQLException; /** * Retrieves whether a catalog name can be used in a procedure call statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsCatalogsInProcedureCalls() throws SQLException; /** * Retrieves whether a catalog name can be used in a table definition statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsCatalogsInTableDefinitions() throws SQLException; /** * Retrieves whether a catalog name can be used in an index definition statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsCatalogsInIndexDefinitions() throws SQLException; /** * Retrieves whether a catalog name can be used in a privilege definition statement. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException; /** * Retrieves whether this database supports positioned {@code DELETE} * statements. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsPositionedDelete() throws SQLException; /** * Retrieves whether this database supports positioned {@code UPDATE} * statements. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsPositionedUpdate() throws SQLException; /** * Retrieves whether this database supports {@code SELECT FOR UPDATE} * statements. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsSelectForUpdate() throws SQLException; /** * Retrieves whether this database supports stored procedure calls * that use the stored procedure escape syntax. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsStoredProcedures() throws SQLException; /** * Retrieves whether this database supports subqueries in comparison * expressions. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsSubqueriesInComparisons() throws SQLException; /** * Retrieves whether this database supports subqueries in * {@code EXISTS} expressions. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsSubqueriesInExists() throws SQLException; /** * Retrieves whether this database supports subqueries in * {@code IN} expressions. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsSubqueriesInIns() throws SQLException; /** * Retrieves whether this database supports subqueries in quantified * expressions. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsSubqueriesInQuantifieds() throws SQLException; /** * Retrieves whether this database supports correlated subqueries. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsCorrelatedSubqueries() throws SQLException; /** * Retrieves whether this database supports SQL {@code UNION}. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsUnion() throws SQLException; /** * Retrieves whether this database supports SQL {@code UNION ALL}. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsUnionAll() throws SQLException; /** * Retrieves whether this database supports keeping cursors open * across commits. * * @return {@code true} if cursors always remain open; * {@code false} if they might not remain open * @throws SQLException if a database access error occurs */ boolean supportsOpenCursorsAcrossCommit() throws SQLException; /** * Retrieves whether this database supports keeping cursors open * across rollbacks. * * @return {@code true} if cursors always remain open; * {@code false} if they might not remain open * @throws SQLException if a database access error occurs */ boolean supportsOpenCursorsAcrossRollback() throws SQLException; /** * Retrieves whether this database supports keeping statements open * across commits. * * @return {@code true} if statements always remain open; * {@code false} if they might not remain open * @throws SQLException if a database access error occurs */ boolean supportsOpenStatementsAcrossCommit() throws SQLException; /** * Retrieves whether this database supports keeping statements open * across rollbacks. * * @return {@code true} if statements always remain open; * {@code false} if they might not remain open * @throws SQLException if a database access error occurs */ boolean supportsOpenStatementsAcrossRollback() throws SQLException; //---------------------------------------------------------------------- // The following group of methods exposes various limitations // based on the target database with the current driver. // Unless otherwise specified, a result of zero means there is no // limit, or the limit is not known. /** * Retrieves the maximum number of hex characters this database allows in an * inline binary literal. * * @return max the maximum length (in hex characters) for a binary literal; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxBinaryLiteralLength() throws SQLException; /** * Retrieves the maximum number of characters this database allows * for a character literal. * * @return the maximum number of characters allowed for a character literal; * a result of zero means that there is no limit or the limit is * not known * @throws SQLException if a database access error occurs */ int getMaxCharLiteralLength() throws SQLException; /** * Retrieves the maximum number of characters this database allows * for a column name. * * @return the maximum number of characters allowed for a column name; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxColumnNameLength() throws SQLException; /** * Retrieves the maximum number of columns this database allows in a * {@code GROUP BY} clause. * * @return the maximum number of columns allowed; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxColumnsInGroupBy() throws SQLException; /** * Retrieves the maximum number of columns this database allows in an index. * * @return the maximum number of columns allowed; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxColumnsInIndex() throws SQLException; /** * Retrieves the maximum number of columns this database allows in an * {@code ORDER BY} clause. * * @return the maximum number of columns allowed; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxColumnsInOrderBy() throws SQLException; /** * Retrieves the maximum number of columns this database allows in a * {@code SELECT} list. * * @return the maximum number of columns allowed; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxColumnsInSelect() throws SQLException; /** * Retrieves the maximum number of columns this database allows in a table. * * @return the maximum number of columns allowed; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxColumnsInTable() throws SQLException; /** * Retrieves the maximum number of concurrent connections to this * database that are possible. * * @return the maximum number of active connections possible at one time; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxConnections() throws SQLException; /** * Retrieves the maximum number of characters that this database allows in a * cursor name. * * @return the maximum number of characters allowed in a cursor name; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxCursorNameLength() throws SQLException; /** * Retrieves the maximum number of bytes this database allows for an * index, including all of the parts of the index. * * @return the maximum number of bytes allowed; this limit includes the * composite of all the constituent parts of the index; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxIndexLength() throws SQLException; /** * Retrieves the maximum number of characters that this database allows in a * schema name. * * @return the maximum number of characters allowed in a schema name; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxSchemaNameLength() throws SQLException; /** * Retrieves the maximum number of characters that this database allows in a * procedure name. * * @return the maximum number of characters allowed in a procedure name; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxProcedureNameLength() throws SQLException; /** * Retrieves the maximum number of characters that this database allows in a * catalog name. * * @return the maximum number of characters allowed in a catalog name; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxCatalogNameLength() throws SQLException; /** * Retrieves the maximum number of bytes this database allows in * a single row. * * @return the maximum number of bytes allowed for a row; a result of * zero means that there is no limit or the limit is not known * @throws SQLException if a database access error occurs */ int getMaxRowSize() throws SQLException; /** * Retrieves whether the return value for the method * {@code getMaxRowSize} includes the SQL data types * {@code LONGVARCHAR} and {@code LONGVARBINARY}. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean doesMaxRowSizeIncludeBlobs() throws SQLException; /** * Retrieves the maximum number of characters this database allows in * an SQL statement. * * @return the maximum number of characters allowed for an SQL statement; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxStatementLength() throws SQLException; /** * Retrieves the maximum number of active statements to this database * that can be open at the same time. * * @return the maximum number of statements that can be open at one time; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxStatements() throws SQLException; /** * Retrieves the maximum number of characters this database allows in * a table name. * * @return the maximum number of characters allowed for a table name; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxTableNameLength() throws SQLException; /** * Retrieves the maximum number of tables this database allows in a * {@code SELECT} statement. * * @return the maximum number of tables allowed in a {@code SELECT} * statement; a result of zero means that there is no limit or * the limit is not known * @throws SQLException if a database access error occurs */ int getMaxTablesInSelect() throws SQLException; /** * Retrieves the maximum number of characters this database allows in * a user name. * * @return the maximum number of characters allowed for a user name; * a result of zero means that there is no limit or the limit * is not known * @throws SQLException if a database access error occurs */ int getMaxUserNameLength() throws SQLException; //---------------------------------------------------------------------- /** * Retrieves this database's default transaction isolation level. The * possible values are defined in {@code java.sql.Connection}. * * @return the default isolation level * @throws SQLException if a database access error occurs * @see Connection */ int getDefaultTransactionIsolation() throws SQLException; /** * Retrieves whether this database supports transactions. If not, invoking the * method {@code commit} is a noop, and the isolation level is * {@code TRANSACTION_NONE}. * * @return {@code true} if transactions are supported; * {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsTransactions() throws SQLException; /** * Retrieves whether this database supports the given transaction isolation level. * * @param level one of the transaction isolation levels defined in * {@code java.sql.Connection} * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs * @see Connection */ boolean supportsTransactionIsolationLevel(int level) throws SQLException; /** * Retrieves whether this database supports both data definition and * data manipulation statements within a transaction. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException; /** * Retrieves whether this database supports only data manipulation * statements within a transaction. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean supportsDataManipulationTransactionsOnly() throws SQLException; /** * Retrieves whether a data definition statement within a transaction forces * the transaction to commit. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean dataDefinitionCausesTransactionCommit() throws SQLException; /** * Retrieves whether this database ignores a data definition statement * within a transaction. * * @return {@code true} if so; {@code false} otherwise * @throws SQLException if a database access error occurs */ boolean dataDefinitionIgnoredInTransactions() throws SQLException; /** * Retrieves a description of the stored procedures available in the given * catalog. * <P> * Only procedure descriptions matching the schema and * procedure name criteria are returned. They are ordered by * {@code PROCEDURE_CAT}, {@code PROCEDURE_SCHEM}, * {@code PROCEDURE_NAME} and {@code SPECIFIC_ NAME}. * * <P>Each procedure description has the following columns: * <OL> * <LI><B>PROCEDURE_CAT</B> String {@code =>} procedure catalog (may be {@code null}) * <LI><B>PROCEDURE_SCHEM</B> String {@code =>} procedure schema (may be {@code null}) * <LI><B>PROCEDURE_NAME</B> String {@code =>} procedure name * <LI> reserved for future use * <LI> reserved for future use * <LI> reserved for future use * <LI><B>REMARKS</B> String {@code =>} explanatory comment on the procedure * <LI><B>PROCEDURE_TYPE</B> short {@code =>} kind of procedure: * <UL> * <LI> procedureResultUnknown - Cannot determine if a return value * will be returned * <LI> procedureNoResult - Does not return a return value * <LI> procedureReturnsResult - Returns a return value * </UL> * <LI><B>SPECIFIC_NAME</B> String {@code =>} The name which uniquely identifies this * procedure within its schema. * </OL> * <p> * A user may not have permissions to execute any of the procedures that are * returned by {@code getProcedures} * * @param catalog a catalog name; must match the catalog name as it * is stored in the database; "" retrieves those without a catalog; * {@code null} means that the catalog name should not be used to narrow * the search * @param schemaPattern a schema name pattern; must match the schema name * as it is stored in the database; "" retrieves those without a schema; * {@code null} means that the schema name should not be used to narrow * the search * @param procedureNamePattern a procedure name pattern; must match the * procedure name as it is stored in the database * @return {@code ResultSet} - each row is a procedure description * @throws SQLException if a database access error occurs * @see #getSearchStringEscape */ ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException; /** * Indicates that it is not known whether the procedure returns * a result. * <P> * A possible value for column {@code PROCEDURE_TYPE} in the * {@code ResultSet} object returned by the method * {@code getProcedures}. */ int procedureResultUnknown = 0; /** * Indicates that the procedure does not return a result. * <P> * A possible value for column {@code PROCEDURE_TYPE} in the * {@code ResultSet} object returned by the method * {@code getProcedures}. */ int procedureNoResult = 1; /** * Indicates that the procedure returns a result. * <P> * A possible value for column {@code PROCEDURE_TYPE} in the * {@code ResultSet} object returned by the method * {@code getProcedures}. */ int procedureReturnsResult = 2; /** * Retrieves a description of the given catalog's stored procedure parameter * and result columns. * * <P>Only descriptions matching the schema, procedure and * parameter name criteria are returned. They are ordered by * PROCEDURE_CAT, PROCEDURE_SCHEM, PROCEDURE_NAME and SPECIFIC_NAME. Within this, the retu * if any, is first. Next are the parameter descriptions in call * order. The column descriptions follow in column number order. * * <P>Each row in the {@code ResultSet} is a parameter description or * column description with the following fields: * <OL> * <LI><B>PROCEDURE_CAT</B> String {@code =>} procedure catalog (may be {@code null}) * <LI><B>PROCEDURE_SCHEM</B> String {@code =>} procedure schema (may be {@code null}) * <LI><B>PROCEDURE_NAME</B> String {@code =>} procedure name * <LI><B>COLUMN_NAME</B> String {@code =>} column/parameter name * <LI><B>COLUMN_TYPE</B> Short {@code =>} kind of column/parameter: * <UL> * <LI> procedureColumnUnknown - nobody knows * <LI> procedureColumnIn - IN parameter * <LI> procedureColumnInOut - INOUT parameter * <LI> procedureColumnOut - OUT parameter * <LI> procedureColumnReturn - procedure return value * <LI> procedureColumnResult - result column in {@code ResultSet} * </UL> * <LI><B>DATA_TYPE</B> int {@code =>} SQL type from java.sql.Types * <LI><B>TYPE_NAME</B> String {@code =>} SQL type name, for a UDT type the * type name is fully qualified * <LI><B>PRECISION</B> int {@code =>} precision * <LI><B>LENGTH</B> int {@code =>} length in bytes of data * <LI><B>SCALE</B> short {@code =>} scale - null is returned for data types where * SCALE is not applicable. * <LI><B>RADIX</B> short {@code =>} radix * <LI><B>NULLABLE</B> short {@code =>} can it contain NULL. * <UL> * <LI> procedureNoNulls - does not allow NULL values * <LI> procedureNullable - allows NULL values * <LI> procedureNullableUnknown - nullability unknown * </UL> * <LI><B>REMARKS</B> String {@code =>} comment describing parameter/column * <LI><B>COLUMN_DEF</B> String {@code =>} default value for the column, which should be interpreted a * <UL> * <LI> The string NULL (not enclosed in quotes) - if NULL was specified as the default value * <LI> TRUNCATE (not enclosed in quotes) - if the specified default value cannot be represented wi * <LI> NULL - if a default value was not specified * </UL> * <LI><B>SQL_DATA_TYPE</B> int {@code =>} reserved for future use * <LI><B>SQL_DATETIME_SUB</B> int {@code =>} reserved for future use * <LI><B>CHAR_OCTET_LENGTH</B> int {@code =>} the maximum length of binary and character based colum * NULL * <LI><B>ORDINAL_POSITION</B> int {@code =>} the ordinal position, starting from 1, for the input and *is returned if this row describes the procedure's return value. For result set columns, it is t *ordinal position of the column in the result set starting from 1. If there are *multiple result sets, the column ordinal positions are implementation * defined. * <LI><B>IS_NULLABLE</B> String {@code =>} ISO rules are used to determine the nullability for a colum * <UL> * <LI> YES --- if the column can include NULLs * <LI> NO --- if the column cannot include NULLs * <LI> empty string --- if the nullability for the * column is unknown * </UL> * <LI><B>SPECIFIC_NAME</B> String {@code =>} the name which uniquely identifies this procedure with * </OL> * * <P><B>Note:</B> Some databases may not return the column * descriptions for a procedure. * * <p>The PRECISION column represents the specified column size for the given column. * For numeric data, this is the maximum precision. For character data, this is the length in char * For datetime datatypes, this is the length in characters of the String representation (assum * maximum allowed precision of the fractional seconds component). For binary data, this is the * this is the length in bytes. Null is returned for data types where the * column size is not applicable. * @param catalog a catalog name; must match the catalog name as it * is stored in the database; "" retrieves those without a catalog; * {@code null} means that the catalog name should not be used to narrow * the search * @param schemaPattern a schema name pattern; must match the schema name * as it is stored in the database; "" retrieves those without a schema; * {@code null} means that the schema name should not be used to narrow * the search * @param procedureNamePattern a procedure name pattern; must match the * procedure name as it is stored in the database * @param columnNamePattern a column name pattern; must match the column name * as it is stored in the database * @return {@code ResultSet} - each row describes a stored procedure parameter or * column * @throws SQLException if a database access error occurs * @see #getSearchStringEscape */ ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException; /** * Indicates that type of the column is unknown. * <P> * A possible value for the column * {@code COLUMN_TYPE} * in the {@code ResultSet} * returned by the method {@code getProcedureColumns}. */ int procedureColumnUnknown = 0; /** * Indicates that the column stores IN parameters. * <P> * A possible value for the column * {@code COLUMN_TYPE} * in the {@code ResultSet} * returned by the method {@code getProcedureColumns}. */ int procedureColumnIn = 1; /** * Indicates that the column stores INOUT parameters. * <P> * A possible value for the column * {@code COLUMN_TYPE} * in the {@code ResultSet} * returned by the method {@code getProcedureColumns}. */ int procedureColumnInOut = 2; /** * Indicates that the column stores OUT parameters. * <P> * A possible value for the column * {@code COLUMN_TYPE} * in the {@code ResultSet} * returned by the method {@code getProcedureColumns}. */ int procedureColumnOut = 4; /** * Indicates that the column stores return values. * <P> * A possible value for the column * {@code COLUMN_TYPE} * in the {@code ResultSet} * returned by the method {@code getProcedureColumns}. */ int procedureColumnReturn = 5; /** * Indicates that the column stores results. * <P> * A possible value for the column * {@code COLUMN_TYPE} * in the {@code ResultSet} * returned by the method {@code getProcedureColumns}. */ int procedureColumnResult = 3; /** * Indicates that {@code NULL} values are not allowed. * <P> * A possible value for the column * {@code NULLABLE} * in the {@code ResultSet} object * returned by the method {@code getProcedureColumns}. */ int procedureNoNulls = 0; /** * Indicates that {@code NULL} values are allowed. * <P> * A possible value for the column * {@code NULLABLE} * in the {@code ResultSet} object * returned by the method {@code getProcedureColumns}. */ int procedureNullable = 1; /** * Indicates that whether {@code NULL} values are allowed * is unknown. * <P> * A possible value for the column * {@code NULLABLE} * in the {@code ResultSet} object * returned by the method {@code getProcedureColumns}. */ int procedureNullableUnknown = 2; /** * Retrieves a description of the tables available in the given catalog. * Only table descriptions matching the catalog, schema, table * name and type criteria are returned. They are ordered by * {@code TABLE_TYPE}, {@code TABLE_CAT}, * {@code TABLE_SCHEM} and {@code TABLE_NAME}. * <P> * Each table description has the following columns: * <OL> * <LI><B>TABLE_CAT</B> String {@code =>} table catalog (may be {@code null}) * <LI><B>TABLE_SCHEM</B> String {@code =>} table schema (may be {@code null}) * <LI><B>TABLE_NAME</B> String {@code =>} table name * <LI><B>TABLE_TYPE</B> String {@code =>} table type. Typical types are "TABLE", * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", * "LOCAL TEMPORARY", "ALIAS", "SYNONYM". * <LI><B>REMARKS</B> String {@code =>} explanatory comment on the table (may be {@code null}) * <LI><B>TYPE_CAT</B> String {@code =>} the types catalog (may be {@code null}) * <LI><B>TYPE_SCHEM</B> String {@code =>} the types schema (may be {@code null}) * <LI><B>TYPE_NAME</B> String {@code =>} type name (may be {@code null}) * <LI><B>SELF_REFERENCING_COL_NAME</B> String {@code =>} name of the designated * "identifier" column of a typed table (may be {@code null}) * <LI><B>REF_GENERATION</B> String {@code =>} specifies how values in * SELF_REFERENCING_COL_NAME are created. Values are * "SYSTEM", "USER", "DERIVED". (may be {@code null}) * </OL> * * <P><B>Note:</B> Some databases may not return information for * all tables. * * @param catalog a catalog name; must match the catalog name as it * is stored in the database; "" retrieves those without a catalog; * {@code null} means that the catalog name should not be used to narrow * the search * @param schemaPattern a schema name pattern; must match the schema name * as it is stored in the database; "" retrieves those without a schema; * {@code null} means that the schema name should not be used to narrow * the search * @param tableNamePattern a table name pattern; must match the * table name as it is stored in the database * @param types a list of table types, which must be from the list of table types * returned from {@link #getTableTypes}, to include; {@code null} returns * all types * @return {@code ResultSet} - each row is a table description * @throws SQLException if a database access error occurs * @see #getSearchStringEscape */ ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String types[]) throws SQLException; /** * Retrieves the schema names available in this database. The results * are ordered by {@code TABLE_CATALOG} and * {@code TABLE_SCHEM}. * * <P>The schema columns are: * <OL> * <LI><B>TABLE_SCHEM</B> String {@code =>} schema name * <LI><B>TABLE_CATALOG</B> String {@code =>} catalog name (may be {@code null}) * </OL> * * @return a {@code ResultSet} object in which each row is a * schema description * @throws SQLException if a database access error occurs * */ ResultSet getSchemas() throws SQLException; /** * Retrieves the catalog names available in this database. The results * are ordered by catalog name. * * <P>The catalog column is: * <OL> * <LI><B>TABLE_CAT</B> String {@code =>} catalog name * </OL> * * @return a {@code ResultSet} object in which each row has a * single {@code String} column that is a catalog name * @throws SQLException if a database access error occurs */ ResultSet getCatalogs() throws SQLException; /** * Retrieves the table types available in this database. The results * are ordered by table type. * * <P>The table type is: * <OL> * <LI><B>TABLE_TYPE</B> String {@code =>} table type. Typical types are "TABLE", * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", * "LOCAL TEMPORARY", "ALIAS", "SYNONYM". * </OL> * * @return a {@code ResultSet} object in which each row has a * single {@code String} column that is a table type * @throws SQLException if a database access error occurs */ ResultSet getTableTypes() throws SQLException; /** * Retrieves a description of table columns available in * the specified catalog. * * <P>Only column descriptions matching the catalog, schema, table * and column name criteria are returned. They are ordered by * {@code TABLE_CAT},{@code TABLE_SCHEM}, * {@code TABLE_NAME}, and {@code ORDINAL_POSITION}. * * <P>Each column description has the following columns: * <OL> * <LI><B>TABLE_CAT</B> String {@code =>} table catalog (may be {@code null}) * <LI><B>TABLE_SCHEM</B> String {@code =>} table schema (may be {@code null}) * <LI><B>TABLE_NAME</B> String {@code =>} table name * <LI><B>COLUMN_NAME</B> String {@code =>} column name * <LI><B>DATA_TYPE</B> int {@code =>} SQL type from java.sql.Types * <LI><B>TYPE_NAME</B> String {@code =>} Data source dependent type name, * for a UDT the type name is fully qualified * <LI><B>COLUMN_SIZE</B> int {@code =>} column size. * <LI><B>BUFFER_LENGTH</B> is not used. * <LI><B>DECIMAL_DIGITS</B> int {@code =>} the number of fractional digits. Null is returned for data * DECIMAL_DIGITS is not applicable. * <LI><B>NUM_PREC_RADIX</B> int {@code =>} Radix (typically either 10 or 2) * <LI><B>NULLABLE</B> int {@code =>} is NULL allowed. * <UL> * <LI> columnNoNulls - might not allow {@code NULL} values * <LI> columnNullable - definitely allows {@code NULL} values * <LI> columnNullableUnknown - nullability unknown * </UL> * <LI><B>REMARKS</B> String {@code =>} comment describing column (may be {@code null}) * <LI><B>COLUMN_DEF</B> String {@code =>} default value for the column, which should be interpreted a * <LI><B>SQL_DATA_TYPE</B> int {@code =>} unused * <LI><B>SQL_DATETIME_SUB</B> int {@code =>} unused * <LI><B>CHAR_OCTET_LENGTH</B> int {@code =>} for char types the * maximum number of bytes in the column * <LI><B>ORDINAL_POSITION</B> int {@code =>} index of column in table * (starting at 1) * <LI><B>IS_NULLABLE</B> String {@code =>} ISO rules are used to determine the nullability for a colum * <UL> * <LI> YES --- if the column can include NULLs * <LI> NO --- if the column cannot include NULLs * <LI> empty string --- if the nullability for the * column is unknown * </UL> * <LI><B>SCOPE_CATALOG</B> String {@code =>} catalog of table that is the scope * of a reference attribute ({@code null} if DATA_TYPE isn't REF) * <LI><B>SCOPE_SCHEMA</B> String {@code =>} schema of table that is the scope * of a reference attribute ({@code null} if the DATA_TYPE isn't REF) * <LI><B>SCOPE_TABLE</B> String {@code =>} table name that this the scope * of a reference attribute ({@code null} if the DATA_TYPE isn't REF) * <LI><B>SOURCE_DATA_TYPE</B> short {@code =>} source type of a distinct type or user-generated * Ref type, SQL type from java.sql.Types ({@code null} if DATA_TYPE * isn't DISTINCT or user-generated REF) * <LI><B>IS_AUTOINCREMENT</B> String {@code =>} Indicates whether this column is auto incremented * <UL> * <LI> YES --- if the column is auto incremented * <LI> NO --- if the column is not auto incremented * <LI> empty string --- if it cannot be determined whether the column is auto incremented * </UL> * <LI><B>IS_GENERATEDCOLUMN</B> String {@code =>} Indicates whether this is a generated column * <UL> --> -------------------- --> maximum size reached --> -------------------- ¤ Dauer der Verarbeitung: 0.49 Sekunden (vorverarbeitet) ¤ |
Haftungshinweis
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:Die farbliche Syntaxdarstellung ist noch experimentell.Bot Zugriff |
