Merge pull request #5 from moufmouf/1.0

Adding a parameter to ignore junction tables pointed by foreign keys

Author: moufmouf

README.md

@@ -47,6 +47,15 @@ A **junction table** is a table:
 - that has **exactly 2 foreign keys**
 - that has **only 2 columns** (or **3 columns** if the one of those is an *autoincremented primary key*).
 
+There is an optional parameter you can use with `detectJunctionTables` that will automatically ignore any junction 
+table that is referenced by a foreign key of another table.
+
+```php
+// Get all junction tables except the ones that are references by a foreign key.
+$tables = $schemaAnalyzer->detectJunctionTables(true);
+```
+
+
 ## Detecting inheritance relationship between tables
 
 ### About inheritance relationships

src/SchemaAnalyzer.php

@@ -89,15 +89,21 @@ public function __construct(AbstractSchemaManager $schemaManager, Cache $cache =
      * - it has exactly 2 foreign keys
      * - it has only 2 columns (or 3 columns if the third one is an autoincremented primary key).
      *
+     * If $ignoreReferencedTables is true, junctions table that are pointed to by a foreign key of another
+     * table are ignored.
+     *
+     * @param bool $ignoreReferencedTables
      *
      * @return Table[]
      */
-    public function detectJunctionTables()
+    public function detectJunctionTables($ignoreReferencedTables = false)
     {
-        $junctionTablesKey = $this->cachePrefix.'_junctiontables';
+        $junctionTablesKey = $this->cachePrefix.'_junctiontables_'.($ignoreReferencedTables ? 'true' : 'false');
         $junctionTables = $this->cache->fetch($junctionTablesKey);
         if ($junctionTables === false) {
-            $junctionTables = array_filter($this->getSchema()->getTables(), [$this, 'isJunctionTable']);
+            $junctionTables = array_filter($this->getSchema()->getTables(), function (Table $table) use ($ignoreReferencedTables) {
+                return $this->isJunctionTable($table, $ignoreReferencedTables);
+            });
             $this->cache->save($junctionTablesKey, $junctionTables);
         }
 
@@ -111,14 +117,18 @@ public function detectJunctionTables()
      * - it must have exactly 2 foreign keys
      * - it must have only 2 columns (or 3 columns if the third one is an autoincremented primary key).
      *
+     * If $ignoreReferencedTables is true, junctions table that are pointed to by a foreign key of another
+     * table are ignored.
+     *
      * @param Table $table
+     * @param bool  $ignoreReferencedTables
      *
      * @return bool
      */
-    private function isJunctionTable(Table $table)
+    private function isJunctionTable(Table $table, $ignoreReferencedTables = false)
     {
         $foreignKeys = $table->getForeignKeys();
-        if (count($foreignKeys) != 2) {
+        if (count($foreignKeys) !== 2) {
             return false;
         }
 
@@ -133,24 +143,24 @@ private function isJunctionTable(Table $table)
             $pkColumns = [];
         }
 
-        if (count($pkColumns) == 1 && count($columns) == 2) {
+        if (count($pkColumns) === 1 && count($columns) === 2) {
             return false;
         }
 
-        if (count($pkColumns) != 1 && count($columns) == 3) {
+        if (count($pkColumns) !== 1 && count($columns) === 3) {
             return false;
         }
 
         $fkColumnNames = [];
         foreach ($foreignKeys as $foreignKey) {
             $fkColumns = $foreignKey->getColumns();
-            if (count($fkColumns) != 1) {
+            if (count($fkColumns) !== 1) {
                 return false;
             }
             $fkColumnNames[$fkColumns[0]] = true;
         }
 
-        if (count($columns) == 3) {
+        if (count($columns) === 3) {
             // Let's check that the third column (the ID is NOT a foreign key)
             if (isset($fkColumnNames[$pkColumns[0]])) {
                 return false;
@@ -162,9 +172,34 @@ private function isJunctionTable(Table $table)
             }
         }
 
+        if ($ignoreReferencedTables && $this->isTableReferenced($table)) {
+            return false;
+        }
+
         return true;
     }
 
+    /**
+     * Returns true if the table $table is referenced by another table.
+     *
+     * @param Table $table
+     *
+     * @return bool
+     */
+    private function isTableReferenced(Table $table)
+    {
+        $tableName = $table->getName();
+        foreach ($this->getSchema()->getTables() as $tableIter) {
+            foreach ($tableIter->getForeignKeys() as $fk) {
+                if ($fk->getForeignTableName() === $tableName) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     /**
      * Get the shortest path between 2 tables.
      *
@@ -488,7 +523,7 @@ private function getParentRelationshipWithoutCache($tableName)
             }
         }
 
-        return null;
+        return;
     }
 
     /**

tests/SchemaAnalyzerTest.php

@@ -206,6 +206,36 @@ public function testJointureTableDetectionWith3ColumnsWithPkIsFk()
         $junctionTables = $schemaAnalyzer->detectJunctionTables();
 
         $this->assertCount(0, $junctionTables);
+
+        $junctionTables = $schemaAnalyzer->detectJunctionTables(true);
+        $this->assertCount(0, $junctionTables);
+    }
+
+    public function testJointureTableDetectionWithForeignKeyPointingOnJointureTable()
+    {
+        $schema = $this->getBaseSchema();
+
+        $role_right = $schema->createTable('role_right');
+        $role_right->addColumn('id', 'integer', array('unsigned' => true, 'autoincrement' => true));
+        $role_right->addColumn('role_id', 'integer', array('unsigned' => true));
+        $role_right->addColumn('right_id', 'integer', array('unsigned' => true));
+
+        $role_right->addForeignKeyConstraint($schema->getTable('role'), array('role_id'), array('id'), array('onUpdate' => 'CASCADE'));
+        $role_right->addForeignKeyConstraint($schema->getTable('right'), array('right_id'), array('id'), array('onUpdate' => 'CASCADE'));
+        $role_right->setPrimaryKey(['id']);
+
+        $other_table = $schema->createTable('other_table');
+        $other_table->addColumn('id', 'integer', array('unsigned' => true, 'autoincrement' => true));
+        $other_table->addColumn('role_right_id', 'integer', array('unsigned' => true));
+        $other_table->addForeignKeyConstraint($schema->getTable('role_right'), array('role_right_id'), array('id'), array('onUpdate' => 'CASCADE'));
+        $other_table->setPrimaryKey(['id']);
+
+        $schemaAnalyzer = new SchemaAnalyzer(new StubSchemaManager($schema));
+        $junctionTables = $schemaAnalyzer->detectJunctionTables();
+        $this->assertCount(1, $junctionTables);
+
+        $junctionTables = $schemaAnalyzer->detectJunctionTables(true);
+        $this->assertCount(0, $junctionTables);
     }
 
     public function testShortestPathInJointure()
@@ -283,7 +313,7 @@ public function testCache()
         $schemaAnalyzer->detectJunctionTables();
 
         $this->assertNotFalse($cache->fetch('mykey_schema'));
-        $this->assertNotFalse($cache->fetch('mykey_junctiontables'));
+        $this->assertNotFalse($cache->fetch('mykey_junctiontables_false'));
         $r1 = $schemaAnalyzer->getShortestPath('role_right', 'role');
         $r2 = $schemaAnalyzer->getShortestPath('role_right', 'role');
         $this->assertTrue($r1 === $r2);