Backend.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Extbase\Persistence\Generic;
 
use Psr\EventDispatcher\EventDispatcherInterface;
use ‪TYPO3\CMS\Core\Context\LanguageAspect;
use ‪TYPO3\CMS\Core\Database\ReferenceIndex;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use ‪TYPO3\CMS\Extbase\DomainObject\AbstractDomainObject;
use ‪TYPO3\CMS\Extbase\DomainObject\AbstractValueObject;
use ‪TYPO3\CMS\Extbase\DomainObject\DomainObjectInterface;
use ‪TYPO3\CMS\Extbase\Event\Persistence\EntityAddedToPersistenceEvent;
use ‪TYPO3\CMS\Extbase\Event\Persistence\EntityFinalizedAfterPersistenceEvent;
use ‪TYPO3\CMS\Extbase\Event\Persistence\EntityPersistedEvent;
use ‪TYPO3\CMS\Extbase\Event\Persistence\EntityRemovedFromPersistenceEvent;
use ‪TYPO3\CMS\Extbase\Event\Persistence\EntityUpdatedInPersistenceEvent;
use ‪TYPO3\CMS\Extbase\Event\Persistence\ModifyQueryBeforeFetchingObjectDataEvent;
use ‪TYPO3\CMS\Extbase\Event\Persistence\ModifyResultAfterFetchingObjectDataEvent;
use ‪TYPO3\CMS\Extbase\Persistence\Exception\IllegalRelationTypeException;
use ‪TYPO3\CMS\Extbase\Persistence\Generic\Mapper\ColumnMap;
use ‪TYPO3\CMS\Extbase\Persistence\Generic\Mapper\ColumnMap\Relation;
use ‪TYPO3\CMS\Extbase\Persistence\Generic\Mapper\DataMapFactory;
use ‪TYPO3\CMS\Extbase\Persistence\Generic\Mapper\DataMapper;
use ‪TYPO3\CMS\Extbase\Persistence\ObjectStorage;
use ‪TYPO3\CMS\Extbase\Persistence\PersistenceManagerInterface;
use ‪TYPO3\CMS\Extbase\Persistence\QueryInterface;
use ‪TYPO3\CMS\Extbase\Reflection\ObjectAccess;
use ‪TYPO3\CMS\Extbase\Reflection\ReflectionService;
 
class ‪Backend implements ‪BackendInterface, ‪SingletonInterface
{
    protected ‪$session;
 
    protected ‪$persistenceManager;
 
    protected ‪$aggregateRootObjects;
 
    protected ‪$deletedEntities;
 
    protected ‪$changedEntities;
 
    protected ‪$visitedDuringPersistence;
 
    protected ‪$reflectionService;
 
    protected ‪$storageBackend;
 
    protected ‪$dataMapFactory;
 
    protected ‪$referenceIndex;
 
    protected ‪$configurationManager;
 
    protected ‪$eventDispatcher;
 
    public function ‪__construct(
        ‪ConfigurationManagerInterface ‪$configurationManager,
        ‪Session ‪$session,
        ‪ReflectionService ‪$reflectionService,
        \‪TYPO3\CMS\‪Extbase\Persistence\Generic\Storage\‪BackendInterface ‪$storageBackend,
        ‪DataMapFactory ‪$dataMapFactory,
        EventDispatcherInterface ‪$eventDispatcher
    ) {
        $this->configurationManager = ‪$configurationManager;
        $this->session = ‪$session;
        $this->reflectionService = ‪$reflectionService;
        $this->storageBackend = ‪$storageBackend;
        $this->dataMapFactory = ‪$dataMapFactory;
        $this->eventDispatcher = ‪$eventDispatcher;
 
        $this->referenceIndex = GeneralUtility::makeInstance(ReferenceIndex::class);
        $this->aggregateRootObjects = new ‪ObjectStorage();
        $this->deletedEntities = new ‪ObjectStorage();
        $this->changedEntities = new ‪ObjectStorage();
    }
 
    public function ‪setPersistenceManager(‪PersistenceManagerInterface ‪$persistenceManager)
    {
        $this->persistenceManager = ‪$persistenceManager;
    }
 
    public function ‪getObjectCountByQuery(‪QueryInterface $query)
    {
        return $this->storageBackend->getObjectCountByQuery($query);
    }
 
