Java DbException.get方法代码示例

import org.h2.message.DbException; //导入方法依赖的package包/类
@Override
public void init() {
    if (SysProperties.CHECK && checkInit) {
        DbException.throwInternalError();
    }
    checkInit = true;
    left.init();
    right.init();
    int len = left.getColumnCount();
    if (len != right.getColumnCount()) {
        throw DbException.get(ErrorCode.COLUMN_COUNT_DOES_NOT_MATCH);
    }
    ArrayList<Expression> le = left.getExpressions();
    // set the expressions to get the right column count and names,
    // but can't validate at this time
    expressions = New.arrayList();
    for (int i = 0; i < len; i++) {
        Expression l = le.get(i);
        expressions.add(l);
    }
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
@Override
SearchRow remove(SearchRow row) {
    int at = find(row, false, false, true);
    SearchRow delete = getRow(at);
    if (index.compareRows(row, delete) != 0 || delete.getKey() != row.getKey()) {
        throw DbException.get(ErrorCode.ROW_NOT_FOUND_WHEN_DELETING_1,
                index.getSQL() + ": " + row);
    }
    index.getPageStore().logUndo(this, data);
    if (entryCount == 1) {
        // the page is now empty
        return row;
    }
    removeRow(at);
    memoryChange();
    index.getPageStore().update(this);
    if (at == entryCount) {
        // the last row changed
        return getRow(at - 1);
    }
    // the last row didn't change
    return null;
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
/**
 * Set the page size. The size must be a power of two. This method must be
 * called before opening.
 *
 * @param size the page size
 */
public void setPageSize(int size) {
    if (size < PAGE_SIZE_MIN || size > PAGE_SIZE_MAX) {
        throw DbException.get(ErrorCode.FILE_CORRUPTED_1,
                fileName + " pageSize: " + size);
    }
    boolean good = false;
    int shift = 0;
    for (int i = 1; i <= size;) {
        if (size == i) {
            good = true;
            break;
        }
        shift++;
        i += i;
    }
    if (!good) {
        throw DbException.get(ErrorCode.FILE_CORRUPTED_1, fileName);
    }
    pageSize = size;
    emptyPage = createData();
    pageSizeShift = shift;
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
private CreateFunctionAlias parseCreateFunctionAlias(boolean force) {
    boolean ifNotExists = readIfNoExists();
    String aliasName = readIdentifierWithSchema();
    if (isKeyword(aliasName) ||
            Function.getFunction(database, aliasName) != null ||
            getAggregateType(aliasName) >= 0) {
        throw DbException.get(ErrorCode.FUNCTION_ALIAS_ALREADY_EXISTS_1,
                aliasName);
    }
    CreateFunctionAlias command = new CreateFunctionAlias(session,
            getSchema());
    command.setForce(force);
    command.setAliasName(aliasName);
    command.setIfNotExists(ifNotExists);
    command.setDeterministic(readIf("DETERMINISTIC"));
    command.setBufferResultSetToLocalTemp(!readIf("NOBUFFER"));
    if (readIf("AS")) {
        command.setSource(readString());
    } else {
        read("FOR");
        command.setJavaClassMethod(readUniqueIdentifier());
    }
    return command;
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
private static String hexToRaw(String s) {
    // TODO function hextoraw compatibility with oracle
    int len = s.length();
    if (len % 4 != 0) {
        throw DbException.get(ErrorCode.DATA_CONVERSION_ERROR_1, s);
    }
    StringBuilder buff = new StringBuilder(len / 4);
    for (int i = 0; i < len; i += 4) {
        try {
            char raw = (char) Integer.parseInt(s.substring(i, i + 4), 16);
            buff.append(raw);
        } catch (NumberFormatException e) {
            throw DbException.get(ErrorCode.DATA_CONVERSION_ERROR_1, s);
        }
    }
    return buff.toString();
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
@Override
public void checkExistingData(Session session) {
    if (session.getDatabase().isStarting()) {
        // don't check at startup
        return;
    }
    String sql = "SELECT 1 FROM " + filter.getTable().getSQL() +
            " WHERE NOT(" + expr.getSQL() + ")";
    ResultInterface r = session.prepare(sql).query(1);
    if (r.next()) {
        throw DbException.get(ErrorCode.CHECK_CONSTRAINT_VIOLATED_1, getName());
    }
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
/**
 * INTERNAL.
 * Check if this connection is closed.
 *
 * @param write if the next operation is possibly writing
 * @throws DbException if the connection or session is closed
 */
protected void checkClosed(boolean write) {
    if (session == null) {
        throw DbException.get(ErrorCode.OBJECT_CLOSED);
    }
    if (session.isClosed()) {
        throw DbException.get(ErrorCode.DATABASE_CALLED_AT_SHUTDOWN);
    }
    if (session.isReconnectNeeded(write)) {
        trace.debug("reconnect");
        closePreparedCommands();
        session = session.reconnect(write);
        trace = session.getTrace();
    }
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
@Override
public void remove(Session session, Row row) {
    // in-memory
    if (!database.isMultiVersion() && rowCount == 1) {
        rows = New.arrayList();
        firstFree = -1;
    } else {
        Row free = new Row(null, 1);
        free.setKey(firstFree);
        long key = row.getKey();
        if (rows.size() <= key) {
            throw DbException.get(ErrorCode.ROW_NOT_FOUND_WHEN_DELETING_1,
                    rows.size() + ": " + key);
        }
        rows.set((int) key, free);
        firstFree = key;
    }
    if (database.isMultiVersion()) {
        // if storage is null, the delete flag is not yet set
        row.setDeleted(true);
        if (delta == null) {
            delta = New.hashSet();
        }
        boolean wasAdded = delta.remove(row);
        if (!wasAdded) {
            delta.add(row);
        }
        incrementRowCount(session.getId(), -1);
    }
    rowCount--;
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
/**
 * Add a local temporary constraint to this session.
 *
 * @param constraint the constraint to add
 * @throws DbException if a constraint with the same name already exists
 */
public void addLocalTempTableConstraint(Constraint constraint) {
    if (localTempTableConstraints == null) {
        localTempTableConstraints = database.newStringMap();
    }
    String name = constraint.getName();
    if (localTempTableConstraints.get(name) != null) {
        throw DbException.get(ErrorCode.CONSTRAINT_ALREADY_EXISTS_1,
                constraint.getSQL());
    }
    localTempTableConstraints.put(name, constraint);
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
private static ValueShort checkRange(int x) {
    if (x < Short.MIN_VALUE || x > Short.MAX_VALUE) {
        throw DbException.get(ErrorCode.NUMERIC_VALUE_OUT_OF_RANGE_1,
                Integer.toString(x));
    }
    return ValueShort.get((short) x);
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
@Override
public int update() {
    session.getUser().checkAdmin();
    session.commit(true);
    Database db = session.getDatabase();
    FunctionAlias functionAlias = getSchema().findFunction(aliasName);
    if (functionAlias == null) {
        if (!ifExists) {
            throw DbException.get(ErrorCode.FUNCTION_ALIAS_NOT_FOUND_1, aliasName);
        }
    } else {
        db.removeSchemaObject(session, functionAlias);
    }
    return 0;
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
/**
 * Calling this method is not legal on a PreparedStatement.
 *
 * @param sql ignored
 * @param columnNames ignored
 * @throws SQLException Unsupported Feature
 */
@Override
public int executeUpdate(String sql, String[] columnNames)
        throws SQLException {
    try {
        debugCode("executeUpdate(" + quote(sql) + ", " +
                quoteArray(columnNames) + ");");
        throw DbException.get(
                ErrorCode.METHOD_NOT_ALLOWED_FOR_PREPARED_STATEMENT);
    } catch (Exception e) {
        throw logAndConvert(e);
    }
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
@Override
public void remove(Session session, Row row) {
    ValueArray array = convertToKey(row);
    TransactionMap<Value, Value> map = getMap(session);
    try {
        Value old = map.remove(array);
        if (old == null) {
            throw DbException.get(ErrorCode.ROW_NOT_FOUND_WHEN_DELETING_1,
                    getSQL() + ": " + row.getKey());
        }
    } catch (IllegalStateException e) {
        throw DbException.get(ErrorCode.CONCURRENT_UPDATE_1,
                e, table.getName());
    }
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
private void checkLiterals(boolean text) {
    if (!session.getAllowLiterals()) {
        int allowed = database.getAllowLiterals();
        if (allowed == Constants.ALLOW_LITERALS_NONE ||
                (text && allowed != Constants.ALLOW_LITERALS_ALL)) {
            throw DbException.get(ErrorCode.LITERALS_ARE_NOT_ALLOWED);
        }
    }
}
 

import org.h2.message.DbException; //导入方法依赖的package包/类
private Sequence readSequence() {
    // same algorithm as readTableOrView
    String sequenceName = readIdentifierWithSchema(null);
    if (schemaName != null) {
        return getSchema().getSequence(sequenceName);
    }
    Sequence sequence = findSequence(session.getCurrentSchemaName(),
            sequenceName);
    if (sequence != null) {
        return sequence;
    }
    throw DbException.get(ErrorCode.SEQUENCE_NOT_FOUND_1, sequenceName);
}