com.speedment.runtime.core.component.transaction.Isolation Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of tool-deploy Show documentation
A Speedment bundle that shades all dependencies into one jar. This is useful when deploying an application on a server.
The newest version!
/*
 *
 * Copyright (c) 2006-2019, Speedment, Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); You may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.speedment.runtime.core.component.transaction;

import java.sql.Connection;

/**
 *
 * @author Per Minborg
 */
public enum Isolation {

//    /**
//     * An enum indicating that transactions are not supported.
//     */
//    NONE(Connection.TRANSACTION_NONE),
    /**
     * An Enum indicating that the default level of isolation for the
     * transaction domain shall be used.
     */
    DEFAULT(-1),
    /**
     * An Enum indicating that dirty reads, non-repeatable reads and phantom
     * reads can occur. This level allows a row changed by one transaction to be
     * read by another transaction before any changes in that row have been
     * committed (a "dirty read"). If any of the changes are rolled back, the
     * second transaction will have retrieved an invalid row.
     */
    READ_UNCOMMITTED(Connection.TRANSACTION_READ_UNCOMMITTED),
    /**
     * An Enum indicating that dirty reads are prevented; non-repeatable reads
     * and phantom reads can occur. This level only prohibits a transaction from
     * reading a row with uncommitted changes in it.
     */
    READ_COMMITTED(Connection.TRANSACTION_READ_COMMITTED),
    /**
     * An Enum indicating that dirty reads and non-repeatable reads are
     * prevented; phantom reads can occur. This level prohibits a transaction
     * from reading a row with uncommitted changes in it, and it also prohibits
     * the situation where one transaction reads a row, a second transaction
     * alters the row, and the first transaction rereads the row, getting
     * different values the second time (a "non-repeatable read").
     */
    REPEATABLE_READ(Connection.TRANSACTION_REPEATABLE_READ),
    /**
     * An Enum indicating that dirty reads, non-repeatable reads and phantom
     * reads are prevented. This level includes the prohibitions in
     * TRANSACTION_REPEATABLE_READ and further prohibits the
     * situation where one transaction reads all rows that satisfy a
     * WHERE condition, a second transaction inserts a row that
     * satisfies that WHERE condition, and the first transaction
     * rereads for the same condition, retrieving the additional "phantom" row
     * in the second read.
     */
    SERIALIZABLE(Connection.TRANSACTION_SERIALIZABLE);

    private final int sqlIsolationLevel;

    private Isolation(int sqlIsolationlevel) {
        this.sqlIsolationLevel = sqlIsolationlevel;
    }

    public int getSqlIsolationLevel() {
        if (DEFAULT == this) {
            throw new IllegalArgumentException("The DEFAULT isolation level does not have a hard coded value.");
        }
        return sqlIsolationLevel;
    }

    public static Isolation fromSqlIsolationLevel(int level) {
        switch (level) {
            case Connection.TRANSACTION_READ_UNCOMMITTED: {
                return READ_UNCOMMITTED;
            }
            case Connection.TRANSACTION_READ_COMMITTED: {
                return READ_COMMITTED;
            }
            case Connection.TRANSACTION_REPEATABLE_READ: {
                return REPEATABLE_READ;
            }
            case Connection.TRANSACTION_SERIALIZABLE: {
                return SERIALIZABLE;
            }
            default:
                throw new IllegalArgumentException("No Isolation exists for " + level);
        }
    }

}