    public function ‪getObjectDataByQuery(QueryInterface $query)
    {
        $event = new ModifyQueryBeforeFetchingObjectDataEvent($query);
        $this->eventDispatcher->dispatch($event);
        $query = $event->getQuery();
        $result = $this->storageBackend->getObjectDataByQuery($query);
        $event = new ‪ModifyResultAfterFetchingObjectDataEvent($query, $result);
        $this->eventDispatcher->dispatch($event);
        return $event->getResult();
    }
 
    public function ‪getIdentifierByObject($object)
    {
        if ($object instanceof ‪LazyLoadingProxy) {
            $object = $object->_loadRealInstance();
        }
 
        return is_object($object) ? $this->session->getIdentifierByObject($object) : null;
    }
 
    public function ‪getObjectByIdentifier(‪$identifier, $className)
    {
        if ($this->session->hasIdentifier(‪$identifier, $className)) {
            return $this->session->getObjectByIdentifier(‪$identifier, $className);
        }
        $query = $this->persistenceManager->createQueryForType($className);
        $query->getQuerySettings()->setRespectStoragePage(false);
        $query->getQuerySettings()->setRespectSysLanguage(false);
        // This allows to fetch IDs for languages for default language AND language IDs
        // This is especially important when using the PropertyMapper of the Extbase MVC part to get
        // an object of the translated version of the incoming ID of a record.
        $languageAspect = $query->getQuerySettings()->getLanguageAspect();
        $languageAspect = new LanguageAspect(
            $languageAspect->getId(),
            $languageAspect->getContentId(),
            $languageAspect->getOverlayType() === ‪LanguageAspect::OVERLAYS_OFF ? ‪LanguageAspect::OVERLAYS_ON_WITH_FLOATING : $languageAspect->getOverlayType()
        );
        $query->getQuerySettings()->setLanguageAspect($languageAspect);
        return $query->matching($query->equals('uid', ‪$identifier))->execute()->getFirst();
    }
 
    public function ‪isNewObject($object)
    {
        return $this->‪getIdentifierByObject($object) === null;
    }
 
    public function ‪setAggregateRootObjects(‪ObjectStorage $objects)
    {
        $this->aggregateRootObjects = $objects;
    }
 
    public function ‪setChangedEntities(‪ObjectStorage $entities)
    {
        $this->changedEntities = $entities;
    }
 
    public function ‪setDeletedEntities(‪ObjectStorage $entities)
    {
        $this->deletedEntities = $entities;
    }
 
    public function ‪commit()
    {
        $this->‪persistObjects();
        $this->‪processDeletedObjects();
    }
 
    protected function ‪persistObjects()
    {
        $this->visitedDuringPersistence = new ‪ObjectStorage();
        foreach ($this->aggregateRootObjects as $object) {
            if ($object->_isNew()) {
                $this->‪insertObject($object);
            }
            $this->‪persistObject($object);
        }
        foreach ($this->changedEntities as $object) {
            $this->‪persistObject($object);
        }
    }
 
