Typo3DbBackend.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Extbase\Persistence\Generic\Storage;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\CMS\Backend\Utility\BackendUtility;
use TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
use TYPO3\CMS\Core\Cache\CacheManager;
use TYPO3\CMS\Core\Cache\Frontend\VariableFrontend;
use TYPO3\CMS\Core\Database\DatabaseConnection;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;
use TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use TYPO3\CMS\Extbase\DomainObject\AbstractValueObject;
use TYPO3\CMS\Extbase\Persistence\Generic\Exception;
use TYPO3\CMS\Extbase\Persistence\Generic\Mapper\DataMapper;
use TYPO3\CMS\Extbase\Persistence\Generic\Qom;
use TYPO3\CMS\Extbase\Persistence\Generic\QuerySettingsInterface;
use TYPO3\CMS\Extbase\Persistence\Generic\Storage\Exception\SqlErrorException;
use TYPO3\CMS\Extbase\Persistence\Generic\Typo3QuerySettings;
use TYPO3\CMS\Extbase\Persistence\QueryInterface;
use TYPO3\CMS\Extbase\Service\CacheService;
use TYPO3\CMS\Extbase\Service\EnvironmentService;
use TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;
use TYPO3\CMS\Frontend\Page\PageRepository;

class Typo3DbBackend implements BackendInterface, \TYPO3\CMS\Core\SingletonInterface
{
    protected $databaseHandle;

    protected $dataMapper;

    protected $pageRepository;

    protected $pageTSConfigCache = [];

    protected $configurationManager;

    protected $cacheService;

    protected $cacheManager;

    protected $queryCache;

    protected $environmentService;

    protected $queryParser;

    protected $queryRuntimeCache = [];

    public function injectDataMapper(DataMapper $dataMapper)
    {
        $this->dataMapper = $dataMapper;
    }

    public function injectConfigurationManager(ConfigurationManagerInterface $configurationManager)
    {
        $this->configurationManager = $configurationManager;
    }

    public function injectCacheService(CacheService $cacheService)
    {
        $this->cacheService = $cacheService;
    }

    public function injectCacheManager(CacheManager $cacheManager)
    {
        $this->cacheManager = $cacheManager;
    }

    public function injectEnvironmentService(EnvironmentService $environmentService)
    {
        $this->environmentService = $environmentService;
    }

    public function injectQueryParser(Typo3DbQueryParser $queryParser)
    {
        $this->queryParser = $queryParser;
    }

    public function __construct()
    {
        $this->databaseHandle = $GLOBALS['TYPO3_DB'];
    }

    public function initializeObject()
    {
        $this->queryCache = $this->cacheManager->getCache('extbase_typo3dbbackend_queries');
    }

    public function addRow($tableName, array $fieldValues, $isRelation = false)
    {
        if (isset($fieldValues['uid'])) {
            unset($fieldValues['uid']);
        }

        $this->databaseHandle->exec_INSERTquery($tableName, $fieldValues);
        $this->checkSqlErrors();
        $uid = $this->databaseHandle->sql_insert_id();

        if (!$isRelation) {
            $this->clearPageCache($tableName, $uid);
        }
        return (int)$uid;
    }

    public function updateRow($tableName, array $fieldValues, $isRelation = false)
    {
        if (!isset($fieldValues['uid'])) {
            throw new \InvalidArgumentException('The given row must contain a value for "uid".');
        }

        $uid = (int)$fieldValues['uid'];
        unset($fieldValues['uid']);

        $updateSuccessful = $this->databaseHandle->exec_UPDATEquery($tableName, 'uid = ' . $uid, $fieldValues);
        $this->checkSqlErrors();

        if (!$isRelation) {
            $this->clearPageCache($tableName, $uid);
        }

        return $updateSuccessful;
    }

    public function updateRelationTableRow($tableName, array $fieldValues)
    {
        if (!isset($fieldValues['uid_local']) && !isset($fieldValues['uid_foreign'])) {
            throw new \InvalidArgumentException(
                'The given fieldValues must contain a value for "uid_local" and "uid_foreign".', 1360500126
            );
        }

        $where['uid_local'] = (int)$fieldValues['uid_local'];
        $where['uid_foreign'] = (int)$fieldValues['uid_foreign'];
        unset($fieldValues['uid_local']);
        unset($fieldValues['uid_foreign']);

        if (!empty($fieldValues['tablenames'])) {
            $where['tablenames'] = $fieldValues['tablenames'];
            unset($fieldValues['tablenames']);
        }
        if (!empty($fieldValues['fieldname'])) {
            $where['fieldname'] = $fieldValues['fieldname'];
            unset($fieldValues['fieldname']);
        }

        $updateSuccessful = $this->databaseHandle->exec_UPDATEquery(
            $tableName,
            $this->resolveWhereStatement($where, $tableName),
            $fieldValues
        );
        $this->checkSqlErrors();

        return $updateSuccessful;
    }

