From bf6655a534a6775d30cafa67bd801276bda1d98d Mon Sep 17 00:00:00 2001
From: polo <ordipolo@gmx.fr>
Date: Tue, 13 Aug 2024 23:45:21 +0200
Subject: =?UTF-8?q?VERSION=200.2=20doctrine=20ORM=20et=20entit=C3=A9s?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../src/Utility/HierarchyDiscriminatorResolver.php |  44 +++++++++
 .../orm/src/Utility/IdentifierFlattener.php        |  83 ++++++++++++++++
 vendor/doctrine/orm/src/Utility/LockSqlHelper.php  |  35 +++++++
 .../doctrine/orm/src/Utility/PersisterHelper.php   | 108 +++++++++++++++++++++
 4 files changed, 270 insertions(+)
 create mode 100644 vendor/doctrine/orm/src/Utility/HierarchyDiscriminatorResolver.php
 create mode 100644 vendor/doctrine/orm/src/Utility/IdentifierFlattener.php
 create mode 100644 vendor/doctrine/orm/src/Utility/LockSqlHelper.php
 create mode 100644 vendor/doctrine/orm/src/Utility/PersisterHelper.php

(limited to 'vendor/doctrine/orm/src/Utility')

diff --git a/vendor/doctrine/orm/src/Utility/HierarchyDiscriminatorResolver.php b/vendor/doctrine/orm/src/Utility/HierarchyDiscriminatorResolver.php
new file mode 100644
index 0000000..b682125
--- /dev/null
+++ b/vendor/doctrine/orm/src/Utility/HierarchyDiscriminatorResolver.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Utility;
+
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\Persistence\Mapping\ClassMetadata;
+
+/** @internal This class exists only to avoid code duplication, do not reuse it externally */
+final class HierarchyDiscriminatorResolver
+{
+    private function __construct()
+    {
+    }
+
+    /**
+     * This method is needed to make INSTANCEOF work correctly with inheritance: if the class at hand has inheritance,
+     * it extracts all the discriminators from the child classes and returns them
+     *
+     * @return null[]
+     * @psalm-return array<array-key, null>
+     */
+    public static function resolveDiscriminatorsForClass(
+        ClassMetadata $rootClassMetadata,
+        EntityManagerInterface $entityManager,
+    ): array {
+        $hierarchyClasses   = $rootClassMetadata->subClasses;
+        $hierarchyClasses[] = $rootClassMetadata->name;
+
+        $discriminators = [];
+
+        foreach ($hierarchyClasses as $class) {
+            $currentMetadata      = $entityManager->getClassMetadata($class);
+            $currentDiscriminator = $currentMetadata->discriminatorValue;
+
+            if ($currentDiscriminator !== null) {
+                $discriminators[$currentDiscriminator] = null;
+            }
+        }
+
+        return $discriminators;
+    }
+}
diff --git a/vendor/doctrine/orm/src/Utility/IdentifierFlattener.php b/vendor/doctrine/orm/src/Utility/IdentifierFlattener.php
new file mode 100644
index 0000000..3792d33
--- /dev/null
+++ b/vendor/doctrine/orm/src/Utility/IdentifierFlattener.php
@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Utility;
+
+use BackedEnum;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\UnitOfWork;
+use Doctrine\Persistence\Mapping\ClassMetadataFactory;
+
+use function assert;
+use function implode;
+use function is_a;
+
+/**
+ * The IdentifierFlattener utility now houses some of the identifier manipulation logic from unit of work, so that it
+ * can be re-used elsewhere.
+ */
+final class IdentifierFlattener
+{
+    /**
+     * Initializes a new IdentifierFlattener instance, bound to the given EntityManager.
+     */
+    public function __construct(
+        /**
+         * The UnitOfWork used to coordinate object-level transactions.
+         */
+        private readonly UnitOfWork $unitOfWork,
+        /**
+         * The metadata factory, used to retrieve the ORM metadata of entity classes.
+         */
+        private readonly ClassMetadataFactory $metadataFactory,
+    ) {
+    }
+
+    /**
+     * convert foreign identifiers into scalar foreign key values to avoid object to string conversion failures.
+     *
+     * @param mixed[] $id
+     *
+     * @return mixed[]
+     * @psalm-return array<string, mixed>
+     */
+    public function flattenIdentifier(ClassMetadata $class, array $id): array
+    {
+        $flatId = [];
+
+        foreach ($class->identifier as $field) {
+            if (isset($class->associationMappings[$field]) && isset($id[$field]) && is_a($id[$field], $class->associationMappings[$field]->targetEntity)) {
+                $targetClassMetadata = $this->metadataFactory->getMetadataFor(
+                    $class->associationMappings[$field]->targetEntity,
+                );
+                assert($targetClassMetadata instanceof ClassMetadata);
+
+                if ($this->unitOfWork->isInIdentityMap($id[$field])) {
+                    $associatedId = $this->flattenIdentifier($targetClassMetadata, $this->unitOfWork->getEntityIdentifier($id[$field]));
+                } else {
+                    $associatedId = $this->flattenIdentifier($targetClassMetadata, $targetClassMetadata->getIdentifierValues($id[$field]));
+                }
+
+                $flatId[$field] = implode(' ', $associatedId);
+            } elseif (isset($class->associationMappings[$field])) {
+                assert($class->associationMappings[$field]->isToOneOwningSide());
+                $associatedId = [];
+
+                foreach ($class->associationMappings[$field]->joinColumns as $joinColumn) {
+                    $associatedId[] = $id[$joinColumn->name];
+                }
+
+                $flatId[$field] = implode(' ', $associatedId);
+            } else {
+                if ($id[$field] instanceof BackedEnum) {
+                    $flatId[$field] = $id[$field]->value;
+                } else {
+                    $flatId[$field] = $id[$field];
+                }
+            }
+        }
+
+        return $flatId;
+    }
+}
diff --git a/vendor/doctrine/orm/src/Utility/LockSqlHelper.php b/vendor/doctrine/orm/src/Utility/LockSqlHelper.php
new file mode 100644
index 0000000..7d135eb
--- /dev/null
+++ b/vendor/doctrine/orm/src/Utility/LockSqlHelper.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Utility;
+
+use Doctrine\DBAL\Platforms\AbstractMySQLPlatform;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Platforms\DB2Platform;
+use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
+use Doctrine\DBAL\Platforms\SQLitePlatform;
+use Doctrine\DBAL\Platforms\SQLServerPlatform;
+
+/** @internal */
+trait LockSqlHelper
+{
+    private function getReadLockSQL(AbstractPlatform $platform): string
+    {
+        return match (true) {
+            $platform instanceof AbstractMySQLPlatform => 'LOCK IN SHARE MODE',
+            $platform instanceof PostgreSQLPlatform => 'FOR SHARE',
+            default => $this->getWriteLockSQL($platform),
+        };
+    }
+
+    private function getWriteLockSQL(AbstractPlatform $platform): string
+    {
+        return match (true) {
+            $platform instanceof DB2Platform => 'WITH RR USE AND KEEP UPDATE LOCKS',
+            $platform instanceof SQLitePlatform,
+            $platform instanceof SQLServerPlatform => '',
+            default => 'FOR UPDATE',
+        };
+    }
+}
diff --git a/vendor/doctrine/orm/src/Utility/PersisterHelper.php b/vendor/doctrine/orm/src/Utility/PersisterHelper.php
new file mode 100644
index 0000000..76e9242
--- /dev/null
+++ b/vendor/doctrine/orm/src/Utility/PersisterHelper.php
@@ -0,0 +1,108 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Utility;
+
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Query\QueryException;
+use RuntimeException;
+
+use function sprintf;
+
+/**
+ * The PersisterHelper contains logic to infer binding types which is used in
+ * several persisters.
+ *
+ * @link   www.doctrine-project.org
+ */
+class PersisterHelper
+{
+    /**
+     * @return list<string>
+     *
+     * @throws QueryException
+     */
+    public static function getTypeOfField(string $fieldName, ClassMetadata $class, EntityManagerInterface $em): array
+    {
+        if (isset($class->fieldMappings[$fieldName])) {
+            return [$class->fieldMappings[$fieldName]->type];
+        }
+
+        if (! isset($class->associationMappings[$fieldName])) {
+            return [];
+        }
+
+        $assoc = $class->associationMappings[$fieldName];
+
+        if (! $assoc->isOwningSide()) {
+            return self::getTypeOfField($assoc->mappedBy, $em->getClassMetadata($assoc->targetEntity), $em);
+        }
+
+        if ($assoc->isManyToManyOwningSide()) {
+            $joinData = $assoc->joinTable;
+        } else {
+            $joinData = $assoc;
+        }
+
+        $types       = [];
+        $targetClass = $em->getClassMetadata($assoc->targetEntity);
+
+        foreach ($joinData->joinColumns as $joinColumn) {
+            $types[] = self::getTypeOfColumn($joinColumn->referencedColumnName, $targetClass, $em);
+        }
+
+        return $types;
+    }
+
+    /** @throws RuntimeException */
+    public static function getTypeOfColumn(string $columnName, ClassMetadata $class, EntityManagerInterface $em): string
+    {
+        if (isset($class->fieldNames[$columnName])) {
+            $fieldName = $class->fieldNames[$columnName];
+
+            if (isset($class->fieldMappings[$fieldName])) {
+                return $class->fieldMappings[$fieldName]->type;
+            }
+        }
+
+        // iterate over to-one association mappings
+        foreach ($class->associationMappings as $assoc) {
+            if (! $assoc->isToOneOwningSide()) {
+                continue;
+            }
+
+            foreach ($assoc->joinColumns as $joinColumn) {
+                if ($joinColumn->name === $columnName) {
+                    $targetColumnName = $joinColumn->referencedColumnName;
+                    $targetClass      = $em->getClassMetadata($assoc->targetEntity);
+
+                    return self::getTypeOfColumn($targetColumnName, $targetClass, $em);
+                }
+            }
+        }
+
+        // iterate over to-many association mappings
+        foreach ($class->associationMappings as $assoc) {
+            if (! $assoc->isManyToManyOwningSide()) {
+                continue;
+            }
+
+            foreach ($assoc->joinTable->joinColumns as $joinColumn) {
+                if ($joinColumn->name === $columnName) {
+                    $targetColumnName = $joinColumn->referencedColumnName;
+                    $targetClass      = $em->getClassMetadata($assoc->targetEntity);
+
+                    return self::getTypeOfColumn($targetColumnName, $targetClass, $em);
+                }
+            }
+        }
+
+        throw new RuntimeException(sprintf(
+            'Could not resolve type of column "%s" of class "%s"',
+            $columnName,
+            $class->getName(),
+        ));
+    }
+}
-- 
cgit v1.2.3