    protected function ‪persistObject(DomainObjectInterface $object)
    {
        if (isset($this->visitedDuringPersistence[$object])) {
            return;
        }
        $row = [];
        $queue = [];
        $className = get_class($object);
        $dataMap = $this->dataMapFactory->buildDataMap($className);
        $classSchema = $this->reflectionService->getClassSchema($className);
        foreach ($classSchema->getDomainObjectProperties() as $property) {
            $propertyName = $property->getName();
            if (!$dataMap->isPersistableProperty($propertyName)) {
                continue;
            }
            $propertyValue = $object->_getProperty($propertyName);
            if ($this->‪propertyValueIsLazyLoaded($propertyValue)) {
                continue;
            }
            $columnMap = $dataMap->getColumnMap($propertyName);
            if ($propertyValue instanceof ObjectStorage) {
                $cleanProperty = $object->_getCleanProperty($propertyName);
                // objectstorage needs to be persisted if the object is new, the objectstorage is dirty, meaning it has
                // been changed after initial build, or an empty objectstorage is present and the cleanstate objectstorage
                // has childelements, meaning all elements should been removed from the objectstorage
                if ($object->_isNew() || $propertyValue->_isDirty() || ($propertyValue->count() === 0 && $cleanProperty && $cleanProperty->count() > 0)) {
                    $this->‪persistObjectStorage($propertyValue, $object, $propertyName, $row);
                    $propertyValue->_memorizeCleanState();
                }
                foreach ($propertyValue as $containedObject) {
                    if ($containedObject instanceof DomainObjectInterface) {
                        $queue[] = $containedObject;
                    }
                }
            } elseif ($propertyValue instanceof DomainObjectInterface) {
                if ($object->_isDirty($propertyName)) {
                    if ($propertyValue->_isNew()) {
                        $this->‪insertObject($propertyValue, $object, $propertyName);
                    }
                    $row[$columnMap->getColumnName()] = $this->‪getPlainValue($propertyValue);
                }
                $queue[] = $propertyValue;
            } elseif ($object->_isNew() || $object->_isDirty($propertyName)) {
                $row[$columnMap->getColumnName()] = $this->‪getPlainValue($propertyValue, $columnMap);
            }
        }
        if (!empty($row)) {
            $this->‪updateObject($object, $row);
            $object->_memorizeCleanState();
        }
        $this->visitedDuringPersistence[$object] = $object->getUid();
        foreach ($queue as $queuedObject) {
            $this->‪persistObject($queuedObject);
        }
        $this->eventDispatcher->dispatch(new ‪EntityPersistedEvent($object));
    }
 
    protected function ‪propertyValueIsLazyLoaded($propertyValue)
    {
        if ($propertyValue instanceof LazyLoadingProxy) {
            return true;
        }
        if ($propertyValue instanceof LazyObjectStorage) {
            if ($propertyValue->isInitialized() === false) {
                return true;
            }
        }
        return false;
    }
 
    protected function ‪persistObjectStorage(‪ObjectStorage $objectStorage, ‪DomainObjectInterface $parentObject, $propertyName, array &$row)
    {
        $className = get_class($parentObject);
        $dataMapper = GeneralUtility::makeInstance(DataMapper::class);
        $columnMap = $this->dataMapFactory->buildDataMap($className)->getColumnMap($propertyName);
        $property = $this->reflectionService->getClassSchema($className)->getProperty($propertyName);
        foreach ($this->‪getRemovedChildObjects($parentObject, $propertyName) as $removedObject) {
            $this->‪detachObjectFromParentObject($removedObject, $parentObject, $propertyName);
            if ($columnMap->getTypeOfRelation() === Relation::HAS_MANY && $property->getCascadeValue() === 'remove') {
                $this->‪removeEntity($removedObject);
            }
        }
 
        $currentUids = [];
        $sortingPosition = 1;
        $updateSortingOfFollowing = false;
 
        foreach ($objectStorage as $object) {
            if (empty($currentUids)) {
                $sortingPosition = 1;
            } else {
                $sortingPosition++;
            }
            $cleanProperty = $parentObject->_getCleanProperty($propertyName);
            if ($object->_isNew()) {
                $this->‪insertObject($object);
                $this->‪attachObjectToParentObject($object, $parentObject, $propertyName, $sortingPosition);
                // if a new object is inserted, all objects after this need to have their sorting updated
                $updateSortingOfFollowing = true;
            } elseif ($cleanProperty === null || $cleanProperty->getPosition($object) === null) {
                // if parent object is new then it doesn't have cleanProperty yet; before attaching object it's clean position is null
                $this->‪attachObjectToParentObject($object, $parentObject, $propertyName, $sortingPosition);
                // if a relation is dirty (speaking the same object is removed and added again at a different position), all objects after this needs to be updated the sorting
                $updateSortingOfFollowing = true;
            } elseif ($objectStorage->‪isRelationDirty($object) || $cleanProperty->getPosition($object) !== $objectStorage->‪getPosition($object)) {
                $this->‪updateRelationOfObjectToParentObject($object, $parentObject, $propertyName, $sortingPosition);
                $updateSortingOfFollowing = true;
            } elseif ($updateSortingOfFollowing) {
                if ($sortingPosition > $objectStorage->‪getPosition($object)) {
                    $this->‪updateRelationOfObjectToParentObject($object, $parentObject, $propertyName, $sortingPosition);
                } else {
                    $sortingPosition = $objectStorage->‪getPosition($object);
                }
            }
            $currentUids[] = $object->getUid();
        }
 
        if ($columnMap->getParentKeyFieldName() === null) {
            $row[$columnMap->getColumnName()] = implode(',', $currentUids);
        } else {
            $row[$columnMap->getColumnName()] = $dataMapper->countRelated($parentObject, $propertyName);
        }
    }
 