    public function removeRow($tableName, array $where, $isRelation = false)
    {
        $deleteSuccessful = $this->databaseHandle->exec_DELETEquery(
            $tableName,
            $this->resolveWhereStatement($where, $tableName)
        );
        $this->checkSqlErrors();

        if (!$isRelation && isset($where['uid'])) {
            $this->clearPageCache($tableName, $where['uid']);
        }

        return $deleteSuccessful;
    }

    public function getMaxValueFromTable($tableName, array $where, $columnName)
    {
        $result = $this->databaseHandle->exec_SELECTgetSingleRow(
            $columnName,
            $tableName,
            $this->resolveWhereStatement($where, $tableName),
            '',
            $columnName . ' DESC',
            true
        );
        $this->checkSqlErrors();

        return $result[0];
    }

    public function getRowByIdentifier($tableName, array $where)
    {
        $row = $this->databaseHandle->exec_SELECTgetSingleRow(
            '*',
            $tableName,
            $this->resolveWhereStatement($where, $tableName)
        );
        $this->checkSqlErrors();

        return $row ?: false;
    }

    protected function resolveWhereStatement(array $where, $tableName = 'foo')
    {
        $whereStatement = [];

        foreach ($where as $fieldName => $fieldValue) {
            $whereStatement[] = $fieldName . ' = ' . $this->databaseHandle->fullQuoteStr($fieldValue, $tableName);
        }

        return implode(' AND ', $whereStatement);
    }

    public function getObjectDataByQuery(QueryInterface $query)
    {
        $statement = $query->getStatement();
        if ($statement instanceof Qom\Statement) {
            $rows = $this->getObjectDataByRawQuery($statement);
        } else {
            $rows = $this->getRowsByStatementParts($query);
        }

        $rows = $this->doLanguageAndWorkspaceOverlay($query->getSource(), $rows, $query->getQuerySettings());
        return $rows;
    }

    protected function createQueryCommandParametersFromStatementParts(array $statementParts)
    {
        if (isset($statementParts['offset']) && !isset($statementParts['limit'])) {
            throw new \InvalidArgumentException(
                'Trying to make query with offset and no limit, the offset would become a limit. You have to set a limit to use offset. To retrieve all rows from a certain offset up to the end of the result set, you can use some large number for the limit.',
                1465223252
            );
        }
        return [
            'selectFields' => implode(' ', $statementParts['keywords']) . ' ' . implode(',', $statementParts['fields']),
            'fromTable'    => implode(' ', $statementParts['tables']) . ' ' . implode(' ', $statementParts['unions']),
            'whereClause'  => (!empty($statementParts['where']) ? implode('', $statementParts['where']) : '1=1')
                . (!empty($statementParts['additionalWhereClause'])
                    ? ' AND ' . implode(' AND ', $statementParts['additionalWhereClause'])
                    : ''
            ),
            'orderBy'      => (!empty($statementParts['orderings']) ? implode(', ', $statementParts['orderings']) : ''),
            'limit'        => ($statementParts['offset'] ? $statementParts['offset'] . ', ' : '')
                . ($statementParts['limit'] ? $statementParts['limit'] : '')
        ];
    }

    protected function getRowsByStatementParts(QueryInterface $query)
    {
        if ($query->getQuerySettings()->getUsePreparedStatement()) {
            list($statementParts, $parameters) = $this->getStatementParts($query, false);
            $rows = $this->getRowsFromPreparedDatabase($statementParts, $parameters);
        } else {
            list($statementParts) = $this->getStatementParts($query);
            $rows = $this->getRowsFromDatabase($statementParts);
        }

        return $rows;
    }

