IBX-10219: Fixed handling multiple relationship comparison (#31)

Author: ciastektk

src/contracts/Gateway/AbstractDoctrineDatabase.php

@@ -12,6 +12,7 @@
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\Query\QueryBuilder;
 use Ibexa\CorePersistence\Gateway\ExpressionVisitor;
+use Ibexa\CorePersistence\Gateway\RelationshipTypeStrategyRegistry;
 use InvalidArgumentException;
 
 /**
@@ -308,6 +309,7 @@ protected function buildExpressionVisitor(QueryBuilder $qb): ExpressionVisitor
             $this->registry,
             $this->getTableName(),
             $this->getTableAlias(),
+            new RelationshipTypeStrategyRegistry()
         );
     }
 

src/lib/Gateway/ExpressionVisitor.php

@@ -16,11 +16,11 @@
 use Doctrine\DBAL\Query\Expression\ExpressionBuilder;
 use Doctrine\DBAL\Query\QueryBuilder;
 use Ibexa\Contracts\CorePersistence\Exception\RuntimeMappingException;
-use Ibexa\Contracts\CorePersistence\Gateway\DoctrineOneToManyRelationship;
 use Ibexa\Contracts\CorePersistence\Gateway\DoctrineRelationship;
 use Ibexa\Contracts\CorePersistence\Gateway\DoctrineRelationshipInterface;
 use Ibexa\Contracts\CorePersistence\Gateway\DoctrineSchemaMetadataInterface;
 use Ibexa\Contracts\CorePersistence\Gateway\DoctrineSchemaMetadataRegistryInterface;
+use LogicException;
 use RuntimeException;
 
 /**
@@ -48,19 +48,23 @@ final class ExpressionVisitor extends BaseExpressionVisitor
 
     private DoctrineSchemaMetadataRegistryInterface $registry;
 
+    private RelationshipTypeStrategyRegistryInterface $relationshipTypeStrategyRegistry;
+
     /**
      * @param non-empty-string $tableName
      */
     public function __construct(
         QueryBuilder $queryBuilder,
         DoctrineSchemaMetadataRegistryInterface $registry,
         string $tableName,
-        string $tableAlias
+        string $tableAlias,
+        RelationshipTypeStrategyRegistryInterface $relationshipTypeStrategyRegistry
     ) {
         $this->queryBuilder = $queryBuilder;
         $this->schemaMetadata = $registry->getMetadataForTable($tableName);
         $this->tableAlias = $tableAlias;
         $this->registry = $registry;
+        $this->relationshipTypeStrategyRegistry = $relationshipTypeStrategyRegistry;
     }
 
     /**
@@ -102,7 +106,7 @@ public function walkComparison(Comparison $comparison)
         }
 
         $parameterName = $column . '_' . count($this->parameters);
-        $placeholder = ':' . $parameterName;
+        $placeholder = $this->getPlaceholder($parameterName);
         $value = $this->walkValue($comparison->getValue());
         $type = $this->schemaMetadata->getBindingTypeForColumn($column);
         if (is_array($value)) {
@@ -162,6 +166,10 @@ private function containsRelationshipDelimiter(string $column): bool
     private function handleRelationshipComparison(string $column, Comparison $comparison): string
     {
         $metadata = $this->schemaMetadata;
+        $fromTable = $this->tableAlias;
+        $toTable = null;
+        $subQuery = null;
+
         do {
             [
                 $foreignProperty,
@@ -170,6 +178,26 @@ private function handleRelationshipComparison(string $column, Comparison $compar
 
             $relationship = $metadata->getRelationshipByForeignProperty($foreignProperty);
             $metadata = $this->registry->getMetadata($relationship->getRelationshipClass());
+            $parentMetadata = $metadata->getParentMetadata();
+            if (null !== $parentMetadata) {
+                $fromTable = $parentMetadata->getTableName();
+            } else {
+                $fromTable = $toTable ?? $fromTable;
+            }
+
+            $toTable = $metadata->getTableName();
+
+            if (DoctrineRelationship::JOIN_TYPE_SUB_SELECT === $relationship->getJoinType()) {
+                $subQuery ??= $this->queryBuilder->getConnection()->createQueryBuilder();
+            }
+
+            $this->relationshipTypeStrategyRegistry->handleRelationshipType(
+                $subQuery ?? $this->queryBuilder,
+                $relationship,
+                $this->tableAlias,
+                $fromTable,
+                $toTable
+            );
         } while ($this->containsRelationshipDelimiter($column));
 
         if (!$metadata->hasColumn($column)) {
@@ -186,32 +214,7 @@ private function handleRelationshipComparison(string $column, Comparison $compar
             ));
         }
 
-        $relationshipType = get_class($relationship);
-
-        switch (true) {
-            case $relationship->getJoinType() === DoctrineRelationship::JOIN_TYPE_SUB_SELECT:
-                return $this->handleSubSelectQuery(
-                    $metadata,
-                    $relationship->getForeignKeyColumn(),
-                    $column,
-                    $comparison,
-                );
-            case $relationship->getJoinType() === DoctrineRelationship::JOIN_TYPE_JOINED:
-                return $this->handleJoinQuery(
-                    $metadata,
-                    $column,
-                    $comparison,
-                );
-            default:
-                throw new RuntimeMappingException(sprintf(
-                    'Unhandled relationship metadata. Expected one of "%s". Received "%s".',
-                    implode('", "', [
-                        DoctrineRelationship::class,
-                        DoctrineOneToManyRelationship::class,
-                    ]),
-                    $relationshipType,
-                ));
-        }
+        return $this->handleRelationshipQuery($metadata, $relationship, $column, $comparison, $subQuery);
     }
 
     private function escapeSpecialSQLValues(Parameter $parameter): string
@@ -226,63 +229,106 @@ private function expr(): ExpressionBuilder
         return $this->queryBuilder->expr();
     }
 
+    private function handleRelationshipQuery(
+        DoctrineSchemaMetadataInterface $metadata,
+        DoctrineRelationshipInterface $relationship,
+        string $column,
+        Comparison $comparison,
+        ?QueryBuilder $subQuery
+    ): string {
+        $isSubSelectJoin = $relationship->getJoinType() === DoctrineRelationship::JOIN_TYPE_SUB_SELECT;
+        if ($isSubSelectJoin) {
+            if ($subQuery === null) {
+                throw new LogicException(
+                    'Sub-select query is not initialized.',
+                );
+            }
+        }
+
+        $parameterName = $column . '_' . count($this->parameters);
+        $fullColumnName = $metadata->getTableName() . '.' . $column;
+        $relationshipQuery = $this->relationshipTypeStrategyRegistry->handleRelationshipTypeQuery(
+            $relationship,
+            $subQuery ?? $this->queryBuilder,
+            $fullColumnName,
+            $this->getPlaceholder($parameterName)
+        );
+
+        if ($isSubSelectJoin) {
+            return $this->handleSubSelectQuery(
+                $relationship,
+                $metadata,
+                $comparison,
+                $column,
+                $parameterName,
+                $relationshipQuery
+            );
+        }
+
+        return $this->handleJoinQuery(
+            $comparison,
+            $metadata,
+            $column,
+            $parameterName,
+            $fullColumnName,
+            $relationshipQuery
+        );
+    }
+
     private function handleJoinQuery(
+        Comparison $comparison,
         DoctrineSchemaMetadataInterface $relationshipMetadata,
         string $field,
-        Comparison $comparison
+        string $parameterName,
+        string $fullColumnName,
+        QueryBuilder $relationshipQuery
     ): string {
-        $tableName = $relationshipMetadata->getTableName();
-        $parameterName = $field . '_' . count($this->parameters);
-        $placeholder = ':' . $parameterName;
-
         $value = $this->walkValue($comparison->getValue());
         $type = $relationshipMetadata->getBindingTypeForColumn($field);
+
         if (is_array($value)) {
             $type += Connection::ARRAY_PARAM_OFFSET;
         }
 
         $parameter = new Parameter($parameterName, $value, $type);
+        $placeholder = $this->getPlaceholder($parameterName);
 
         if (is_array($value)) {
             $this->parameters[] = $parameter;
 
-            return $this->expr()->in($tableName . '.' . $field, $placeholder);
+            return $relationshipQuery->expr()->in(
+                $fullColumnName,
+                $placeholder
+            );
         }
 
-        return $this->handleComparison($comparison, $parameter, $tableName . '.' . $field, $placeholder);
+        return $this->handleComparison(
+            $comparison,
+            $parameter,
+            $fullColumnName,
+            $placeholder
+        );
     }
 
     private function handleSubSelectQuery(
+        DoctrineRelationshipInterface $relationship,
         DoctrineSchemaMetadataInterface $relationshipMetadata,
-        string $foreignField,
+        Comparison $comparison,
         string $field,
-        Comparison $comparison
+        string $parameterName,
+        QueryBuilder $relationshipQuery
     ): string {
-        $tableName = $relationshipMetadata->getTableName();
-        $parameterName = $field . '_' . count($this->parameters);
-        $placeholder = ':' . $parameterName;
-
-        $subquery = $this->queryBuilder->getConnection()->createQueryBuilder();
-        $subquery->from($tableName);
-        $subquery->select($tableName . '.' . $relationshipMetadata->getIdentifierColumn());
-        $subquery->where(
-            $subquery->expr()->in(
-                $tableName . '.' . $field,
-                $placeholder,
-            ),
-        );
-
         $value = $this->walkValue($comparison->getValue());
         $type = $relationshipMetadata->getBindingTypeForColumn($field);
         if (is_array($value)) {
             $type += Connection::ARRAY_PARAM_OFFSET;
         }
-        $parameter = new Parameter($parameterName, $value, $type);
-        $this->parameters[] = $parameter;
+
+        $this->parameters[] = new Parameter($parameterName, $value, $type);
 
         return $this->expr()->in(
-            $this->tableAlias . '.' . $foreignField,
-            $subquery->getSQL(),
+            $this->tableAlias . '.' . $relationship->getForeignKeyColumn(),
+            $relationshipQuery->getSQL(),
         );
     }
 
@@ -304,6 +350,7 @@ private function handleTranslation(Comparison $comparison): string
             $this->registry,
             $translationMetadata->getTableName(),
             self::TRANSLATION_TABLE_ALIAS,
+            $this->relationshipTypeStrategyRegistry
         );
         $innerCondition = $innerExpressionVisitor->walkComparison($comparison);
         $subquery->andWhere($innerCondition);
@@ -317,6 +364,11 @@ private function handleTranslation(Comparison $comparison): string
         );
     }
 
+    private function getPlaceholder(string $parameterName): string
+    {
+        return ':' . $parameterName;
+    }
+
     private function isInheritedColumn(string $column): bool
     {
         return $this->schemaMetadata->getIdentifierColumn() !== $column

src/lib/Gateway/JoinedRelationshipTypeStrategy.php

@@ -0,0 +1,67 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\CorePersistence\Gateway;
+
+use Doctrine\DBAL\Query\QueryBuilder;
+use Ibexa\Contracts\CorePersistence\Gateway\DoctrineRelationshipInterface;
+
+/**
+ * @internal
+ */
+final class JoinedRelationshipTypeStrategy implements RelationshipTypeStrategyInterface
+{
+    public function handleRelationshipType(
+        QueryBuilder $queryBuilder,
+        DoctrineRelationshipInterface $relationship,
+        string $rootTableAlias,
+        string $fromTable,
+        string $toTable
+    ): void {
+        if ($this->isTableAlreadyJoined($queryBuilder, $toTable)) {
+            return;
+        }
+
+        $queryBuilder->leftJoin(
+            $fromTable,
+            $toTable,
+            $toTable,
+            $queryBuilder->expr()->eq(
+                $fromTable . '.' . $relationship->getForeignKeyColumn(),
+                $toTable . '.' . $relationship->getRelatedClassIdColumn()
+            )
+        );
+    }
+
+    public function handleRelationshipTypeQuery(
+        QueryBuilder $queryBuilder,
+        string $fullColumnName,
+        string $placeholder
+    ): QueryBuilder {
+        return $queryBuilder;
+    }
+
+    private function isTableAlreadyJoined(
+        QueryBuilder $queryBuilder,
+        string $tableToJoin
+    ): bool {
+        $joinQueryPart = $queryBuilder->getQueryPart('join');
+
+        foreach ($joinQueryPart as $joins) {
+            foreach ($joins as $join) {
+                $joinAlias = $join['joinAlias'] ?? $join['joinTable'];
+
+                if ($joinAlias === $tableToJoin) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+}

src/lib/Gateway/RelationshipTypeStrategyInterface.php

@@ -0,0 +1,32 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\CorePersistence\Gateway;
+
+use Doctrine\DBAL\Query\QueryBuilder;
+use Ibexa\Contracts\CorePersistence\Gateway\DoctrineRelationshipInterface;
+
+/**
+ * @internal
+ */
+interface RelationshipTypeStrategyInterface
+{
+    public function handleRelationshipType(
+        QueryBuilder $queryBuilder,
+        DoctrineRelationshipInterface $relationship,
+        string $rootTableAlias,
+        string $fromTable,
+        string $toTable
+    ): void;
+
+    public function handleRelationshipTypeQuery(
+        QueryBuilder $queryBuilder,
+        string $fullColumnName,
+        string $placeholder
+    ): QueryBuilder;
+}