    protected function ‪getRemovedChildObjects(‪DomainObjectInterface $object, $propertyName)
    {
        $removedObjects = [];
        $cleanPropertyValue = $object->_getCleanProperty($propertyName);
        if (is_array($cleanPropertyValue) || $cleanPropertyValue instanceof \Iterator) {
            $propertyValue = $object->‪_getProperty($propertyName);
            foreach ($cleanPropertyValue as $containedObject) {
                if (!$propertyValue->contains($containedObject)) {
                    $removedObjects[] = $containedObject;
                }
            }
        }
        return $removedObjects;
    }
 
    protected function ‪attachObjectToParentObject(DomainObjectInterface $object, DomainObjectInterface $parentObject, $parentPropertyName, $sortingPosition = 0)
    {
        $parentDataMap = $this->dataMapFactory->buildDataMap(get_class($parentObject));
 
        $parentColumnMap = $parentDataMap->getColumnMap($parentPropertyName);
        if ($parentColumnMap->getTypeOfRelation() === Relation::HAS_MANY) {
            $this->‪attachObjectToParentObjectRelationHasMany($object, $parentObject, $parentPropertyName, $sortingPosition);
        } elseif ($parentColumnMap->getTypeOfRelation() === Relation::HAS_AND_BELONGS_TO_MANY) {
            $this->‪insertRelationInRelationtable($object, $parentObject, $parentPropertyName, $sortingPosition);
        }
    }
 
    protected function ‪updateRelationOfObjectToParentObject(DomainObjectInterface $object, DomainObjectInterface $parentObject, $parentPropertyName, $sortingPosition = 0)
    {
        $parentDataMap = $this->dataMapFactory->buildDataMap(get_class($parentObject));
        $parentColumnMap = $parentDataMap->getColumnMap($parentPropertyName);
        if ($parentColumnMap->getTypeOfRelation() === Relation::HAS_MANY) {
            $this->‪attachObjectToParentObjectRelationHasMany($object, $parentObject, $parentPropertyName, $sortingPosition);
        } elseif ($parentColumnMap->getTypeOfRelation() === Relation::HAS_AND_BELONGS_TO_MANY) {
            $this->‪updateRelationInRelationTable($object, $parentObject, $parentPropertyName, $sortingPosition);
        }
    }
 
    protected function ‪attachObjectToParentObjectRelationHasMany(DomainObjectInterface $object, DomainObjectInterface $parentObject, $parentPropertyName, $sortingPosition = 0)
    {
        $parentDataMap = $this->dataMapFactory->buildDataMap(get_class($parentObject));
        $parentColumnMap = $parentDataMap->getColumnMap($parentPropertyName);
        if ($parentColumnMap->getTypeOfRelation() !== Relation::HAS_MANY) {
            throw new IllegalRelationTypeException(
                'Parent column relation type is ' . Relation::class . '::' . $parentColumnMap->getTypeOfRelation()->name .
                ' but should be ' . Relation::class . '::' . Relation::HAS_MANY->name,
                1345368105
            );
        }
        $row = [];
        $parentKeyFieldName = $parentColumnMap->getParentKeyFieldName();
        if ($parentKeyFieldName !== null) {
            $row[$parentKeyFieldName] = $parentObject->_getProperty(‪AbstractDomainObject::PROPERTY_LOCALIZED_UID) ?: $parentObject->getUid();
            $parentTableFieldName = $parentColumnMap->getParentTableFieldName();
            if ($parentTableFieldName !== null) {
                $row[$parentTableFieldName] = $parentDataMap->getTableName();
            }
            $relationTableMatchFields = $parentColumnMap->getRelationTableMatchFields();
            if (is_array($relationTableMatchFields)) {
                $row = array_merge($relationTableMatchFields, $row);
            }
        }
        $childSortByFieldName = $parentColumnMap->getChildSortByFieldName();
        if (!empty($childSortByFieldName)) {
            $row[$childSortByFieldName] = $sortingPosition;
        }
        if (!empty($row)) {
            $this->‪updateObject($object, $row);
        }
    }
 