    protected function getRowsFromDatabase(array $statementParts)
    {
        $queryCommandParameters = $this->createQueryCommandParametersFromStatementParts($statementParts);
        $rows = $this->databaseHandle->exec_SELECTgetRows(
            $queryCommandParameters['selectFields'],
            $queryCommandParameters['fromTable'],
            $queryCommandParameters['whereClause'],
            '',
            $queryCommandParameters['orderBy'],
            $queryCommandParameters['limit']
        );
        $this->checkSqlErrors();

        return $rows;
    }

    protected function getRowsFromPreparedDatabase(array $statementParts, array $parameters)
    {
        $queryCommandParameters = $this->createQueryCommandParametersFromStatementParts($statementParts);
        $preparedStatement = $this->databaseHandle->prepare_SELECTquery(
            $queryCommandParameters['selectFields'],
            $queryCommandParameters['fromTable'],
            $queryCommandParameters['whereClause'],
            '',
            $queryCommandParameters['orderBy'],
            $queryCommandParameters['limit']
        );

        $preparedStatement->execute($parameters);
        $rows = $preparedStatement->fetchAll();

        $preparedStatement->free();
        return $rows;
    }

    protected function getObjectDataByRawQuery(Qom\Statement $statement)
    {
        $realStatement = $statement->getStatement();
        $parameters = $statement->getBoundVariables();

        if ($realStatement instanceof \TYPO3\CMS\Core\Database\PreparedStatement) {
            $realStatement->execute($parameters);
            $rows = $realStatement->fetchAll();

            $realStatement->free();
        } else {
            $result = $this->databaseHandle->sql_query($realStatement);
            $this->checkSqlErrors();

            $rows = [];
            while ($row = $this->databaseHandle->sql_fetch_assoc($result)) {
                if (is_array($row)) {
                    $rows[] = $row;
                }
            }
            $this->databaseHandle->sql_free_result($result);
        }

        return $rows;
    }

    public function getObjectCountByQuery(QueryInterface $query)
    {
        if ($query->getConstraint() instanceof Qom\Statement) {
            throw new Exception\BadConstraintException('Could not execute count on queries with a constraint of type TYPO3\\CMS\\Extbase\\Persistence\\Generic\\Qom\\Statement', 1256661045);
        }

        list($statementParts) = $this->getStatementParts($query);

        $fields = '*';
        if (isset($statementParts['keywords']['distinct'])) {
            $fields = 'DISTINCT ' . reset($statementParts['tables']) . '.uid';
        }

        $queryCommandParameters = $this->createQueryCommandParametersFromStatementParts($statementParts);
        $count = $this->databaseHandle->exec_SELECTcountRows(
            $fields,
            $queryCommandParameters['fromTable'],
            $queryCommandParameters['whereClause']
        );
        $this->checkSqlErrors();

        if ($statementParts['offset']) {
            $count -= $statementParts['offset'];
        }

        if ($statementParts['limit']) {
            $count = min($count, $statementParts['limit']);
        }

        return (int)max(0, $count);
    }

    protected function getStatementParts($query, $resolveParameterPlaceholders = true)
    {
        list($queryHash, $parameters) = $this->queryParser->preparseQuery($query);

        if ($query->getQuerySettings()->getUseQueryCache()) {
            $statementParts = $this->getQueryCacheEntry($queryHash);
            if ($queryHash && !$statementParts) {
                $statementParts = $this->queryParser->parseQuery($query);
                $this->setQueryCacheEntry($queryHash, $statementParts);
            }
        } else {
            $statementParts = $this->queryParser->parseQuery($query);
        }

        if (!$statementParts) {
            throw new \RuntimeException('Your query could not be built.', 1394453197);
        }

        $this->queryParser->addDynamicQueryParts($query->getQuerySettings(), $statementParts);

        // Limit and offset are not cached to allow caching of pagebrowser queries.
        $statementParts['limit'] = ((int)$query->getLimit() ?: null);
        $statementParts['offset'] = ((int)$query->getOffset() ?: null);

        if ($resolveParameterPlaceholders === true) {
            $statementParts = $this->resolveParameterPlaceholders($statementParts, $parameters);
        }

        return [$statementParts, $parameters];
    }

    protected function resolveParameterPlaceholders(array $statementParts, array $parameters)
    {
        $tableName = reset($statementParts['tables']) ?: 'foo';

        foreach ($parameters as $parameterPlaceholder => $parameter) {
            $parameter = $this->dataMapper->getPlainValue($parameter, null, [$this, 'quoteTextValueCallback'], ['tablename' => $tableName]);
            $statementParts['where'] = str_replace($parameterPlaceholder, $parameter, $statementParts['where']);
        }

        return $statementParts;
    }

