src/Core/Framework/DataAbstractionLayer/Dbal/EntityDefinitionQueryHelper.php line 50

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer\Dbal;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Defaults;
  7. use Shopware\Core\Framework\Context;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\Exception\FieldAccessorBuilderNotFoundException;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\Exception\UnmappedFieldException;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\FieldResolver\FieldResolverContext;
  11. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Field\AssociationField;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Field\Field;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Field\FkField;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Inherited;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\PrimaryKey;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Field\IdField;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToManyAssociationField;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Field\ReferenceVersionField;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Field\StorageAware;
  21. use Shopware\Core\Framework\DataAbstractionLayer\Field\TranslatedField;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Field\VersionField;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  24. use Shopware\Core\Framework\DataAbstractionLayer\Search\CriteriaPartInterface;
  25. use Shopware\Core\Framework\Log\Package;
  26. use Shopware\Core\Framework\Uuid\Uuid;
  28. /**
  29.  * This class acts only as helper/common class for all dbal operations for entity definitions.
  30.  * It knows how an association should be joined, how a parent-child inheritance should act, how translation chains work, ...
  31.  *
  32.  * @internal
  33.  */
  34. #[Package('core')]
  35. class EntityDefinitionQueryHelper
  36. {
  37.     final public const HAS_TO_MANY_JOIN = 'has_to_many_join';
  39.     public static function escape(string $string): string
  40.     {
  41.         if (mb_strpos($string, '`') !== false) {
  42.             throw new \InvalidArgumentException('Backtick not allowed in identifier');
  43.         }
  45.         return '`' . $string . '`';
  46.     }
  48.     public static function columnExists(Connection $connection, string $table, string $column): bool
  49.     {
  50.         $exists = $connection->fetchOne(
  51.             'SHOW COLUMNS FROM ' . self::escape($table) . ' WHERE `Field` LIKE :column',
  52.             ['column' => $column]
  53.         );
  55.         return !empty($exists);
  56.     }
  58.     public static function tableExists(Connection $connection, string $table): bool
  59.     {
  60.         return !empty(
  61.             $connection->fetchOne(
  62.                 'SHOW TABLES LIKE :table',
  63.                 [
  64.                     'table' => $table,
  65.                 ]
  66.             )
  67.         );
  68.     }
  70.     /**
  71.      * @return list<Field>
  72.      */
  73.     public static function getFieldsOfAccessor(EntityDefinition $definition, string $accessor, bool $resolveTranslated = true): array
  74.     {
  75.         $parts = explode('.', $accessor);
  76.         if ($definition->getEntityName() === $parts[0]) {
  77.             array_shift($parts);
  78.         }
  80.         $accessorFields = [];
  82.         $source = $definition;
  84.         foreach ($parts as $part) {
  85.             if ($part === 'extensions') {
  86.                 continue;
  87.             }
  89.             $fields = $source->getFields();
  90.             $field = $fields->get($part);
  92.             // continue if the current part is not a real field to allow access on collections
  93.             if (!$field) {
  94.                 continue;
  95.             }
  97.             if ($field instanceof TranslatedField && $resolveTranslated) {
  98.                 /** @var EntityDefinition $source */
  99.                 $source = $source->getTranslationDefinition();
  100.                 $fields = $source->getFields();
  101.                 $accessorFields[] = $fields->get($part);
  103.                 continue;
  104.             }
  106.             if ($field instanceof TranslatedField && !$resolveTranslated) {
  107.                 $accessorFields[] = $field;
  109.                 continue;
  110.             }
  112.             $accessorFields[] = $field;
  114.             if (!$field instanceof AssociationField) {
  115.                 break;
  116.             }
  118.             $source = $field->getReferenceDefinition();
  119.             if ($field instanceof ManyToManyAssociationField) {
  120.                 $source = $field->getToManyReferenceDefinition();
  121.             }
  122.         }
  124.         return \array_values(\array_filter($accessorFields));
  125.     }
  127.     /**
  128.      * Returns the field instance of the provided fieldName.
  129.      *
  130.      * @example
  131.      *
  132.      * fieldName => 'product.name'
  133.      * Returns the (new TranslatedField('name')) declaration
  134.      *
  135.      * Allows additionally nested referencing
  136.      *
  137.      * fieldName => 'category.products.name'
  138.      * Returns as well the above field definition
  139.      */
  140.     public function getField(string $fieldName, EntityDefinition $definition, string $root, bool $resolveTranslated = true): ?Field
  141.     {
  142.         $original = $fieldName;
  143.         $prefix = $root . '.';
  145.         if (mb_strpos($fieldName, $prefix) === 0) {
  146.             $fieldName = mb_substr($fieldName, mb_strlen($prefix));
  147.         } else {
  148.             $original = $prefix . $original;
  149.         }
  151.         $fields = $definition->getFields();
  153.         $isAssociation = mb_strpos($fieldName, '.') !== false;
  155.         if (!$isAssociation && $fields->has($fieldName)) {
  156.             return $fields->get($fieldName);
  157.         }
  158.         $associationKey = explode('.', $fieldName);
  159.         $associationKey = array_shift($associationKey);
  161.         $field = $fields->get($associationKey);
  163.         if ($field instanceof TranslatedField && $resolveTranslated) {
  164.             return self::getTranslatedField($definition, $field);
  165.         }
  166.         if ($field instanceof TranslatedField) {
  167.             return $field;
  168.         }
  170.         if (!$field instanceof AssociationField) {
  171.             return $field;
  172.         }
  174.         $referenceDefinition = $field->getReferenceDefinition();
  175.         if ($field instanceof ManyToManyAssociationField) {
  176.             $referenceDefinition = $field->getToManyReferenceDefinition();
  177.         }
  179.         return $this->getField(
  180.             $original,
  181.             $referenceDefinition,
  182.             $root . '.' . $field->getPropertyName()
  183.         );
  184.     }
  186.     /**
  187.      * Builds the sql field accessor for the provided field.
  188.      *
  189.      * @example
  190.      *
  191.      * fieldName => product.taxId
  192.      * root      => product
  193.      * returns   => `product`.`tax_id`
  194.      *
  195.      * This function is also used for complex field accessors like JsonArray Field, JsonObject fields.
  196.      * It considers the translation and parent-child inheritance.
  197.      *
  198.      * fieldName => product.name
  199.      * root      => product
  200.      * return    => COALESCE(`product.translation`.`name`,`product.parent.translation`.`name`)
  201.      *
  202.      * @throws UnmappedFieldException
  203.      */
  204.     public function getFieldAccessor(string $fieldName, EntityDefinition $definition, string $root, Context $context): string
  205.     {
  206.         $fieldName = str_replace('extensions.', '', $fieldName);
  208.         $original = $fieldName;
  209.         $prefix = $root . '.';
  211.         if (str_starts_with($fieldName, $prefix)) {
  212.             $fieldName = mb_substr($fieldName, mb_strlen($prefix));
  213.         } else {
  214.             $original = $prefix . $original;
  215.         }
  217.         $fields = $definition->getFields();
  218.         if ($fields->has($fieldName)) {
  219.             $field = $fields->get($fieldName);
  221.             return $this->buildInheritedAccessor($field, $root, $definition, $context, $fieldName);
  222.         }
  224.         $parts = explode('.', $fieldName);
  225.         $associationKey = array_shift($parts);
  227.         if ($associationKey === 'extensions') {
  228.             $associationKey = array_shift($parts);
  229.         }
  231.         if (!\is_string($associationKey) || !$fields->has($associationKey)) {
  232.             throw new UnmappedFieldException($original, $definition);
  233.         }
  235.         $field = $fields->get($associationKey);
  237.         //case for json object fields, other fields has now same option to act with more point notations but hasn't to be an association field. E.g. price.gross
  238.         if (!$field instanceof AssociationField && ($field instanceof StorageAware || $field instanceof TranslatedField)) {
  239.             return $this->buildInheritedAccessor($field, $root, $definition, $context, $fieldName);
  240.         }
  242.         if (!$field instanceof AssociationField) {
  243.             throw new \RuntimeException(sprintf('Expected field "%s" to be instance of %s', $associationKey, AssociationField::class));
  244.         }
  246.         $referenceDefinition = $field->getReferenceDefinition();
  247.         if ($field instanceof ManyToManyAssociationField) {
  248.             $referenceDefinition = $field->getToManyReferenceDefinition();
  249.         }
  251.         return $this->getFieldAccessor(
  252.             $original,
  253.             $referenceDefinition,
  254.             $root . '.' . $field->getPropertyName(),
  255.             $context
  256.         );
  257.     }
  259.     public static function getAssociationPath(string $accessor, EntityDefinition $definition): ?string
  260.     {
  261.         $fields = self::getFieldsOfAccessor($definition, $accessor);
  263.         $path = [];
  264.         foreach ($fields as $field) {
  265.             if (!$field instanceof AssociationField) {
  266.                 break;
  267.             }
  268.             $path[] = $field->getPropertyName();
  269.         }
  271.         if (empty($path)) {
  272.             return null;
  273.         }
  275.         return implode('.', $path);
  276.     }
  278.     /**
  279.      * Creates the basic root query for the provided entity definition and application context.
  280.      * It considers the current context version.
  281.      */
  282.     public function getBaseQuery(QueryBuilder $query, EntityDefinition $definition, Context $context): QueryBuilder
  283.     {
  284.         $table = $definition->getEntityName();
  286.         $query->from(self::escape($table));
  288.         $useVersionFallback // only applies for versioned entities
  289.             = $definition->isVersionAware()
  290.             // only add live fallback if the current version isn't the live version
  291.             && $context->getVersionId() !== Defaults::LIVE_VERSION
  292.             // sub entities have no live fallback
  293.             && $definition->getParentDefinition() === null;
  295.         if ($useVersionFallback) {
  296.             $this->joinVersion($query, $definition, $definition->getEntityName(), $context);
  297.         } elseif ($definition->isVersionAware()) {
  298.             $versionIdField = array_filter(
  299.                 $definition->getPrimaryKeys()->getElements(),
  300.                 fn ($f) => $f instanceof VersionField || $f instanceof ReferenceVersionField
  301.             );
  303.             if (!$versionIdField) {
  304.                 throw new \RuntimeException('Missing `VersionField` in `' . $definition->getClass() . '`');
  305.             }
  307.             /** @var FkField $versionIdField */
  308.             $versionIdField = array_shift($versionIdField);
  310.             $query->andWhere(self::escape($table) . '.' . self::escape($versionIdField->getStorageName()) . ' = :version');
  311.             $query->setParameter('version', Uuid::fromHexToBytes($context->getVersionId()));
  312.         }
  314.         return $query;
  315.     }
  317.     /**
  318.      * Used for dynamic sql joins. In case that the given fieldName is unknown or event nested with multiple association
  319.      * roots, the function can resolve each association part of the field name, even if one part of the fieldName contains a translation or event inherited data field.
  320.      */
  321.     public function resolveAccessor(
  322.         string $accessor,
  323.         EntityDefinition $definition,
  324.         string $root,
  325.         QueryBuilder $query,
  326.         Context $context,
  327.         ?CriteriaPartInterface $criteriaPart = null
  328.     ): void {
  329.         $accessor = str_replace('extensions.', '', $accessor);
  331.         $parts = explode('.', $accessor);
  333.         if ($parts[0] === $root) {
  334.             unset($parts[0]);
  335.         }
  337.         $alias = $root;
  339.         $path = [$root];
  341.         $rootDefinition = $definition;
  343.         foreach ($parts as $part) {
  344.             $field = $definition->getFields()->get($part);
  346.             if ($field === null) {
  347.                 return;
  348.             }
  350.             $resolver = $field->getResolver();
  351.             if ($resolver === null) {
  352.                 continue;
  353.             }
  355.             if ($field instanceof AssociationField) {
  356.                 $path[] = $field->getPropertyName();
  357.             }
  359.             $currentPath = implode('.', $path);
  360.             $resolverContext = new FieldResolverContext($currentPath, $alias, $field, $definition, $rootDefinition, $query, $context, $criteriaPart);
  362.             $alias = $this->callResolver($resolverContext);
  364.             if (!$field instanceof AssociationField) {
  365.                 return;
  366.             }
  368.             $definition = $field->getReferenceDefinition();
  369.             if ($field instanceof ManyToManyAssociationField) {
  370.                 $definition = $field->getToManyReferenceDefinition();
  371.             }
  373.             if ($definition->isInheritanceAware() && $context->considerInheritance() && $parent = $definition->getField('parent')) {
  374.                 $resolverContext = new FieldResolverContext($currentPath, $alias, $parent, $definition, $rootDefinition, $query, $context, $criteriaPart);
  376.                 $this->callResolver($resolverContext);
  377.             }
  378.         }
  379.     }
  381.     public function resolveField(Field $field, EntityDefinition $definition, string $root, QueryBuilder $query, Context $context): void
  382.     {
  383.         $resolver = $field->getResolver();
  385.         if ($resolver === null) {
  386.             return;
  387.         }
  389.         $resolver->join(new FieldResolverContext($root, $root, $field, $definition, $definition, $query, $context, null));
  390.     }
  392.     /**
  393.      * Adds the full translation select part to the provided sql query.
  394.      * Considers the parent-child inheritance and provided context language inheritance.
  395.      * The raw parameter allows to skip the parent-child inheritance.
  396.      *
  397.      * @param array<string, mixed> $partial
  398.      */
  399.     public function addTranslationSelect(string $root, EntityDefinition $definition, QueryBuilder $query, Context $context, array $partial = []): void
  400.     {
  401.         $translationDefinition = $definition->getTranslationDefinition();
  403.         if (!$translationDefinition) {
  404.             return;
  405.         }
  407.         $fields = $translationDefinition->getFields();
  408.         if (!empty($partial)) {
  409.             $fields = $translationDefinition->getFields()->filter(fn (Field $field) => $field->is(PrimaryKey::class)
  410.                 || isset($partial[$field->getPropertyName()])
  411.                 || $field instanceof FkField);
  412.         }
  414.         $inherited = $context->considerInheritance() && $definition->isInheritanceAware();
  416.         $chain = EntityDefinitionQueryHelper::buildTranslationChain($root, $context, $inherited);
  418.         /** @var TranslatedField $field */
  419.         foreach ($fields as $field) {
  420.             if (!$field instanceof StorageAware) {
  421.                 continue;
  422.             }
  424.             $selects = [];
  425.             foreach ($chain as $select) {
  426.                 $vars = [
  427.                     '#root#' => $select,
  428.                     '#field#' => $field->getPropertyName(),
  429.                 ];
  431.                 $query->addSelect(str_replace(
  432.                     array_keys($vars),
  433.                     array_values($vars),
  434.                     EntityDefinitionQueryHelper::escape('#root#.#field#')
  435.                 ));
  437.                 $selects[] = str_replace(
  438.                     array_keys($vars),
  439.                     array_values($vars),
  440.                     self::escape('#root#.#field#')
  441.                 );
  442.             }
  444.             //check if current field is a translated field of the origin definition
  445.             $origin = $definition->getFields()->get($field->getPropertyName());
  446.             if (!$origin instanceof TranslatedField) {
  447.                 continue;
  448.             }
  450.             $selects[] = self::escape($root . '.translation.' . $field->getPropertyName());
  452.             //add selection for resolved parent-child and language inheritance
  453.             $query->addSelect(
  454.                 sprintf('COALESCE(%s)', implode(',', $selects)) . ' as '
  455.                 . self::escape($root . '.' . $field->getPropertyName())
  456.             );
  457.         }
  458.     }
  460.     public function joinVersion(QueryBuilder $query, EntityDefinition $definition, string $root, Context $context): void
  461.     {
  462.         $table = $definition->getEntityName();
  463.         $versionRoot = $root . '_version';
  465.         $query->andWhere(
  466.             str_replace(
  467.                 ['#root#', '#table#', '#version#'],
  468.                 [self::escape($root), self::escape($table), self::escape($versionRoot)],
  469.                 '#root#.version_id = COALESCE(
  470.                     (SELECT DISTINCT version_id FROM #table# AS #version# WHERE #version#.`id` = #root#.`id` AND `version_id` = :version),
  471.                     :liveVersion
  472.                 )'
  473.             )
  474.         );
  476.         $query->setParameter('liveVersion', Uuid::fromHexToBytes(Defaults::LIVE_VERSION));
  477.         $query->setParameter('version', Uuid::fromHexToBytes($context->getVersionId()));
  478.     }
  480.     public static function getTranslatedField(EntityDefinition $definition, TranslatedField $translatedField): Field
  481.     {
  482.         $translationDefinition = $definition->getTranslationDefinition();
  484.         if ($translationDefinition === null) {
  485.             throw new \RuntimeException(sprintf('Entity %s has no translation definition', $definition->getEntityName()));
  486.         }
  488.         $field = $translationDefinition->getFields()->get($translatedField->getPropertyName());
  490.         if ($field === null || !$field instanceof StorageAware || !$field instanceof Field) {
  491.             throw new \RuntimeException(
  492.                 sprintf(
  493.                     'Missing translated storage aware property %s in %s',
  494.                     $translatedField->getPropertyName(),
  495.                     $translationDefinition->getEntityName()
  496.                 )
  497.             );
  498.         }
  500.         return $field;
  501.     }
  503.     /**
  504.      * @return list<string>
  505.      */
  506.     public static function buildTranslationChain(string $root, Context $context, bool $includeParent): array
  507.     {
  508.         $chain = [];
  509.         $count = \count($context->getLanguageIdChain()) - 1;
  511.         for ($i = $count; $i >= 1; --$i) {
  512.             $chain[] = $root . '.translation.fallback_' . $i;
  513.             if ($includeParent) {
  514.                 $chain[] = $root . '.parent.translation.fallback_' . $i;
  515.             }
  516.         }
  518.         $chain[] = $root . '.translation';
  519.         if ($includeParent) {
  520.             $chain[] = $root . '.parent.translation';
  521.         }
  523.         return $chain;
  524.     }
  526.     public function addIdCondition(Criteria $criteria, EntityDefinition $definition, QueryBuilder $query): void
  527.     {
  528.         $primaryKeys = $criteria->getIds();
  530.         $primaryKeys = array_values($primaryKeys);
  532.         if (empty($primaryKeys)) {
  533.             return;
  534.         }
  536.         if (!\is_array($primaryKeys[0]) || \count($primaryKeys[0]) === 1) {
  537.             $primaryKeyField = $definition->getPrimaryKeys()->first();
  538.             if ($primaryKeyField instanceof IdField || $primaryKeyField instanceof FkField) {
  539.                 $primaryKeys = array_map(function ($id) {
  540.                     if (\is_array($id)) {
  541.                         /** @var string $shiftedId */
  542.                         $shiftedId = array_shift($id);
  544.                         return Uuid::fromHexToBytes($shiftedId);
  545.                     }
  547.                     return Uuid::fromHexToBytes($id);
  548.                 }, $primaryKeys);
  549.             }
  551.             if (!$primaryKeyField instanceof StorageAware) {
  552.                 throw new \RuntimeException('Primary key fields has to be an instance of StorageAware');
  553.             }
  555.             $query->andWhere(sprintf(
  556.                 '%s.%s IN (:ids)',
  557.                 EntityDefinitionQueryHelper::escape($definition->getEntityName()),
  558.                 EntityDefinitionQueryHelper::escape($primaryKeyField->getStorageName())
  559.             ));
  561.             $query->setParameter('ids', $primaryKeys, Connection::PARAM_STR_ARRAY);
  563.             return;
  564.         }
  566.         $this->addIdConditionWithOr($criteria, $definition, $query);
  567.     }
  569.     private function callResolver(FieldResolverContext $context): string
  570.     {
  571.         $resolver = $context->getField()->getResolver();
  573.         if (!$resolver) {
  574.             return $context->getAlias();
  575.         }
  577.         return $resolver->join($context);
  578.     }
  580.     private function addIdConditionWithOr(Criteria $criteria, EntityDefinition $definition, QueryBuilder $query): void
  581.     {
  582.         $wheres = [];
  584.         foreach ($criteria->getIds() as $primaryKey) {
  585.             if (!\is_array($primaryKey)) {
  586.                 $primaryKey = ['id' => $primaryKey];
  587.             }
  589.             $where = [];
  591.             foreach ($primaryKey as $propertyName => $value) {
  592.                 $field = $definition->getFields()->get($propertyName);
  594.                 if (!$field) {
  595.                     throw new UnmappedFieldException($propertyName, $definition);
  596.                 }
  598.                 if (!$field instanceof StorageAware) {
  599.                     throw new \RuntimeException('Only storage aware fields are supported in read condition');
  600.                 }
  602.                 if ($field instanceof IdField || $field instanceof FkField) {
  603.                     $value = Uuid::fromHexToBytes($value);
  604.                 }
  606.                 $key = 'pk' . Uuid::randomHex();
  608.                 $accessor = EntityDefinitionQueryHelper::escape($definition->getEntityName()) . '.' . EntityDefinitionQueryHelper::escape($field->getStorageName());
  610.                 $where[$accessor] = $accessor . ' = :' . $key;
  612.                 $query->setParameter($key, $value);
  613.             }
  615.             $wheres[] = '(' . implode(' AND ', $where) . ')';
  616.         }
  618.         $wheres = implode(' OR ', $wheres);
  620.         $query->andWhere($wheres);
  621.     }
  623.     /**
  624.      * @param list<string> $chain
  625.      */
  626.     private function getTranslationFieldAccessor(Field $field, string $accessor, array $chain, Context $context): string
  627.     {
  628.         if (!$field instanceof StorageAware) {
  629.             throw new \RuntimeException('Only storage aware fields are supported as translated field');
  630.         }
  632.         $selects = [];
  633.         foreach ($chain as $part) {
  634.             $select = $this->buildFieldSelector($part, $field, $context, $accessor);
  636.             $selects[] = str_replace(
  637.                 '`.' . self::escape($field->getStorageName()),
  638.                 '.' . $field->getPropertyName() . '`',
  639.                 $select
  640.             );
  641.         }
  643.         /*
  644.          * Simplified Example:
  645.          * COALESCE(
  646.              JSON_UNQUOTE(JSON_EXTRACT(`tbl.translation.fallback_2`.`translated_attributes`, '$.path')) AS datetime(3), # child language
  647.              JSON_UNQUOTE(JSON_EXTRACT(`tbl.translation.fallback_1`.`translated_attributes`, '$.path')) AS datetime(3), # root language
  648.              JSON_UNQUOTE(JSON_EXTRACT(`tbl.translation`.`translated_attributes`, '$.path')) AS datetime(3) # system language
  649.            );
  650.          */
  651.         return sprintf('COALESCE(%s)', implode(',', $selects));
  652.     }
  654.     private function buildInheritedAccessor(
  655.         Field $field,
  656.         string $root,
  657.         EntityDefinition $definition,
  658.         Context $context,
  659.         string $original
  660.     ): string {
  661.         if ($field instanceof TranslatedField) {
  662.             $inheritedChain = self::buildTranslationChain($root, $context, $definition->isInheritanceAware() && $context->considerInheritance());
  664.             $translatedField = self::getTranslatedField($definition, $field);
  666.             return $this->getTranslationFieldAccessor($translatedField, $original, $inheritedChain, $context);
  667.         }
  669.         $select = $this->buildFieldSelector($root, $field, $context, $original);
  671.         if (!$field->is(Inherited::class) || !$context->considerInheritance()) {
  672.             return $select;
  673.         }
  675.         $parentSelect = $this->buildFieldSelector($root . '.parent', $field, $context, $original);
  677.         return sprintf('IFNULL(%s, %s)', $select, $parentSelect);
  678.     }
  680.     private function buildFieldSelector(string $root, Field $field, Context $context, string $accessor): string
  681.     {
  682.         $accessorBuilder = $field->getAccessorBuilder();
  683.         if (!$accessorBuilder) {
  684.             throw new FieldAccessorBuilderNotFoundException($field->getPropertyName());
  685.         }
  687.         $accessor = $accessorBuilder->buildAccessor($root, $field, $context, $accessor);
  689.         if (!$accessor) {
  690.             throw new \RuntimeException(sprintf('Can not build accessor for field "%s" on root "%s"', $field->getPropertyName(), $root));
  691.         }
  693.         return $accessor;
  694.     }
  695. }