result.php

<?php
namespace Bitrix\Main\ORM\Query;
 
use Bitrix\Main\ArgumentException;
use Bitrix\Main\DB\ArrayResult;
use \Bitrix\Main\DB\Result as BaseResult;
use Bitrix\Main\ORM\Fields\ExpressionField;
use Bitrix\Main\ORM\Entity;
use Bitrix\Main\ORM\Fields\Field;
use Bitrix\Main\ORM\Fields\IReadable;
use Bitrix\Main\ORM\Fields\Relations\ManyToMany;
use Bitrix\Main\ORM\Fields\Relations\OneToMany;
use Bitrix\Main\ORM\Objectify\Collection;
use Bitrix\Main\ORM\Objectify\IdentityMap;
use Bitrix\Main\ORM\Objectify\State;
use Bitrix\Main\ORM\Objectify\EntityObject;
use Bitrix\Main\ORM\Fields\Relations\Reference;
use Bitrix\Main\ORM\Fields\ScalarField;
use Bitrix\Main\SystemException;
 
class Result extends BaseResult
{
    protected $result;
 
    protected $query;
 
    protected $selectChainsMap = [];
 
    protected $objectClass;
 
    protected $identityMap;
 
    protected $objectInitPassed = false;
 
    protected $primaryAliases = [];
 
    protected $hiddenObjectFields;
 
    public function __construct(Query $query, BaseResult $result)
    {
        $this->query = $query;
        $this->result = $result;
    }
 
    public function setHiddenObjectFields($hiddenObjectFields)
    {
        $this->hiddenObjectFields = $hiddenObjectFields;
    }
 
    protected function hideObjectFields(&$row)
    {
        foreach ($this->hiddenObjectFields as $fieldName)
        {
            unset($row[$fieldName]);
        }
 
        return $row;
    }
 
    public function getFields()
    {
        return $this->result->getFields();
    }
 
    public function getSelectedRowsCount()
    {
        return $this->result->getSelectedRowsCount();
    }
 
    protected function fetchRowInternal()
    {
        return $this->result->fetchRowInternal();
    }
 