    protected function ‪detachObjectFromParentObject(DomainObjectInterface $object, DomainObjectInterface $parentObject, $parentPropertyName)
    {
        $parentDataMap = $this->dataMapFactory->buildDataMap(get_class($parentObject));
        $parentColumnMap = $parentDataMap->getColumnMap($parentPropertyName);
        if ($parentColumnMap->getTypeOfRelation() === Relation::HAS_MANY) {
            $row = [];
            $parentKeyFieldName = $parentColumnMap->getParentKeyFieldName();
            if ($parentKeyFieldName !== null) {
                $row[$parentKeyFieldName] = 0;
                $parentTableFieldName = $parentColumnMap->getParentTableFieldName();
                if ($parentTableFieldName !== null) {
                    $row[$parentTableFieldName] = '';
                }
                $relationTableMatchFields = $parentColumnMap->getRelationTableMatchFields();
                if (is_array($relationTableMatchFields) && !empty($relationTableMatchFields)) {
                    $row = array_merge(array_fill_keys(array_keys($relationTableMatchFields), ''), $row);
                }
            }
            $childSortByFieldName = $parentColumnMap->getChildSortByFieldName();
            if (!empty($childSortByFieldName)) {
                $row[$childSortByFieldName] = 0;
            }
            if (!empty($row)) {
                $this->‪updateObject($object, $row);
            }
        } elseif ($parentColumnMap->getTypeOfRelation() === Relation::HAS_AND_BELONGS_TO_MANY) {
            $this->‪deleteRelationFromRelationtable($object, $parentObject, $parentPropertyName);
        }
    }
 
    protected function ‪insertObject(DomainObjectInterface $object, DomainObjectInterface $parentObject = null, $parentPropertyName = '')
    {
        if ($object instanceof AbstractValueObject) {
            $result = $this->‪getUidOfAlreadyPersistedValueObject($object);
            if ($result !== null) {
                $object->_setProperty(‪AbstractDomainObject::PROPERTY_UID, $result);
                return;
            }
        }
        $className = get_class($object);
        $dataMap = $this->dataMapFactory->buildDataMap($className);
        $row = [];
        $classSchema = $this->reflectionService->getClassSchema($className);
        foreach ($classSchema->getDomainObjectProperties() as $property) {
            $propertyName = $property->getName();
            if (!$dataMap->isPersistableProperty($propertyName)) {
                continue;
            }
            $propertyValue = $object->_getProperty($propertyName);
            if ($this->‪propertyValueIsLazyLoaded($propertyValue)) {
                continue;
            }
            $columnMap = $dataMap->getColumnMap($propertyName);
            if ($columnMap->getTypeOfRelation() === Relation::HAS_ONE) {
                $row[$columnMap->getColumnName()] = 0;
            } elseif ($columnMap->getTypeOfRelation() !== Relation::NONE) {
                if ($columnMap->getParentKeyFieldName() === null) {
                    // CSV type relation
                    $row[$columnMap->getColumnName()] = '';
                } else {
                    // MM type relation
                    $row[$columnMap->getColumnName()] = 0;
                }
            } elseif ($propertyValue !== null) {
                $row[$columnMap->getColumnName()] = $this->‪getPlainValue($propertyValue, $columnMap);
            }
        }
        $this->‪addCommonFieldsToRow($object, $row);
        if ($dataMap->getLanguageIdColumnName() !== null && $object->_getProperty(‪AbstractDomainObject::PROPERTY_LANGUAGE_UID) === null) {
            $row[$dataMap->getLanguageIdColumnName()] = 0;
            $object->_setProperty(‪AbstractDomainObject::PROPERTY_LANGUAGE_UID, 0);
        }
        if ($dataMap->getTranslationOriginColumnName() !== null) {
            $row[$dataMap->getTranslationOriginColumnName()] = 0;
        }
        if ($dataMap->getTranslationOriginDiffSourceName() !== null) {
            $row[$dataMap->getTranslationOriginDiffSourceName()] = '';
        }
        if ($parentObject !== null && $parentPropertyName) {
            $parentColumnDataMap = $this->dataMapFactory->buildDataMap(get_class($parentObject))->getColumnMap($parentPropertyName);
            $relationTableMatchFields = $parentColumnDataMap->getRelationTableMatchFields();
            if (is_array($relationTableMatchFields)) {
                $row = array_merge($relationTableMatchFields, $row);
            }
            if ($parentColumnDataMap->getParentKeyFieldName() !== null) {
                $row[$parentColumnDataMap->getParentKeyFieldName()] = (int)$parentObject->getUid();
            }
        }
        ‪$uid = $this->storageBackend->addRow($dataMap->getTableName(), $row);
        $localizedUid = $object->_getProperty(‪AbstractDomainObject::PROPERTY_LOCALIZED_UID);
        ‪$identifier = ‪$uid . ($localizedUid ? '_' . $localizedUid : '');
        $object->_setProperty(‪AbstractDomainObject::PROPERTY_UID, ‪$uid);
        $object->setPid((int)$row['pid']);
        if (‪$uid >= 1) {
            $this->eventDispatcher->dispatch(new EntityAddedToPersistenceEvent($object));
        }
        $frameworkConfiguration = $this->configurationManager->getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
        if (($frameworkConfiguration['persistence']['updateReferenceIndex'] ?? '') === '1') {
            $this->referenceIndex->updateRefIndexTable($dataMap->getTableName(), ‪$uid);
        }
        $this->session->registerObject($object, ‪$identifier);
        if (‪$uid >= 1) {
            $this->eventDispatcher->dispatch(new ‪EntityFinalizedAfterPersistenceEvent($object));
        }
    }
 
