databasemetadata.h

絲路server源碼 Silk Road server source

     *
     * @return true if the data source only supports data manipulation
     * (eg. <code>UPDATE</code>, <code>INSERT</code>) within a transaction
     * and any data definition (eg. <code>CREATE TABLE</code>) will be
     * ignored.
     *
     * If this method returns <code>true</code>,
     * supportsDataDefinitionAndDataManipulationTransactions(),
     * supportsDataManipulationTransactionsOnly() and
     * dataDefinitionCausesTransactionCommit() all return <code>false</code>.
     */
    bool dataDefinitionIgnoredInTransactions();


    /**
     */
    bool supportsTableCorrelationNames();

    /**
     */
    bool supportsDifferentTableCorrelationNames();

    /**
     */
    bool supportsOrderByUnrelated();

    /**
     */
    bool supportsExpressionsInOrderBy();

    /** Returns true if the data source and the driver can handle
     * open cursors (eg. ResultSets) across a commit, or false if
     * they are invalidated.
     */
    bool supportsOpenCursorsAcrossCommit();


    /** Returns true if the data source and the driver can handle
     * open cursors (eg. ResultSets) across a rollback, or false if
     * they are invalidated.
     */
    bool supportsOpenCursorsAcrossRollback();


    /** Returns true if the data source and the driver can handle
     * open statements across a commit, or false if
     * they are invalidated.
     */
    bool supportsOpenStatementsAcrossCommit();

    /** Returns true if the data source and the driver can handle
     * open statements across a rollback, or false if
     * they are invalidated.
     */
    bool supportsOpenStatementsAcrossRollback();

    /** Returns true if the data source supports the given
     * result set type.
     * @param type The type to check for
     * @see ResultSet
     */
    bool supportsResultSetType(int type);

    /** Returns true if the data source supports the given
     * result set concurrency for the given result set type.
     * @param type The type to check for.
     * @param concurrency The concurrency level to check for.
     * @see ResultSet
     */
    bool supportsResultSetConcurrency(int type, int concurrency);


    /** Returns true if catalogs are supported in DML */
    bool supportsCatalogsInDataManipulation();

    /** Returns true if catalogs are supported in procedure call statements */
    bool supportsCatalogsInProcedureCalls();

    /** Returns true if catalogs are supported in CREATE/ALTER TABLE statements */
    bool supportsCatalogsInTableDefinitions();

    /** Returns true if catalogs are supported in index definitions */
    bool supportsCatalogsInIndexDefinitions();

    /** Returns true if catalogs are supported in privilege definition statements */
    bool supportsCatalogsInPrivilegeDefinitions();


    /** Returns true if schemas are supported in DML */
    bool supportsSchemasInDataManipulation();

    /** Returns true if schemas are supported in procedure call statements */
    bool supportsSchemasInProcedureCalls();

    /** Returns true if schemas are supported in CREATE/ALTER TABLE statements */
    bool supportsSchemasInTableDefinitions();

    /** Returns true if schemas are supported in index definitions */
    bool supportsSchemasInIndexDefinitions();

    /** Returns true if schemas are supported in privilege definition statements */
    bool supportsSchemasInPrivilegeDefinitions();


    /** Returns true if NULL plus a non-NULL value yields NULL.
     */
    bool nullPlusNonNullIsNull();

    /** Returns true if the data source supports column aliasing, for example
     * SELECT COLUMN1 [AS] C1 FROM TABLE
     */
    bool supportsColumnAliasing();

    /** Returns true if the CONVERT function is supported by the data source.
     */
    bool supportsConvert();

    /** Returns true if CONVERT between fromType and toType is supported.
     */
    bool supportsConvert(int fromType, int toType);

    /** Returns true if ALTER TABLE with drop column is supported.
     */
    bool supportsAlterTableWithDropColumn();

    /** Returns true if ALTER TABLE with add column is supported.
     */
    bool supportsAlterTableWithAddColumn();

    /** Returns the extra characters beyond A-Z, a-z, 0-9 and _ that can
     * be used in unquoted identifier names.
     */
    ODBCXX_STRING getExtraNameCharacters();

    /** Returns the string that can be used to escape wildcard characters.
     */
    ODBCXX_STRING getSearchStringEscape();

    /** Returns a comma-separated list of all time and date functions supported.
     */
    ODBCXX_STRING getTimeDateFunctions();

    /** Returns a comma-separated list of all system functions supported.
     */
    ODBCXX_STRING getSystemFunctions();

    /** Returns a comma-separated list of all string functions supported.
     */
    ODBCXX_STRING getStringFunctions();

    /** Returns a comma-separated list of all numeric functions supported.
     */
    ODBCXX_STRING getNumericFunctions();

    /** Returns true if the escape character is supported in LIKE clauses.
     */
    bool supportsLikeEscapeClause();

    /** Returns true if a query can return multiple ResultSets.
     */
    bool supportsMultipleResultSets();

    /** Returns true if multiple transactions can be open at once
     * on different connections.
     */
    bool supportsMultipleTransactions();

    /** Returns true if columns can be defined as non-nullable.
     */
    bool supportsNonNullableColumns();

    /** Returns true if the data source supports ODBC minimum SQL grammar.
     */
    bool supportsMinimumSQLGrammar();

    /** Returns true if the data source supports the core ODBC SQL grammar.
     */
    bool supportsCoreSQLGrammar();

    /** Returns true if the data source supports the ODBC extended SQL grammar.
     */
    bool supportsExtendedSQLGrammar();


    /** Returns true if the data source supports the ANSI92 entry level
     * SQL grammar.
     */
    bool supportsANSI92EntryLevelSQL();

    /** Returns true if the data source supports the ANSI92 intermediate level
     * SQL grammar.
     */
    bool supportsANSI92IntermediateSQL();

    /** Returns true if the data source supports the full ANSI92 SQL grammar.
     */
    bool supportsANSI92FullSQL();

    /** Checks if the data source supports positioned delete
     *
     * @return <code>true</code> if (<code>"DELETE WHERE CURRENT OF ..."</code>)
     * is supported
     */
    bool supportsPositionedDelete();

    /** Checks if the data source supports positioned update
     *
     * @return <code>true</code> if (<code>"UPDATE ... WHERE CURRENT OF ..."</code>)
     * is supported
     */
    bool supportsPositionedUpdate();

    /** Checks if the data source supports
     *
     * @return <code>true</code> if (<code>"SELECT ... FOR UPDATE"</code>)
     * is supported
     */
    bool supportsSelectForUpdate();


    /** Returns true if the data source supports the SQL Integrity
     * Enhancement Facility.
     */
    bool supportsIntegrityEnhancementFacility();

    /** Whether the data source supports batch updates
     */
    bool supportsBatchUpdates();

    /** Returns true if the data source supports subqueries in comparisons
     */
    bool supportsSubqueriesInComparisons();

    /** Returns true if the data source supports subqueries in
     * <code>"EXISTS"</code> expressions.
     */
    bool supportsSubqueriesInExists();

    /** Returns true if the data source supports subqueries in
     * <code>"IN"</code> expressions.
     */
    bool supportsSubqueriesInIns();

    /** Returns true if the data source supports subqueries in
     * quantified expressions.
     */
    bool supportsSubqueriesInQuantifieds();


    /** Returns true if the data source supports correlated subqueries
     */
    bool supportsCorrelatedSubqueries();

    /** Returns true if updated rows are available with their new
     * values in the ResultSet.
     * @param type The type of ResultSet of interest
     */
    bool ownUpdatesAreVisible(int type);

    /** Returns true if deleted rows dissapear from a ResultSet
     * @param type The type of ResultSet of interest
     */
    bool ownDeletesAreVisible(int type);

    /** Returns true if inserted rows become available in a ResultSet
     * @param type The type of ResultSet of interest
     */
    bool ownInsertsAreVisible(int type);

    /** Returns true if rows updated by others are visible
     * with their new values.
     * @param type The type of ResultSet of interest
     */
    bool othersUpdatesAreVisible(int type);

    /** Returns true if rows deleted by others disapear
     * from a ResultSet.
     * @param type The type of ResultSet of interest
     */
    bool othersDeletesAreVisible(int type);

    /** Returns true if rows inserted by others become available in
     * a ResultSet.
     * @param type The type of ResultSet of interest
     */
    bool othersInsertsAreVisible(int type);

    /** Returns true if a deleted row can be detected with
     * ResultSet::rowDeleted().
     * @param type The type of ResultSet of interest
     */
    bool deletesAreDetected(int type);

    /** Returns true if an inserted row can be detected with
     * ResultSet::rowInserted().
     * @param type The type of ResultSet of interest
     */
    bool insertsAreDetected(int type);

    /** Returns true if ResultSet::rowUpdated can determine whether
     * a row has been updated.
     * @param type The type of ResultSet of interest
     */
    bool updatesAreDetected(int type);


    /** Returns the max number of hex characters allowed in an inline binary
     * literal.
     */
    int getMaxBinaryLiteralLength();

    /** Returns the maximum length of an inline character string.
     */
    int getMaxCharLiteralLength();

    /** Returns the maximum length of a column name.
     */
    int getMaxColumnNameLength();

    /** Returns the maximum number of columns this data source can have in
     * a GROUP BY clause.
     */
    int getMaxColumnsInGroupBy();

    /** Returns the maximum number of columns allowed in an index.
     */
    int getMaxColumnsInIndex();

    /** Returns the maximum number of columns this data source can have in
     * an ORDER BY clause.
     */
    int getMaxColumnsInOrderBy();

    /** Returns the maximum number of columns this data source can SELECT.
     */
    int getMaxColumnsInSelect();

    /** Returns the maximum number of columns a table can consist of.