    final public function fetchObject()
    {
        // TODO when join, add primary and hide it in ARRAY result, but use for OBJECT fetch
        // e.g. when first fetchObject, remove data modifier that cuts 'unexpected' primary fields
 
        // TODO wakeup reference objects with only primary if there are enough data in result
 
        // base object initialization
        $this->initializeFetchObject();
 
        // array data
        $row = $this->result->fetch();
 
        if (empty($row))
        {
            return null;
        }
 
        if (is_object($row) && $row instanceof EntityObject)
        {
            // all rows has already been fetched in initializeFetchObject
            return $row;
        }
 
        // get primary of base object
        $basePrimaryValues = [];
 
        foreach ($this->primaryAliases as $primaryName => $primaryAlias)
        {
            $primaryField = $this->query->getEntity()->getField($primaryName);
            $primaryValue = $primaryField->cast($row[$primaryAlias]);
 
            $basePrimaryValues[$primaryName] = $primaryValue;
        }
 
        // check for object in identity map
        $baseAddToIM = false;
        $objectClass = $this->objectClass;
 
        $object = $this->identityMap->get($objectClass, $basePrimaryValues);
 
        if (empty($object))
        {
            $object = new $objectClass(false);
 
            // set right state
            $object->sysChangeState(State::ACTUAL);
 
            // add to identityMap later, when primary is set
            $baseAddToIM = true;
        }
 
        $relEntityCache = [];
 
        // go through select chains
        foreach ($this->query->getSelectChains() as $selectChain)
        {
            // object for current chain element, for the first element is object of init entity
            $currentObject = $object;
 
            // accumulated definition from the first to the current chain element
            $currentDefinitionParts = [];
            $currentDefinition = null;
 
            // cut first element as long as it is init entity
            $iterableElements = array_slice($selectChain->getAllElements(), 1);
 
            // dive deep from the start to the end of chain
            foreach ($iterableElements as $element)
            {
                if ($currentObject === null)
                {
                    continue;
                }
 
                $field = $element->getValue();
 
                if (!($field instanceof Field))
                {
                    // ignore old-style back references, OneToMany is expected instead
                    // skip for the next chain
                    continue 2;
                }
 
                // actualize current definition
                $currentDefinitionParts[] = $field->getName();
                $currentDefinition = join('.', $currentDefinitionParts);
 
                // is it runtime field? then ->tmpSet()
                $isRuntimeField = !empty($this->query->getRuntimeChains()[$currentDefinition]);
 
                if ($field instanceof IReadable)
                {
                    // for remote objects all values have been already set during compose
                    if ($currentObject !== $object)
                    {
                        continue;
                    }
 
                    // normalize value
                    $value = $field->cast($row[$selectChain->getAlias()]);
 
                    // set value as actual to the object
                    $isRuntimeField
                        ? $currentObject->sysSetRuntime($field->getName(), $value)
                        : $currentObject->sysSetActual($field->getName(), $value);
                }
                else
                {
                    // define remote entity definition
                    // check if this reference has already been woken up
                    // main part of current chain (w/o last element) should be the same
                    if (array_key_exists($currentDefinition, $relEntityCache))
                    {
                        $currentObject = $relEntityCache[$currentDefinition];
                        continue;
                    } // else it will be set after object identification
 
                    // define remote entity of reference
                    $remoteEntity = $field->getRefEntity();
 
                    // define values and primary of remote object
                    // we can set all values at one time and skip other iterations with values of this object
                    $remotePrimary = $remoteEntity->getPrimaryArray();
                    $remoteObjectValues = [];
                    $remotePrimaryValues = [];
 
                    foreach ($this->selectChainsMap[$currentDefinition] as $remoteChain)
                    {
                        $remoteField = $remoteChain->getLastElement()->getValue();
                        $remoteValue = $row[$remoteChain->getAlias()];
 
                        $remoteObjectValues[$remoteField->getName()] = $remoteValue;
                    }
 
                    foreach ($remotePrimary as $primaryName)
                    {
                        if (!array_key_exists($primaryName, $remoteObjectValues))
                        {
                            throw new SystemException(sprintf(
                                'Primary of %s was not found in database result', $remoteEntity->getDataClass()
                            ));
                        }
 
                        $remotePrimaryValues[$primaryName] = $remoteObjectValues[$primaryName];
                    }
 
                    // compose relative object
                    if ($field instanceof Reference)
                    {
                        // get object via identity map
                        $remoteObject = $this->composeRemoteObject($remoteEntity, $remotePrimaryValues, $remoteObjectValues);
 
                        // set remoteObject to baseObject
                        $isRuntimeField
                            ? $currentObject->sysSetRuntime($field->getName(), $remoteObject)
                            : $currentObject->sysSetActual($field->getName(), $remoteObject);
                    }
                    elseif ($field instanceof OneToMany || $field instanceof ManyToMany)
                    {
                        // get collection of remote objects
                        if ($isRuntimeField)
                        {
                            if (empty($currentObject->sysGetRuntime($field->getName())))
                            {
                                // create new collection and set as value for current object
                                $collection = $remoteEntity->createCollection();
                                $currentObject->sysSetRuntime($field->getName(), $collection);
                            }
                            else
                            {
                                $collection = $currentObject->sysGetRuntime($field->getName());
                            }
                        }
                        else
                        {
                            if (empty($currentObject->sysGetValue($field->getName())))
                            {
                                // create new collection and set as value for current object
                                $collection = $remoteEntity->createCollection();
 
                                // collection should be filled if there are no LIMIT and relation filter in query
                                if ($this->query->getLimit() === null)
                                {
                                    // noting in filter should start with $currentDefinition
                                    $noRelationInFilter = true;
 
                                    foreach ($this->query->getFilterChains() as $chain)
                                    {
                                        if (strpos($chain->getDefinition(), $currentDefinition) === 0)
                                        {
                                            $noRelationInFilter = false;
                                            break;
                                        }
                                    }
 
                                    if ($noRelationInFilter)
                                    {
                                        // now we are sure the set is complete
                                        $collection->sysSetFilled();
                                    }
                                }
 
                                $currentObject->sysSetActual($field->getName(), $collection);
                            }
                            else
                            {
                                $collection = $currentObject->sysGetValue($field->getName());
                            }
                        }
 
                        // define remote object
                        if (current($remotePrimaryValues) === null || !$collection->hasByPrimary($remotePrimaryValues))
                        {
                            // get object via identity map
                            $remoteObject = $this->composeRemoteObject($remoteEntity, $remotePrimaryValues, $remoteObjectValues);
 
                            // add to collection
                            if ($remoteObject !== null)
                            {
                                $collection->sysAddActual($remoteObject);
                            }
                        }
                        else
                        {
                            $remoteObject = $collection->getByPrimary($remotePrimaryValues);
                        }
                    }
                    else
                    {
                        throw new SystemException('Unknown chain element value while fetching object');
                    }
 
                    // switch current object, further chain elements belong to this object
                    $currentObject = $remoteObject;
 
                    // save as ready object for current row
                    $relEntityCache[$currentDefinition] = $remoteObject;
                }
            }
        }
 
        if ($baseAddToIM)
        {
            // save to identityMap
            $this->identityMap->put($object);
        }
 
        return $object;
    }
 
