dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); stmt = dbConn.createStatement(); LOG.debug("Going to rollback"); dbConn.rollback(); LockInfo info = getTxnIdFromLockId(dbConn, extLockId); if(info == null) { } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "unlock(" + rqst + ")"); throw new MetaException("Unable to update transaction database " + JavaUtils.lockIdToString(extLockId) + " " + StringUtils.stringifyException(e)); } finally { closeStmt(stmt); closeDbConn(dbConn); unlock(rqst);
ResultSet lockHandle = null; try { lockInternal(); dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); long txnid = rqst.getTxnid(); stmt = dbConn.createStatement(); if (isValidTxn(txnid)) { lockHandle = lockTransactionRecord(stmt, txnid, TXN_OPEN); if(lockHandle == null) { ensureValidTxn(dbConn, txnid, stmt); shouldNeverHappen(txnid); String dbName = normalizeCase(lc.getDbname()); String tblName = normalizeCase(lc.getTablename()); String partName = normalizeCase(lc.getPartitionname()); Long writeId = null; if (tblName != null) { pStmt = sqlGenerator.prepareStmtWithParameters(dbConn, s, Arrays.asList(dbName, tblName)); LOG.debug("Going to execute query <" + s.replaceAll("\\?", "{}") + ">", quoteString(dbName), quoteString(tblName)); rs = pStmt.executeQuery(); if (rs.next()) { (tblName == null ? "null" : "?") + ", " + (partName == null ? "null" : "?")+ "," + quoteString(OperationType.fromDataOperationType(lc.getOperationType()).toString())+ "," + (writeId == null ? "null" : writeId));
LOG.error("Too many repeated deadlocks in " + caller + ", giving up."); } else if (isRetryable(conf, e)) { sendRetrySignal = waitForRetry(caller, e.getMessage()); LOG.info("Non-retryable error in " + caller + " : " + getMessage(e));
/** * Close all 3 JDBC artifacts in order: {@code rs stmt dbConn} */ static void close(ResultSet rs, Statement stmt, Connection dbConn) { close(rs); closeStmt(stmt); closeDbConn(dbConn); }
private enum LockAction {ACQUIRE, WAIT, KEEP_LOOKING}
private Connection getDbConn(int isolationLevel, DataSource connPool) throws SQLException { int rc = doRetryOnConnPool ? 10 : 1; Connection dbConn = null; while (true) { try { dbConn = connPool.getConnection(); dbConn.setAutoCommit(false); dbConn.setTransactionIsolation(isolationLevel); return dbConn; } catch (SQLException e){ closeDbConn(dbConn); if ((--rc) <= 0) throw e; LOG.error("There is a problem with a connection from the pool, retrying(rc=" + rc + "): " + getMessage(e), e); } } }
public LockResponse checkLock(CheckLockRequest rqst) throws NoSuchTxnException, NoSuchLockException, TxnAbortedException, MetaException { try { Connection dbConn = null; try { dbConn = getDbConn(Connection.TRANSACTION_SERIALIZABLE); long extLockId = rqst.getLockid(); // Clean up timed out locks timeOutLocks(dbConn); // Heartbeat on the lockid first, to assure that our lock is still valid. // Then look up the lock info (hopefully in the cache). If these locks // are associated with a transaction then heartbeat on that as well. heartbeatLock(dbConn, extLockId); long txnid = getTxnIdFromLockId(dbConn, extLockId); if (txnid > 0) heartbeatTxn(dbConn, txnid); return checkLock(dbConn, extLockId, true); } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "checkLock(" + rqst + " )"); throw new MetaException("Unable to update transaction database " + StringUtils.stringifyException(e)); } finally { closeDbConn(dbConn); } } catch (RetryException e) { return checkLock(rqst); } }
/** * {@code ids} should only have txnid or lockid but not both, ideally. * Currently DBTxnManager.heartbeat() enforces this. */ @Override @RetrySemantics.SafeToRetry public void heartbeat(HeartbeatRequest ids) throws NoSuchTxnException, NoSuchLockException, TxnAbortedException, MetaException { try { Connection dbConn = null; try { dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); heartbeatLock(dbConn, ids.getLockid()); heartbeatTxn(dbConn, ids.getTxnid()); } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "heartbeat(" + ids + ")"); throw new MetaException("Unable to select from transaction database " + StringUtils.stringifyException(e)); } finally { closeDbConn(dbConn); } } catch (RetryException e) { heartbeat(ids); } } @Override
try { try { dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); stmt = dbConn.createStatement(); String s = "select cq_database, cq_table, cq_partition, cq_state, cq_type, cq_worker_id, " + e.setTablename(rs.getString(2)); e.setPartitionname(rs.getString(3)); e.setState(compactorStateToResponse(rs.getString(4).charAt(0))); switch (rs.getString(5).charAt(0)) { case MAJOR_TYPE: e.setType(CompactionType.MAJOR); break; } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "showCompact(" + rqst + ")"); throw new MetaException("Unable to select from transaction database " + StringUtils.stringifyException(e)); } finally { closeStmt(stmt); closeDbConn(dbConn); return showCompact(rqst);
public LockResponse lockNoWait(LockRequest rqst) throws NoSuchTxnException, TxnAbortedException, MetaException { try { Connection dbConn = null; try { dbConn = getDbConn(Connection.TRANSACTION_SERIALIZABLE); return lock(dbConn, rqst, false); } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "lockNoWait(" + rqst + ")"); throw new MetaException("Unable to update transaction database " + StringUtils.stringifyException(e)); } finally { closeDbConn(dbConn); } } catch (RetryException e) { return lockNoWait(rqst); } }
ResultSet commitIdRs = null, rs; try { lockInternal(); dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); stmt = dbConn.createStatement(); updateReplId(dbConn, rqst.getReplLastIdInfo()); List<Long> targetTxnIds = getTargetTxnIdList(rqst.getReplPolicy(), Collections.singletonList(sourceTxnId), dbConn); if (targetTxnIds.isEmpty()) { lockHandle = lockTransactionRecord(stmt, txnid, TXN_OPEN); if (lockHandle == null) { TxnStatus actualTxnStatus = findTxnState(txnid, stmt); if(actualTxnStatus == TxnStatus.COMMITTED) { if (rqst.isSetReplPolicy()) { raiseTxnUnexpectedState(actualTxnStatus, txnid); shouldNeverHappen(txnid); } else { conflictSQLSuffix = "from TXN_COMPONENTS where tc_txnid=" + txnid + " and tc_operation_type IN(" + quoteChar(OperationType.UPDATE.sqlConst) + "," + quoteChar(OperationType.DELETE.sqlConst) + ")"; rs = stmt.executeQuery(sqlGenerator.addLimitClause(1, "tc_operation_type " + conflictSQLSuffix)); close(rs);
Connection dbConn = null; try { dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); int numAborted = abortTxns(dbConn, txnids, false); if (numAborted != txnids.size()) { LOG.warn("Abort Transactions command only aborted " + numAborted + " out of " + } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "abortTxns(" + rqst + ")"); throw new MetaException("Unable to update transaction database " + StringUtils.stringifyException(e)); } finally { closeDbConn(dbConn); abortTxns(rqst);
List<Long> abortedWriteIds = getAbortedWriteIds(validWriteIdList); int numAbortedWrites = abortedWriteIds.size(); try { List<String> params = Arrays.asList(dbName, tblName); try { lockInternal(); dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); stmt = dbConn.createStatement(); pStmt = sqlGenerator.prepareStmtWithParameters(dbConn, sql, params); LOG.debug("Going to execute query <" + sql.replaceAll("\\?", "{}") + ">", quoteString(dbName), quoteString(tblName)); rs = pStmt.executeQuery(); if (rs.next()) { LOG.info("Idempotent flow: WriteId state <" + validWriteIdList + "> is already applied for the table: " + dbName + "." + tblName); rollbackDBConn(dbConn); return; List<Long> txnIds = openTxns(dbConn, stmt, new OpenTxnRequest(numAbortedWrites, rqst.getUser(), rqst.getHostName())); assert(numAbortedWrites == txnIds.size()); int numAborts = abortTxns(dbConn, txnIds, true); assert(numAborts == numAbortedWrites); handle = getMutexAPI().acquireLock(MUTEX_KEY.WriteIdAllocator.name());
Statement stmt = null; try { dbConn = getDbConn(Connection.TRANSACTION_SERIALIZABLE); LOG.debug("Going to execute update <" + s + ">"); stmt.executeUpdate(s); long now = getDbTime(dbConn); s = "insert into TXNS (txn_id, txn_state, txn_started, " + "txn_last_heartbeat, txn_user, txn_host) values (?, 'o', " + now + ", " + } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "openTxns(" + rqst + ")"); throw new MetaException("Unable to select from transaction database " + StringUtils.stringifyException(e)); } finally { closeStmt(stmt); closeDbConn(dbConn); return openTxns(rqst);
TxnStore.MutexAPI.LockHandle handle = null; try { lockInternal(); handle = getMutexAPI().acquireLock(MUTEX_KEY.CompactionScheduler.name()); dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); stmt = dbConn.createStatement(); long id = generateCompactionQueueId(stmt); append(" cq_state IN(").append(quoteChar(INITIATED_STATE)). append(",").append(quoteChar(WORKING_STATE)). append(") AND cq_database=?"). append(" AND cq_table=?").append(" AND "); if(rs.next()) { long enqueuedId = rs.getLong(1); String state = compactorStateToResponse(rs.getString(2).charAt(0)); LOG.info("Ignoring request to compact " + rqst.getDbname() + "/" + rqst.getTablename() + "/" + rqst.getPartitionname() + " since it is already " + quoteString(state) + " with id=" + enqueuedId); return new CompactionResponse(enqueuedId, state, false); close(rs); closeStmt(pst); params.clear(); StringBuilder buf = new StringBuilder("insert into COMPACTION_QUEUE (cq_id, cq_database, " + } catch (SQLException e) {
try { try { dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); stmt = dbConn.createStatement(); heartbeatTxn(dbConn, rqst.getTxnid()); for (String partName : rqst.getPartitionnames()) { StringBuilder buff = new StringBuilder(); } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "addDynamicPartitions(" + rqst + ")"); throw new MetaException("Unable to insert into from transaction database " + StringUtils.stringifyException(e)); } finally { closeStmt(stmt); closeDbConn(dbConn); addDynamicPartitions(rqst);
Statement stmt = null; try { dbConn = getDbConn(Connection.TRANSACTION_SERIALIZABLE); stmt = dbConn.createStatement(); heartbeatTxn(dbConn, txnid); } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "commitTxn(" + rqst + ")"); throw new MetaException("Unable to update transaction database " + StringUtils.stringifyException(e)); } finally { closeStmt(stmt); closeDbConn(dbConn); commitTxn(rqst);
long extLockId = rqst.getLockid(); try { lockInternal(); dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); LockInfo info = getTxnIdFromLockId(dbConn, extLockId); if(info == null) { throw new NoSuchLockException("No such lock " + JavaUtils.lockIdToString(extLockId)); heartbeatTxn(dbConn, info.txnId); heartbeatLock(dbConn, extLockId); return checkLock(dbConn, extLockId); } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "checkLock(" + rqst + " )"); throw new MetaException("Unable to update transaction database " + JavaUtils.lockIdToString(extLockId) + " " + StringUtils.stringifyException(e)); } finally { closeDbConn(dbConn); unlockInternal(); return checkLock(rqst);
Statement stmt = null; try { dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); timeOutTxns(dbConn); stmt = dbConn.createStatement(); String s = "select ntxn_next - 1 from NEXT_TXN_ID"; } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "getOpenTxns"); throw new MetaException("Unable to select from transaction database, " + StringUtils.stringifyException(e)); } finally { closeStmt(stmt); closeDbConn(dbConn); return getOpenTxns();
try { try { lockInternal(); dbConn = getDbConn(Connection.TRANSACTION_READ_COMMITTED); stmt = dbConn.createStatement(); lockHandle = lockTransactionRecord(stmt, rqst.getTxnid(), TXN_OPEN); if(lockHandle == null) { ensureValidTxn(dbConn, rqst.getTxnid(), stmt); shouldNeverHappen(rqst.getTxnid()); List<List<String>> paramsList = new ArrayList<>(); for (String partName : rqst.getPartitionnames()) { rows.add(rqst.getTxnid() + ",?,?,?," + quoteChar(ot.sqlConst) + "," + writeId); List<String> params = new ArrayList<>(); params.add(normalizeCase(rqst.getDbname())); params.add(normalizeCase(rqst.getTablename())); params.add(partName); paramsList.add(params); } catch (SQLException e) { LOG.debug("Going to rollback"); rollbackDBConn(dbConn); checkRetryable(dbConn, e, "addDynamicPartitions(" + rqst + ")"); throw new MetaException("Unable to insert into from transaction database " + StringUtils.stringifyException(e)); if (insertPreparedStmts != null) { for(PreparedStatement pst : insertPreparedStmts) {