Examples with LanguageConnectionContext org.apache.derby.iapi.sql.conn.LanguageConnectionContext used on opensource projects

Example 1 with LanguageConnectionContext

use of org.apache.derby.iapi.sql.conn.LanguageConnectionContext in project derby by apache.

the class SystemProcedures method SYSCS_INPLACE_COMPRESS_TABLE.

/**
 *    Implementation of SYSCS_UTIL.SYSCS_INPLACE_COMPRESS_TABLE().
 *    <p>
 *    Code which implements the following system procedure:
 *
 *    void SYSCS_UTIL.SYSCS_INPLACE_COMPRESS_TABLE(
 *        IN SCHEMANAME        VARCHAR(128),
 *        IN TABLENAME         VARCHAR(128),
 *        IN PURGE_ROWS        SMALLINT,
 *        IN DEFRAGMENT_ROWS   SMALLINT,
 *        IN TRUNCATE_END      SMALLINT)
 *    <p>
 *    Use the SYSCS_UTIL.SYSCS_INPLACE_COMPRESS_TABLE system procedure to reclaim
 *    unused, allocated space in a table and its indexes. Typically, unused allocated
 *    space exists when a large amount of data is deleted from a table, and there
 *    have not been subsequent inserts to use the space freed by the deletes.
 *    By default, Derby does not return unused space to the operating system. For
 *    example, once a page has been allocated to a table or index, it is not
 *    automatically returned to the operating system until the table or index is
 *    destroyed. SYSCS_UTIL.SYSCS_INPLACE_COMPRESS_TABLE allows you to return unused
 *    space to the operating system.
 *    <p>
 *    This system procedure can be used to force 3 levels of in place compression
 *    of a SQL table: PURGE_ROWS, DEFRAGMENT_ROWS, TRUNCATE_END.  Unlike
 *    SYSCS_UTIL.SYSCS_COMPRESS_TABLE() all work is done in place in the existing
 *    table/index.
 *    <p>
 *    Syntax:
 *    SYSCS_UTIL.SYSCS_INPLACE_COMPRESS_TABLE(
 *        IN SCHEMANAME        VARCHAR(128),
 *        IN TABLENAME         VARCHAR(128),
 *        IN PURGE_ROWS        SMALLINT,
 *        IN DEFRAGMENT_ROWS   SMALLINT,
 *        IN TRUNCATE_END      SMALLINT)
 *    <p>
 *    SCHEMANAME:
 *    An input argument of type VARCHAR(128) that specifies the schema of the table. Passing a null will result in an error.
 *    <p>
 *    TABLENAME:
 *    An input argument of type VARCHAR(128) that specifies the table name of the
 *    table. The string must exactly match the case of the table name, and the
 *    argument of "Fred" will be passed to SQL as the delimited identifier 'Fred'.
 *    Passing a null will result in an error.
 *    <p>
 *    PURGE_ROWS:
 *    If PURGE_ROWS is set to non-zero then a single pass is made through the table
 *    which will purge committed deleted rows from the table.  This space is then
 *    available for future inserted rows, but remains allocated to the table.
 *    As this option scans every page of the table, it's performance is linearly
 *    related to the size of the table.
 *    <p>
 *    DEFRAGMENT_ROWS:
 *    If DEFRAGMENT_ROWS is set to non-zero then a single defragment pass is made
 *    which will move existing rows from the end of the table towards the front
 *    of the table.  The goal of the defragment run is to empty a set of pages
 *    at the end of the table which can then be returned to the OS by the
 *    TRUNCATE_END option.  It is recommended to only run DEFRAGMENT_ROWS, if also
 *    specifying the TRUNCATE_END option.  This option scans the whole table and
 *    needs to update index entries for every base table row move, and thus execution
 *    time is linearly related to the size of the table.
 *    <p>
 *    TRUNCATE_END:
 *    If TRUNCATE_END is set to non-zero then all contiguous pages at the end of
 *    the table will be returned to the OS.  Running the PURGE_ROWS and/or
 *    DEFRAGMENT_ROWS passes options may increase the number of pages affected.
 *    This option itself does no scans of the table, so performs on the order of a
 *    few system calls.
 *    <p>
 *    SQL example:
 *    To compress a table called CUSTOMER in a schema called US, using all
 *    available compress options:
 *    call SYSCS_UTIL.SYSCS_INPLACE_COMPRESS_TABLE('US', 'CUSTOMER', 1, 1, 1);
 *
 *    To quickly just return the empty free space at the end of the same table,
 *    this option will run much quicker than running all phases but will likely
 *    return much less space:
 *    call SYSCS_UTIL.SYSCS_INPLACE_COMPRESS_TABLE('US', 'CUSTOMER', 0, 0, 1);
 *
 *    Java example:
 *    To compress a table called CUSTOMER in a schema called US, using all
 *    available compress options:
 *
 *    CallableStatement cs = conn.prepareCall
 *    ("CALL SYSCS_UTIL.SYSCS_COMPRESS_TABLE(?, ?, ?, ?, ?)");
 *    cs.setString(1, "US");
 *    cs.setString(2, "CUSTOMER");
 *    cs.setShort(3, (short) 1);
 *    cs.setShort(4, (short) 1);
 *    cs.setShort(5, (short) 1);
 *    cs.execute();
 *
 *    To quickly just return the empty free space at the end of the same table,
 *    this option will run much quicker than running all phases but will likely
 *    return much less space:
 *
 *    CallableStatement cs = conn.prepareCall
 *    ("CALL SYSCS_UTIL.SYSCS_COMPRESS_TABLE(?, ?, ?, ?, ?)");
 *    cs.setString(1, "US");
 *    cs.setString(2, "CUSTOMER");
 *    cs.setShort(3, (short) 0);
 *    cs.setShort(4, (short) 0);
 *    cs.setShort(5, (short) 1);
 *    cs.execute();
 *
 *    <p>
 *    It is recommended that the SYSCS_UTIL.SYSCS_COMPRESS_TABLE procedure is
 *    issued in auto-commit mode.
 *    Note: This procedure acquires an exclusive table lock on the table being compressed. All statement plans dependent on the table or its indexes are invalidated. For information on identifying unused space, see the Derby Server and Administration Guide.
 *
 *    TODO LIST:
 *    o defragment requires table level lock in nested user transaction, which
 *      will conflict with user lock on same table in user transaction.
 */