    public function quoteTextValueCallback($value, $parameters)
    {
        return $this->databaseHandle->fullQuoteStr($value, $parameters['tablename']);
    }

    public function getUidOfAlreadyPersistedValueObject(AbstractValueObject $object)
    {
        $fields = [];
        $parameters = [];
        $dataMap = $this->dataMapper->getDataMap(get_class($object));
        $properties = $object->_getProperties();
        foreach ($properties as $propertyName => $propertyValue) {
            // @todo We couple the Backend to the Entity implementation (uid, isClone); changes there breaks this method
            if ($dataMap->isPersistableProperty($propertyName) && $propertyName !== 'uid' && $propertyName !== 'pid' && $propertyName !== 'isClone') {
                if ($propertyValue === null) {
                    $fields[] = $dataMap->getColumnMap($propertyName)->getColumnName() . ' IS NULL';
                } else {
                    $fields[] = $dataMap->getColumnMap($propertyName)->getColumnName() . '=?';
                    $parameters[] = $this->dataMapper->getPlainValue($propertyValue);
                }
            }
        }
        $sql = [];
        $sql['additionalWhereClause'] = [];
        $tableName = $dataMap->getTableName();
        $this->addVisibilityConstraintStatement(new Typo3QuerySettings(), $tableName, $sql);
        $statement = 'SELECT * FROM ' . $tableName;
        $statement .= ' WHERE ' . implode(' AND ', $fields);
        if (!empty($sql['additionalWhereClause'])) {
            $statement .= ' AND ' . implode(' AND ', $sql['additionalWhereClause']);
        }
        $this->replacePlaceholders($statement, $parameters, $tableName);
        // debug($statement,-2);
        $res = $this->databaseHandle->sql_query($statement);
        $this->checkSqlErrors($statement);
        $row = $this->databaseHandle->sql_fetch_assoc($res);
        if ($row !== false) {
            return (int)$row['uid'];
        } else {
            return false;
        }
    }

    protected function replacePlaceholders(&$sqlString, array $parameters, $tableName = 'foo')
    {
        // @todo profile this method again
        if (substr_count($sqlString, '?') !== count($parameters)) {
            throw new Exception('The number of question marks to replace must be equal to the number of parameters.', 1242816074);
        }
        $offset = 0;
        foreach ($parameters as $parameter) {
            $markPosition = strpos($sqlString, '?', $offset);
            if ($markPosition !== false) {
                if ($parameter === null) {
                    $parameter = 'NULL';
                } elseif (is_array($parameter) || $parameter instanceof \ArrayAccess || $parameter instanceof \Traversable) {
                    $items = [];
                    foreach ($parameter as $item) {
                        $items[] = $this->databaseHandle->fullQuoteStr($item, $tableName);
                    }
                    $parameter = '(' . implode(',', $items) . ')';
                } else {
                    $parameter = $this->databaseHandle->fullQuoteStr($parameter, $tableName);
                }
                $sqlString = substr($sqlString, 0, $markPosition) . $parameter . substr($sqlString, ($markPosition + 1));
            }
            $offset = $markPosition + strlen($parameter);
        }
    }

    protected function addVisibilityConstraintStatement(QuerySettingsInterface $querySettings, $tableName, array &$sql)
    {
        $statement = '';
        if (is_array($GLOBALS['TCA'][$tableName]['ctrl'])) {
            $ignoreEnableFields = $querySettings->getIgnoreEnableFields();
            $enableFieldsToBeIgnored = $querySettings->getEnableFieldsToBeIgnored();
            $includeDeleted = $querySettings->getIncludeDeleted();
            if ($this->environmentService->isEnvironmentInFrontendMode()) {
                $statement .= $this->getFrontendConstraintStatement($tableName, $ignoreEnableFields, $enableFieldsToBeIgnored, $includeDeleted);
            } else {
                // TYPO3_MODE === 'BE'
                $statement .= $this->getBackendConstraintStatement($tableName, $ignoreEnableFields, $includeDeleted);
            }
            if (!empty($statement)) {
                $statement = strtolower(substr($statement, 1, 3)) === 'and' ? substr($statement, 5) : $statement;
                $sql['additionalWhereClause'][] = $statement;
            }
        }
    }