    protected function ‪getUidOfAlreadyPersistedValueObject(‪AbstractValueObject $object)
    {
        return $this->storageBackend->getUidOfAlreadyPersistedValueObject($object);
    }
 
    protected function ‪insertRelationInRelationtable(‪DomainObjectInterface $object, ‪DomainObjectInterface $parentObject, $propertyName, $sortingPosition = null)
    {
        $dataMap = $this->dataMapFactory->buildDataMap(get_class($parentObject));
        $columnMap = $dataMap->getColumnMap($propertyName);
        $parentUid = $parentObject->‪getUid();
        if ($parentObject->‪_getProperty(‪AbstractDomainObject::PROPERTY_LOCALIZED_UID) !== null) {
            $parentUid = $parentObject->‪_getProperty(‪AbstractDomainObject::PROPERTY_LOCALIZED_UID);
        }
        $row = [
            $columnMap->getParentKeyFieldName() => (int)$parentUid,
            $columnMap->getChildKeyFieldName() => (int)$object->‪getUid(),
            $columnMap->getChildSortByFieldName() => $sortingPosition !== null ? (int)$sortingPosition : 0,
        ];
        $relationTableName = $columnMap->getRelationTableName();
        if (isset(‪$GLOBALS['TCA'][$relationTableName])) {
            $row[‪AbstractDomainObject::PROPERTY_PID] = $this->‪determineStoragePageIdForNewRecord();
        }
        $relationTableMatchFields = $columnMap->getRelationTableMatchFields();
        if (is_array($relationTableMatchFields)) {
            $row = array_merge($relationTableMatchFields, $row);
        }
        $res = $this->storageBackend->addRow($relationTableName, $row, true);
        return $res;
    }
 
    protected function ‪updateRelationInRelationTable(‪DomainObjectInterface $object, ‪DomainObjectInterface $parentObject, $propertyName, $sortingPosition = 0)
    {
        $dataMap = $this->dataMapFactory->buildDataMap(get_class($parentObject));
        $columnMap = $dataMap->getColumnMap($propertyName);
        $row = [
            $columnMap->getParentKeyFieldName() => (int)$parentObject->‪getUid(),
            $columnMap->getChildKeyFieldName() => (int)$object->‪getUid(),
            $columnMap->getChildSortByFieldName() => (int)$sortingPosition,
        ];
        $relationTableName = $columnMap->getRelationTableName();
        $relationTableMatchFields = $columnMap->getRelationTableMatchFields();
        if (is_array($relationTableMatchFields)) {
            $row = array_merge($relationTableMatchFields, $row);
        }
        $this->storageBackend->updateRelationTableRow(
            $relationTableName,
            $row
        );
        return true;
    }
 