public static void SYSCS_INPLACE_COMPRESS_TABLE(String schema, String tablename, short purgeRows, short defragmentRows, short truncateEnd) throws SQLException {
    // Inplace compress let's the user call compress on VTI but it
    // is really a no-op. In order to avoid having to go throught
    // the ALTER TABLE code just for a no-op, we simply do the check
    // here and return if we are dealing with VTI.
    LanguageConnectionContext lcc = ConnectionUtil.getCurrentLCC();
    TransactionController tc = lcc.getTransactionExecute();
    try {
        DataDictionary data_dictionary = lcc.getDataDictionary();
        SchemaDescriptor sd = data_dictionary.getSchemaDescriptor(schema, tc, true);
        TableDescriptor td = data_dictionary.getTableDescriptor(tablename, sd, tc);
        if (td != null && td.getTableType() == TableDescriptor.VTI_TYPE) {
            return;
        }
    } catch (StandardException se) {
        throw PublicAPI.wrapStandardException(se);
    }
    // Send all the other inplace compress requests to ALTER TABLE
    // machinery
    String escapedSchema = IdUtil.normalToDelimited(schema);
    String escapedTableName = IdUtil.normalToDelimited(tablename);
    String query = "alter table " + escapedSchema + "." + escapedTableName + " compress inplace" + (purgeRows != 0 ? " purge" : "") + (defragmentRows != 0 ? " defragment" : "") + (truncateEnd != 0 ? " truncate_end" : "");
    Connection conn = getDefaultConn();
    PreparedStatement ps = conn.prepareStatement(query);
    ps.executeUpdate();
    ps.close();
    conn.close();
}

Example 2 with LanguageConnectionContext

use of org.apache.derby.iapi.sql.conn.LanguageConnectionContext in project derby by apache.

the class SystemProcedures method addUser.

/**
 * Create a new user (this entry is called when bootstrapping the credentials of the DBO
 * at database creation time.
 */