    protected function getFrontendConstraintStatement($tableName, $ignoreEnableFields, array $enableFieldsToBeIgnored = [], $includeDeleted)
    {
        $statement = '';
        if ($ignoreEnableFields && !$includeDeleted) {
            if (!empty($enableFieldsToBeIgnored)) {
                // array_combine() is necessary because of the way \TYPO3\CMS\Frontend\Page\PageRepository::enableFields() is implemented
                $statement .= $this->getPageRepository()->enableFields($tableName, -1, array_combine($enableFieldsToBeIgnored, $enableFieldsToBeIgnored));
            } else {
                $statement .= $this->getPageRepository()->deleteClause($tableName);
            }
        } elseif (!$ignoreEnableFields && !$includeDeleted) {
            $statement .= $this->getPageRepository()->enableFields($tableName);
        } elseif (!$ignoreEnableFields && $includeDeleted) {
            throw new Exception\InconsistentQuerySettingsException('Query setting "ignoreEnableFields=FALSE" can not be used together with "includeDeleted=TRUE" in frontend context.', 1327678173);
        }
        return $statement;
    }

    protected function getBackendConstraintStatement($tableName, $ignoreEnableFields, $includeDeleted)
    {
        $statement = '';
        if (!$ignoreEnableFields) {
            $statement .= BackendUtility::BEenableFields($tableName);
        }
        if (!$includeDeleted) {
            $statement .= BackendUtility::deleteClause($tableName);
        }
        return $statement;
    }

