TYPO3 Core

<?php
namespace Vendor\Extension\Xclass\TYPO3;

use TYPO3\CMS\Core\Context\Context;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;
use TYPO3\CMS\Extbase\Persistence\Generic\QuerySettingsInterface;

class Typo3DbQueryParser extends \TYPO3\CMS\Extbase\Persistence\Generic\Storage\Typo3DbQueryParser {
    /**
     * Builds the language field statement
     *
     * @param string $tableName The database table name
     * @param string $tableAlias The table alias used in the query.
     * @param QuerySettingsInterface $querySettings The TYPO3 CMS specific query settings
     * @return string
     */
    protected function getLanguageStatement($tableName, $tableAlias, QuerySettingsInterface $querySettings)
    {
        if (empty($GLOBALS['TCA'][$tableName]['ctrl']['languageField'])) {
            return '';
        }
        if(!isset($GLOBALS['TCA'][$tableName]['ctrl']['languageAspect']) || $GLOBALS['TCA'][$tableName]['ctrl']['languageAspect'] == false) {
            return parent::getLanguageStatement($tableName, $tableAlias, $querySettings);
        }

        $fallbackChain = array_unique(array_filter(GeneralUtility::makeInstance(Context::class)->getAspect('language')->getFallbackChain(), function ($item) {
            return MathUtility::canBeInterpretedAsInteger($item);
        }));

        // Select all entries for the current language
        // If any language is set -> get those entries which are not translated yet
        // They will be removed by \TYPO3\CMS\Frontend\Page\PageRepository::getRecordOverlay if not matching overlay mode
        $languageField = $GLOBALS['TCA'][$tableName]['ctrl']['languageField'];

        $transOrigPointerField = $GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField'] ?? '';
        if (!$transOrigPointerField || !$querySettings->getLanguageUid()) {
            return $this->queryBuilder->expr()->in(
                $tableAlias . '.' . $languageField,
                [(int)$querySettings->getLanguageUid(), -1]
            );
        }

        $mode = $querySettings->getLanguageOverlayMode();
        if (!$mode) {
            return $this->queryBuilder->expr()->in(
                $tableAlias . '.' . $languageField,
                [(int)$querySettings->getLanguageUid(), -1]
            );
        }

        $defLangTableAlias = $tableAlias . '_dl';
        $defaultLanguageRecordsSubSelect = $this->queryBuilder->getConnection()->createQueryBuilder();
        $defaultLanguageRecordsSubSelect
            ->select($defLangTableAlias . '.uid')
            ->from($tableName, $defLangTableAlias)
            ->where(
                $defaultLanguageRecordsSubSelect->expr()->andX(
                    $defaultLanguageRecordsSubSelect->expr()->eq($defLangTableAlias . '.' . $transOrigPointerField, 0),
                    $defaultLanguageRecordsSubSelect->expr()->eq($defLangTableAlias . '.' . $languageField, 0)
                )
            );

        $andConditions = [];
        // records in language 'all'
        $andConditions[] = $this->queryBuilder->expr()->eq($tableAlias . '.' . $languageField, -1);
        // translated records where a default language exists
        $andConditions[] = $this->queryBuilder->expr()->andX(
            $this->queryBuilder->expr()->eq($tableAlias . '.' . $languageField, (int)$querySettings->getLanguageUid()),
            $this->queryBuilder->expr()->in(
                $tableAlias . '.' . $transOrigPointerField,
                $defaultLanguageRecordsSubSelect->getSQL()
            )
        );
        if(count($fallbackChain) == 1) {
            $translatedOnlyTableAlias = $tableAlias . '_to';
            $queryBuilderForSubselect = $this->queryBuilder->getConnection()->createQueryBuilder();
            $queryBuilderForSubselect
                ->select($translatedOnlyTableAlias . '.l10n_parent' )
                ->from($tableName, $translatedOnlyTableAlias)
                ->where(
                    $queryBuilderForSubselect->expr()->andX(
                        $queryBuilderForSubselect->expr()->gt($translatedOnlyTableAlias . '.' . $transOrigPointerField, 0),
                        $queryBuilderForSubselect->expr()->eq($translatedOnlyTableAlias . '.' . $languageField, $querySettings->getLanguageUid())
                    )
                );

            $andConditions[] = $this->queryBuilder->expr()->andX(
                $this->queryBuilder->expr()->in($tableAlias . '.' . $languageField, $fallbackChain),
                $this->queryBuilder->expr()->notIn(
                    $tableAlias . '.l10n_parent',
                    $queryBuilderForSubselect->getSQL()
                )
            );
        }

        return $this->queryBuilder->expr()->orX(...$andConditions);
    }
}