    protected function ‪deleteAllRelationsFromRelationtable(‪DomainObjectInterface $parentObject, $parentPropertyName)
    {
        $dataMap = $this->dataMapFactory->buildDataMap(get_class($parentObject));
        $columnMap = $dataMap->getColumnMap($parentPropertyName);
        $relationTableName = $columnMap->getRelationTableName();
        $relationMatchFields = [
            $columnMap->getParentKeyFieldName() => (int)$parentObject->‪getUid(),
        ];
        $relationTableMatchFields = $columnMap->getRelationTableMatchFields();
        if (is_array($relationTableMatchFields)) {
            $relationMatchFields = array_merge($relationTableMatchFields, $relationMatchFields);
        }
        $this->storageBackend->removeRow($relationTableName, $relationMatchFields, false);
        return true;
    }
 
    protected function ‪deleteRelationFromRelationtable(‪DomainObjectInterface $relatedObject, ‪DomainObjectInterface $parentObject, $parentPropertyName)
    {
        $dataMap = $this->dataMapFactory->buildDataMap(get_class($parentObject));
        $columnMap = $dataMap->getColumnMap($parentPropertyName);
        $relationTableName = $columnMap->getRelationTableName();
        $relationMatchFields = [
            $columnMap->getParentKeyFieldName() => (int)$parentObject->‪getUid(),
            $columnMap->getChildKeyFieldName() => (int)$relatedObject->‪getUid(),
        ];
        $relationTableMatchFields = $columnMap->getRelationTableMatchFields();
        if (is_array($relationTableMatchFields)) {
            $relationMatchFields = array_merge($relationTableMatchFields, $relationMatchFields);
        }
        $this->storageBackend->removeRow($relationTableName, $relationMatchFields, false);
        return true;
    }
 
    protected function ‪updateObject(‪DomainObjectInterface $object, array $row)
    {
        $dataMap = $this->dataMapFactory->buildDataMap(get_class($object));
        $this->‪addCommonFieldsToRow($object, $row);
        $row['uid'] = $object->‪getUid();
        if ($dataMap->getLanguageIdColumnName() !== null) {
            $row[$dataMap->getLanguageIdColumnName()] = (int)$object->‪_getProperty(‪AbstractDomainObject::PROPERTY_LANGUAGE_UID);
            if ($object->‪_getProperty(‪AbstractDomainObject::PROPERTY_LOCALIZED_UID) !== null) {
                $row['uid'] = $object->‪_getProperty(‪AbstractDomainObject::PROPERTY_LOCALIZED_UID);
            }
        }
        $this->storageBackend->updateRow($dataMap->getTableName(), $row);
        $this->eventDispatcher->dispatch(new ‪EntityUpdatedInPersistenceEvent($object));
 
        $frameworkConfiguration = $this->configurationManager->getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
        if (($frameworkConfiguration['persistence']['updateReferenceIndex'] ?? '') === '1') {
            $this->referenceIndex->updateRefIndexTable($dataMap->getTableName(), (int)$row['uid']);
        }
        return true;
    }
 
    protected function ‪addCommonFieldsToRow(‪DomainObjectInterface $object, array &$row)
    {
        $dataMap = $this->dataMapFactory->buildDataMap(get_class($object));
        $this->‪addCommonDateFieldsToRow($object, $row);
        if ($dataMap->getRecordTypeColumnName() !== null && $dataMap->getRecordType() !== null) {
            $row[$dataMap->getRecordTypeColumnName()] = $dataMap->getRecordType();
        }
        if ($object->‪_isNew() && !isset($row['pid'])) {
            $row['pid'] = $this->‪determineStoragePageIdForNewRecord($object);
        }
    }
 
    protected function ‪addCommonDateFieldsToRow(DomainObjectInterface $object, array &$row)
    {
        $dataMap = $this->dataMapFactory->buildDataMap(get_class($object));
        if ($object->_isNew() && $dataMap->getCreationDateColumnName() !== null) {
            $row[$dataMap->getCreationDateColumnName()] = ‪$GLOBALS['EXEC_TIME'];
        }
        if ($dataMap->getModificationDateColumnName() !== null) {
            $row[$dataMap->getModificationDateColumnName()] = ‪$GLOBALS['EXEC_TIME'];
        }
    }
 