    final public function fetchCollection()
    {
        // base object initialization
        $this->initializeFetchObject(true);
 
        $collection = $this->query->getEntity()->createCollection();
 
        while ($object = $this->fetchObject())
        {
            $collection->sysAddActual($object);
        }
 
        return $collection;
    }
 
    protected function initializeFetchObject($asCollection = false)
    {
        if (empty($this->objectInitPassed))
        {
            // validate query
            if (!empty($this->query->getGroupChains()))
            {
                throw new SystemException(
                    'Result of query with aggregation could not be fetched as an object'
                );
            }
 
            // initialize
            if (empty($this->identityMap))
            {
                // identity map could have been set before first fetch
                $this->identityMap = new IdentityMap;
            }
 
            $this->objectClass = $this->query->getEntity()->getObjectClass();
 
            $this->buildSelectChainsMap();
            $this->definePrimaryAliases();
 
            // values will be cast anyway based on original fields, not just associated with column types
            //$this->setStrictValueConverters();
 
            $this->objectInitPassed = true;
 
            // if there are back references, fetch everything and make virtual ArrayResult
            if (!$asCollection && $this->query->hasBackReference())
            {
                $collection = $this->fetchCollection();
 
                // remember original result
                $originalResult = $this->result;
 
                $this->result = new ArrayResult($collection->getAll());
 
                // recover count total
                try
                {
                    if ($originalResult->getCount())
                    {
                        $this->result->setCount($originalResult->getCount());
                    }
                }
                catch (\Bitrix\Main\ObjectPropertyException $e) {}
            }
        }
    }
 
    protected function buildSelectChainsMap()
    {
        foreach ($this->query->getSelectChains() as $selectChain)
        {
            $this->selectChainsMap[$selectChain->getDefinition(-1)][] = $selectChain;
        }
    }
 
    protected function definePrimaryAliases()
    {
        $primaryNames = $this->query->getEntity()->getPrimaryArray();
 
        foreach ($this->query->getSelectChains() as $selectChain)
        {
            $field = $selectChain->getLastElement()->getValue();
 
            // get 0-level simple fields: entity + field
            if ($field->getEntity()->getDataClass() === $this->query->getEntity()->getDataClass()
                && in_array($field->getName(), $primaryNames))
            {
                $this->primaryAliases[$field->getName()] = $selectChain->getAlias();
 
                if (count($this->primaryAliases) == count($primaryNames))
                {
                    break;
                }
            }
        }
 
        if (count($this->primaryAliases) != count($primaryNames))
        {
            throw new SystemException(sprintf(
                'Primary of %s was not found in database result', $this->query->getEntity()->getDataClass()
            ));
        }
    }
 