<?php

namespace Vendor\Extension\Xclass\TYPO3;

use Doctrine\DBAL\FetchMode;
use TYPO3\CMS\Core\Context\Context;
use TYPO3\CMS\Core\Database\Connection;
use TYPO3\CMS\Core\Utility\ArrayUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;
use TYPO3\CMS\Extbase\Persistence\Generic\QuerySettingsInterface;

class Typo3DbQueryParser extends \TYPO3\CMS\Extbase\Persistence\Generic\Storage\Typo3DbQueryParser {
    /**
     * Builds the language field statement
     *
     * @param string $tableName The database table name
     * @param string $tableAlias The table alias used in the query.
     * @param QuerySettingsInterface $querySettings The TYPO3 CMS specific query settings
     * @return string
     */
    protected function getLanguageStatement($tableName, $tableAlias, QuerySettingsInterface $querySettings)
    {
        if (empty($GLOBALS['TCA'][$tableName]['ctrl']['languageField'])) {
            return '';
        }
        if(!isset($GLOBALS['TCA'][$tableName]['ctrl']['languageAspect']) || $GLOBALS['TCA'][$tableName]['ctrl']['languageAspect'] == false) {
            return parent::getLanguageStatement($tableName, $tableAlias, $querySettings);
        }

        $languageField = $GLOBALS['TCA'][$tableName]['ctrl']['languageField'];

        $transOrigPointerField = $GLOBALS['TCA'][$tableName]['ctrl']['transOrigPointerField'] ?? '';

        $mode = $querySettings->getLanguageOverlayMode();

        if (!$transOrigPointerField || !$querySettings->getLanguageUid() || !$mode) {
            return $this->queryBuilder->expr()->in(
                $tableAlias . '.' . $languageField,
                [(int)$querySettings->getLanguageUid(), -1]
            );
        }

        $andConditions = [];
        $andConditions[] = $this->queryBuilder->expr()->eq($tableAlias . '.' . $languageField, -1);
        $fallbackCain = GeneralUtility::makeInstance(Context::class)->getAspect('language')->getFallbackChain();
        $languageOrder = array_merge([$querySettings->getLanguageUid()], array_unique(array_filter($fallbackCain, function ($item) {
            return MathUtility::canBeInterpretedAsInteger($item);
        })));

        $fallbackUidList = $this->queryBuilder->getConnection()->createQueryBuilder();
        $fallbackUidList
            ->selectLiteral("`uid`, IF(`". $transOrigPointerField. "` = 0, `uid`, `". $transOrigPointerField. "`) AS group_field,`sys_language_uid`")
            ->from($tableName)
            ->where(
                $fallbackUidList->expr()->in('sys_language_uid', $languageOrder)
            )
            ->add('orderBy', 'FIELD(`sys_language_uid`,' . implode(',', $languageOrder ). ')')
            #->setMaxResults(1000000); if there are problems with big queries, limit forces indexes to be used

        /** @var Connection $connection */
        $connection = $this->queryBuilder->getConnection();
        $res = $connection->executeQuery("SELECT `uid` FROM (" . $fallbackUidList->getSQL(). ") as tmp GROUP BY `tmp`.`group_field`")->fetchAll(FetchMode::NUMERIC);
        if(count($res)) {
            $andConditions[] = $this->queryBuilder->expr()->andX(
                $this->queryBuilder->expr()->in($tableAlias . '.' . $languageField, $languageOrder),
                $this->queryBuilder->expr()->in(
                    $tableAlias . '.uid',
                    ArrayUtility::flatten($res)
                )
            );
        }
        return $this->queryBuilder->expr()->orX(...$andConditions);
    }
}

<?php

namespace Vendor\Extension\Xclass\TYPO3;

use TYPO3\CMS\Core\Database\Connection;
use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\Database\Query\Restriction\FrontendRestrictionContainer;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;

class PageRepository extends \TYPO3\CMS\Frontend\Page\PageRepository {