    protected function ‪processDeletedObjects()
    {
        foreach ($this->deletedEntities as $entity) {
            if ($this->session->hasObject($entity)) {
                $this->‪removeEntity($entity);
                $this->session->unregisterReconstitutedEntity($entity);
                $this->session->unregisterObject($entity);
            }
        }
        $this->deletedEntities = new ‪ObjectStorage();
    }
 
    protected function ‪removeEntity(DomainObjectInterface $object, $markAsDeleted = true)
    {
        $dataMap = $this->dataMapFactory->buildDataMap(get_class($object));
        $tableName = $dataMap->getTableName();
        if ($markAsDeleted === true && $dataMap->getDeletedFlagColumnName() !== null) {
            $deletedColumnName = $dataMap->getDeletedFlagColumnName();
            $row = [
                'uid' => $object->getUid(),
                $deletedColumnName => 1,
            ];
            $this->‪addCommonDateFieldsToRow($object, $row);
            $this->storageBackend->updateRow($tableName, $row);
        } else {
            $this->storageBackend->removeRow($tableName, ['uid' => $object->getUid()]);
        }
        $this->eventDispatcher->dispatch(new EntityRemovedFromPersistenceEvent($object));
 
        $this->‪removeRelatedObjects($object);
        $frameworkConfiguration = $this->configurationManager->getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
        if (($frameworkConfiguration['persistence']['updateReferenceIndex'] ?? '') === '1') {
            $this->referenceIndex->updateRefIndexTable($tableName, $object->getUid());
        }
    }
 
    protected function ‪removeRelatedObjects(‪DomainObjectInterface $object)
    {
        $className = get_class($object);
        $dataMap = $this->dataMapFactory->buildDataMap($className);
        $classSchema = $this->reflectionService->getClassSchema($className);
        foreach ($classSchema->getDomainObjectProperties() as $property) {
            $propertyName = $property->getName();
            $columnMap = $dataMap->getColumnMap($propertyName);
            if ($columnMap === null) {
                continue;
            }
            $propertyValue = $object->‪_getProperty($propertyName);
            if ($property->getCascadeValue() === 'remove') {
                if ($columnMap->getTypeOfRelation() === Relation::HAS_MANY) {
                    foreach ($propertyValue as $containedObject) {
                        $this->‪removeEntity($containedObject);
                    }
                } elseif ($propertyValue instanceof DomainObjectInterface) {
                    $this->‪removeEntity($propertyValue);
                }
            } elseif ($dataMap->getDeletedFlagColumnName() === null
                && $columnMap->getTypeOfRelation() === Relation::HAS_AND_BELONGS_TO_MANY
            ) {
                $this->‪deleteAllRelationsFromRelationtable($object, $propertyName);
            }
        }
    }
 
    protected function ‪determineStoragePageIdForNewRecord(‪DomainObjectInterface $object = null)
    {
        $frameworkConfiguration = $this->configurationManager->getConfiguration(‪ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
        if ($object !== null) {
            if (‪ObjectAccess::isPropertyGettable($object, ‪AbstractDomainObject::PROPERTY_PID)) {
                $pid = ‪ObjectAccess::getProperty($object, ‪AbstractDomainObject::PROPERTY_PID);
                if (isset($pid)) {
                    return (int)$pid;
                }
            }
            $className = get_class($object);
            // todo: decide what to do with this option.
            if (isset($frameworkConfiguration['persistence']['classes'][$className]) && !empty($frameworkConfiguration['persistence']['classes'][$className]['newRecordStoragePid'])) {
                return (int)$frameworkConfiguration['persistence']['classes'][$className]['newRecordStoragePid'];
            }
        }
        $storagePidList = ‪GeneralUtility::intExplode(',', (string)($frameworkConfiguration['persistence']['storagePid'] ?? ''));
        return $storagePidList[0];
    }
 
    protected function ‪getPlainValue($input, ‪ColumnMap $columnMap = null)
    {
        return $input !== null
            ? GeneralUtility::makeInstance(DataMapper::class)->getPlainValue($input, $columnMap)
            : null;
    }
}