public static void addUser(String userName, String password, TransactionController tc) throws SQLException {
    // 
    try {
        LanguageConnectionContext lcc = ConnectionUtil.getCurrentLCC();
        DataDictionary dd = lcc.getDataDictionary();
        /*
            ** Inform the data dictionary that we are about to write to it.
            ** There are several calls to data dictionary "get" methods here
            ** that might be done in "read" mode in the data dictionary, but
            ** it seemed safer to do this whole operation in "write" mode.
            **
            ** We tell the data dictionary we're done writing at the end of
            ** the transaction.
            */
        dd.startWriting(lcc);
        UserDescriptor userDescriptor = makeUserDescriptor(dd, tc, userName, password);
        dd.addDescriptor(userDescriptor, null, DataDictionary.SYSUSERS_CATALOG_NUM, false, tc);
        // turn on NATIVE::LOCAL authentication
        if (dd.getAuthorizationDatabaseOwner().equals(userName)) {
            tc.setProperty(Property.AUTHENTICATION_PROVIDER_PARAMETER, Property.AUTHENTICATION_PROVIDER_NATIVE_LOCAL, true);
        }
    } catch (StandardException se) {
        throw PublicAPI.wrapStandardException(se);
    }
}

Example 3 with LanguageConnectionContext

use of org.apache.derby.iapi.sql.conn.LanguageConnectionContext in project derby by apache.

the class SystemProcedures method REMOVE_JAR.

/**
 *		Remove a jar file from the database.
 *
 *		@param jar      SQL name of jar to be replaced.
 *		@param undeploy Ignored.
 *
 *		@exception SQLException Error removing jar file.
 */
public static void REMOVE_JAR(String jar, int undeploy) throws SQLException {
    try {
        LanguageConnectionContext lcc = ConnectionUtil.getCurrentLCC();
        String[] st = IdUtil.parseMultiPartSQLIdentifier(jar.trim());
        String schemaName;
        String sqlName;
        if (st.length == 1) {
            schemaName = lcc.getCurrentSchemaName();
            sqlName = st[0];
        } else {
            schemaName = st[0];
            sqlName = st[1];
        }
        checkJarSQLName(sqlName);
        JarUtil.drop(lcc, schemaName, sqlName);
    } catch (StandardException se) {
        throw PublicAPI.wrapStandardException(se);
    }
}

Example 4 with LanguageConnectionContext

use of org.apache.derby.iapi.sql.conn.LanguageConnectionContext in project derby by apache.

the class SystemProcedures method setDatabaseProperty.

private static void setDatabaseProperty(String key, String value, Securable authorizationCheck) throws SQLException {
    LanguageConnectionContext lcc = ConnectionUtil.getCurrentLCC();
    try {
        if (authorizationCheck != null) {
            SecurityUtil.authorize(authorizationCheck);
        }
        Authorizer a = lcc.getAuthorizer();
        a.authorize((Activation) null, Authorizer.PROPERTY_WRITE_OP);
        // Get the current transaction controller
        TransactionController tc = lcc.getTransactionExecute();
        tc.setProperty(key, value, false);
    } catch (StandardException se) {
        throw PublicAPI.wrapStandardException(se);
    }
}

Example 5 with LanguageConnectionContext

use of org.apache.derby.iapi.sql.conn.LanguageConnectionContext in project derby by apache.

the class SystemProcedures method REPLACE_JAR.

/**
 *		Replace a jar file in the database.
 *
 *		SQLJ.REPLACE_JAR
 *
 *		@param url URL of the jar file to be installed in the database.
 *		@param jar SQL name of jar to be replaced.
 *
 *		@exception SQLException Error replacing jar file.
 */
public static void REPLACE_JAR(String url, String jar) throws SQLException {
    try {
        LanguageConnectionContext lcc = ConnectionUtil.getCurrentLCC();
        String[] st = IdUtil.parseMultiPartSQLIdentifier(jar.trim());
        String schemaName;
        String sqlName;
        if (st.length == 1) {
            schemaName = lcc.getCurrentSchemaName();
            sqlName = st[0];
        } else {
            schemaName = st[0];
            sqlName = st[1];
        }
        checkJarSQLName(sqlName);
        JarUtil.replace(lcc, schemaName, sqlName, url);
    } catch (StandardException se) {
        throw PublicAPI.wrapStandardException(se);
    }
}