    protected function setStrictValueConverters()
    {
        foreach ($this->query->getSelectChains() as $selectChain)
        {
            $alias = $selectChain->getAlias();
 
            if (!isset($this->result->converters[$alias]))
            {
                $this->result->converters[$alias] = [
                    $this->result->getFields()[$alias],
                    'convertValueFromDb'
                ];
            }
        }
    }
 
    protected function composeRemoteObject($entity, $primaryValues, $objectValues)
    {
        // if null primary then return null
        if (current($primaryValues) === null)
        {
            return null;
        }
 
        // try to get remote object from identity map
        $objectClass = $entity->getObjectClass();
        $remoteObject = $this->identityMap->get($objectClass, $primaryValues);
 
        // do we have a new object to add to identity map
        $addToIM = false;
 
        if (empty($remoteObject))
        {
            // define new object
            $remoteObject = new $objectClass(false);
 
            // set right state
            $remoteObject->sysChangeState(State::ACTUAL);
 
            // add to identityMap later, when primary is set
            $addToIM = true;
        }
 
        // set all values of remote object
        foreach ($objectValues as $fieldName => $objectValue)
        {
            $field = $entity->getField($fieldName);
            $castValue = $field->cast($objectValue);
 
            $remoteObject->sysSetActual($fieldName, $castValue);
        }
 
        // save to identityMap
        if ($addToIM)
        {
            $this->identityMap->put($remoteObject);
        }
 
        return $remoteObject;
    }
 
    public function setIdentityMap(IdentityMap $map)
    {
        $this->identityMap = $map;
 
        return $this;
    }
 
    public function getIdentityMap()
    {
        return $this->identityMap;
    }
 
    // decorate other methods
    public function getResource()
    {
        return $this->result->getResource();
    }
 
    public function setReplacedAliases(array $replacedAliases)
    {
        $this->result->setReplacedAliases($replacedAliases);
    }
 
    public function addReplacedAliases(array $replacedAliases)
    {
        $this->result->addReplacedAliases($replacedAliases);
    }
 
    public function setSerializedFields(array $serializedFields)
    {
        $this->result->setSerializedFields($serializedFields);
    }
 
    public function addFetchDataModifier($fetchDataModifier)
    {
        $this->result->addFetchDataModifier($fetchDataModifier);
    }
 
    public function fetchRaw()
    {
        return $this->result->fetchRaw();
    }
 
    public function fetch(\Bitrix\Main\Text\Converter $converter = null)
    {
        $row = $this->result->fetch($converter);
 
        if ($row && !empty($this->hiddenObjectFields))
        {
            return $this->hideObjectFields($row);
        }
 
        return $row;
    }
 
    public function fetchAll(\Bitrix\Main\Text\Converter $converter = null)
    {
        if (empty($this->hiddenObjectFields))
        {
            return $this->result->fetchAll($converter);
        }
        else
        {
            $data = $this->result->fetchAll($converter);
 
            foreach ($data as &$row)
            {
                $this->hideObjectFields($row);
            }
 
            return $data;
        }
 
    }
 
    public function getTrackerQuery()
    {
        return $this->result->getTrackerQuery();
    }
 
    public function getConverters()
    {
        return $this->result->getConverters();
    }
 
    public function setConverters($converters)
    {
        $this->result->setConverters($converters);
    }
 
    public function setCount($n)
    {
        $this->result->setCount($n);
    }
 
    public function getCount()
    {
        return $this->result->getCount();
    }
 
    public function getIterator(): \Traversable
    {
        return $this->result->getIterator();
    }
 
}