Method lockMemoryLock

src/Interpreters/InterpreterSystemQuery.cpp:1782–1825

}

void InterpreterSystemQuery::lockMemoryLock(const ASTSystemQuery & query, const StorageID & table_id, ContextPtr local_context)
{
    /// SYSTEM LOCK MEMORY LOCK db.tb PARTITON '2012-01-01' FOR 4 SECONDS TASK_DOMAIN

    auto & txn_coordinator = local_context->getCnchTransactionCoordinator();
    auto transaction = txn_coordinator.createTransaction(
        CreateTransactionOption().setInitiator(CnchTransactionInitiator::Merge).setPriority(CnchTransactionPriority::low));

    SCOPE_EXIT({
        try
        {
            txn_coordinator.finishTransaction(transaction);
        }
        catch (...)
        {
            tryLogCurrentException(log, __PRETTY_FUNCTION__);
        }
    });

    StoragePtr storage = local_context->getCnchCatalog()->tryGetTable(*local_context, table_id.database_name, table_id.table_name);
    if (!storage)
        throw Exception("Failed to get StoragePtr for table", ErrorCodes::BAD_ARGUMENTS);

    auto * merge_tree = dynamic_cast<StorageCnchMergeTree *>(storage.get());
    if (!merge_tree)
        throw Exception("storage is not merge tree table", ErrorCodes::LOGICAL_ERROR);

    String partition_id = merge_tree->getPartitionIDFromQuery(query.partition, local_context);
    LOG_DEBUG(log, "execute lock Memory lock on partition_id {} on table {} for {} s with string data {}", partition_id, table_id.getFullTableName(), query.seconds, query.string_data);

    TxnTimestamp txn_id = transaction->getTransactionID();
    LockInfoPtr partition_lock = std::make_shared<LockInfo>(txn_id);
    partition_lock->setMode(LockMode::X);
    partition_lock->setTimeout(1000); //1 seconds
    partition_lock->setPartition(partition_id);
    partition_lock->setUUIDAndPrefix(storage->getStorageUUID(), query.string_data.empty() ? LockInfo::default_domain : LockInfo::task_domain);

    Stopwatch lock_watch;

    auto cnch_lock = std::make_shared<CnchLockHolder>(local_context, std::move(partition_lock));
    cnch_lock->lock();
    LOG_DEBUG(log, "Acquired lock in {} ms", lock_watch.elapsedMilliseconds());
    sleepForSeconds(query.seconds);
}

void InterpreterSystemQuery::releaseMemoryLock(const ASTSystemQuery & query, const StorageID & table_id, ContextPtr local_context)
{