    /**
     * Creates language-overlay for records in general (where translation is found
     * in records from the same table)
     *
     * @param string $table Table name
     * @param array $row Record to overlay. Must contain uid, pid and $table]['ctrl']['languageField']
     * @param int $sys_language_content Pointer to the sys_language uid for content on the site.
     * @param string $OLmode Overlay mode. If "hideNonTranslated" then records without translation will not be returned  un-translated but unset (and return value is FALSE)
     * @param array fallbackChain for translations
     * @throws \UnexpectedValueException
     * @return mixed Returns the input record, possibly overlaid with a translation.  But if $OLmode is "hideNonTranslated" then it will return FALSE if no translation is found.
     */
    public function getRecordOverlay($table, $row, $sys_language_content, $OLmode = '') {
        $tableControl = $GLOBALS['TCA'][$table]['ctrl'] ?? [];
        if(!isset($tableControl['languageAspect']) || $tableControl['languageAspect'] == false) {
            return parent::getRecordOverlay($table, $row, $sys_language_content, $OLmode);
        }
        $sys_language_content = $this->context->getAspect('language')->getId();
        $fallbackChain = array_unique(array_filter($this->context->getAspect('language')->getFallbackChain(), function ($item) {
            return MathUtility::canBeInterpretedAsInteger($item);
        }));
        if (!empty($tableControl['languageField'])
            // Return record for ALL languages untouched
            // TODO: Fix call stack to prevent this situation in the first place
            && (int)$row[$tableControl['languageField']] !== -1
            && !empty($tableControl['transOrigPointerField'])
            && $row['uid'] > 0
            && ($row['pid'] > 0 || in_array($tableControl['rootLevel'] ?? false, [true, 1, -1], true))) {
            // Will try to overlay a record only if the sys_language_content value is larger than zero.
            if ($sys_language_content !== $row[$tableControl['languageField']]) {
                // Must be default language, otherwise no overlaying
                if ((int)$row[$tableControl['languageField']] === 0) {
                    // Select overlay record:
                    $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                        ->getQueryBuilderForTable($table);
                    $queryBuilder->setRestrictions(
                        GeneralUtility::makeInstance(FrontendRestrictionContainer::class)
                    );
                    $languageChain = implode(',', array_merge([$sys_language_content],$fallbackChain));
                    $query = $queryBuilder->select('*')
                        ->from($table)
                        ->where(
                            $queryBuilder->expr()->eq(
                                'pid',
                                $queryBuilder->createNamedParameter($row['pid'], \PDO::PARAM_INT)
                            ),
                            $queryBuilder->expr()->in(
                                $tableControl['languageField'],
                                $queryBuilder->createNamedParameter(GeneralUtility::intExplode(',', $languageChain), Connection::PARAM_INT_ARRAY)
                            ),
                            $queryBuilder->expr()->eq(
                                $tableControl['transOrigPointerField'],
                                $queryBuilder->createNamedParameter($row['uid'], \PDO::PARAM_INT)
                            )
                        )
                        ->add('orderBy', 'FIELD(' . $tableControl['languageField'] . ', ' . $languageChain . ')', true)
                        ->setMaxResults(1);
                    $olrow = $query->execute()
                        ->fetch();
                    $this->versionOL($table, $olrow);
                    // Merge record content by traversing all fields:
                    if (is_array($olrow)) {
                        if (isset($olrow['_ORIG_uid'])) {
                            $row['_ORIG_uid'] = $olrow['_ORIG_uid'];
                        }
                        if (isset($olrow['_ORIG_pid'])) {
                            $row['_ORIG_pid'] = $olrow['_ORIG_pid'];
                        }
                        foreach ($row as $fN => $fV) {
                            if ($fN !== 'uid' && $fN !== 'pid' && isset($olrow[$fN])) {
                                $row[$fN] = $olrow[$fN];
                            } elseif ($fN === 'uid') {
                                $row['_LOCALIZED_UID'] = $olrow['uid'];
                            }
                        }
                    } elseif (!in_array($row[$tableControl['languageField']], $fallbackChain)) {
                        unset($row);
                    }
                } elseif ($sys_language_content != $row[$tableControl['languageField']]) {
                    unset($row);
                }
            } elseif($sys_language_content == 0 && $row[$tableControl['languageField']] > 0) {
                unset($row);
            }
        }
        return $row;
    }

}