    protected function doLanguageAndWorkspaceOverlay(Qom\SourceInterface $source, array $rows, QuerySettingsInterface $querySettings, $workspaceUid = null)
    {
        if ($source instanceof Qom\SelectorInterface) {
            $tableName = $source->getSelectorName();
        } elseif ($source instanceof Qom\JoinInterface) {
            $tableName = $source->getRight()->getSelectorName();
        } else {
            // No proper source, so we do not have a table name here
            // we cannot do an overlay and return the original rows instead.
            return $rows;
        }

        $pageRepository = $this->getPageRepository();
        if (is_object($this->getTSFE())) {
            if ($workspaceUid !== null) {
                $pageRepository->versioningWorkspaceId = $workspaceUid;
            }
        } else {
            if ($workspaceUid === null) {
                $workspaceUid = $this->getBeUser()->workspace;
            }
            $pageRepository->versioningWorkspaceId = $workspaceUid;
        }

        // Fetches the move-placeholder in case it is supported
        // by the table and if there's only one row in the result set
        // (applying this to all rows does not work, since the sorting
        // order would be destroyed and possible limits not met anymore)
        if (!empty($pageRepository->versioningWorkspaceId)
            && BackendUtility::isTableWorkspaceEnabled($tableName)
            && count($rows) === 1
        ) {
            $movePlaceholder = $this->databaseHandle->exec_SELECTgetSingleRow(
                $tableName . '.*',
                $tableName,
                't3ver_state=3 AND t3ver_wsid=' . $pageRepository->versioningWorkspaceId
                    . ' AND t3ver_move_id=' . $rows[0]['uid']
            );
            if (!empty($movePlaceholder)) {
                $rows = [$movePlaceholder];
            }
        }

        $overlaidRows = [];
        foreach ($rows as $row) {
            // If current row is a translation select its parent
            if (isset($tableName) && isset($GLOBALS['TCA'][$tableName])
                && isset($GLOBALS['TCA'][$tableName]['ctrl']['languageField'])
                && isset($GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField'])
                && !isset($GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerTable'])
            ) {
                if (isset($row[$GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField']])
                    && $row[$GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField']] > 0
                ) {
                    $row = $this->databaseHandle->exec_SELECTgetSingleRow(
                        $tableName . '.*',
                        $tableName,
                        $tableName . '.uid=' . (int)$row[$GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField']] .
                            ' AND ' . $tableName . '.' . $GLOBALS['TCA'][$tableName]['ctrl']['languageField'] . '=0'
                    );
                }
            }
            $pageRepository->versionOL($tableName, $row, true);
            if ($tableName == 'pages') {
                $row = $pageRepository->getPageOverlay($row, $querySettings->getLanguageUid());
            } elseif (isset($GLOBALS['TCA'][$tableName]['ctrl']['languageField'])
                && $GLOBALS['TCA'][$tableName]['ctrl']['languageField'] !== ''
                && !isset($GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerTable'])
            ) {
                if (in_array($row[$GLOBALS['TCA'][$tableName]['ctrl']['languageField']], [-1, 0])) {
                    $overlayMode = $querySettings->getLanguageMode() === 'strict' ? 'hideNonTranslated' : '';
                    $row = $pageRepository->getRecordOverlay($tableName, $row, $querySettings->getLanguageUid(), $overlayMode);
                }
            }
            if ($row !== null && is_array($row)) {
                $overlaidRows[] = $row;
            }
        }
        return $overlaidRows;
    }

    protected function getPageRepository()
    {
        if (!$this->pageRepository instanceof PageRepository) {
            if ($this->environmentService->isEnvironmentInFrontendMode() && is_object($this->getTSFE())) {
                $this->pageRepository = $this->getTSFE()->sys_page;
            } else {
                $this->pageRepository = GeneralUtility::makeInstance(PageRepository::class);
            }
        }

        return $this->pageRepository;
    }

    protected function checkSqlErrors($sql = '')
    {
        $error = $this->databaseHandle->sql_error();
        if ($error !== '') {
            $error .= $sql ? ': ' . $sql : '';
            throw new SqlErrorException($error, 1247602160);
        }
    }

    protected function clearPageCache($tableName, $uid)
    {
        $frameworkConfiguration = $this->configurationManager->getConfiguration(ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
        if (isset($frameworkConfiguration['persistence']['enableAutomaticCacheClearing']) && $frameworkConfiguration['persistence']['enableAutomaticCacheClearing'] === '1') {
        } else {
            // if disabled, return
            return;
        }
        $pageIdsToClear = [];
        $storagePage = null;
        $columns = $this->databaseHandle->admin_get_fields($tableName);
        $tsfe = $this->getTSFE();
        if (array_key_exists('pid', $columns)) {
            $result = $this->databaseHandle->exec_SELECTquery('pid', $tableName, 'uid=' . (int)$uid);
            if ($row = $this->databaseHandle->sql_fetch_assoc($result)) {
                $storagePage = $row['pid'];
                $pageIdsToClear[] = $storagePage;
            }
        } elseif (isset($tsfe)) {
            // No PID column - we can do a best-effort to clear the cache of the current page if in FE
            $storagePage = $tsfe->id;
            $pageIdsToClear[] = $storagePage;
        }
        if ($storagePage === null) {
            return;
        }
        if (!isset($this->pageTSConfigCache[$storagePage])) {
            $this->pageTSConfigCache[$storagePage] = BackendUtility::getPagesTSconfig($storagePage);
        }
        if (isset($this->pageTSConfigCache[$storagePage]['TCEMAIN.']['clearCacheCmd'])) {
            $clearCacheCommands = GeneralUtility::trimExplode(',', strtolower($this->pageTSConfigCache[$storagePage]['TCEMAIN.']['clearCacheCmd']), true);
            $clearCacheCommands = array_unique($clearCacheCommands);
            foreach ($clearCacheCommands as $clearCacheCommand) {
                if (MathUtility::canBeInterpretedAsInteger($clearCacheCommand)) {
                    $pageIdsToClear[] = $clearCacheCommand;
                }
            }
        }

        foreach ($pageIdsToClear as $pageIdToClear) {
            $this->cacheService->getPageIdStack()->push($pageIdToClear);
        }
    }

    protected function getQueryCacheEntry($entryIdentifier)
    {
        if (!isset($this->queryRuntimeCache[$entryIdentifier])) {
            $this->queryRuntimeCache[$entryIdentifier] = $this->queryCache->get($entryIdentifier);
        }
        return $this->queryRuntimeCache[$entryIdentifier];
    }

    protected function setQueryCacheEntry($entryIdentifier, $variable)
    {
        $this->queryRuntimeCache[$entryIdentifier] = $variable;
        $this->queryCache->set($entryIdentifier, $variable, [], 0);
    }

    protected function getTSFE()
    {
        return isset($GLOBALS['TSFE']) ? $GLOBALS['TSFE'] : null;
    }

    protected function getBeUser()
    {
        return isset($GLOBALS['BE_USER']) ? $GLOBALS['BE_USER'] : null;
    }
}