Merge pull request #3 from moufmouf/1.0

Adding ability to detect inheritance relationships between tables

Author: xhuberty

README.md

@@ -47,6 +47,28 @@ 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*).
 
+## Detecting inheritance relationship between tables
+
+### About inheritance relationships
+
+If a table "user" has a primary key that is also a foreign key pointing on table "contact", then table "user" is 
+considered to be a child of table "contact". This is because you cannot create a row in "user" without having a row 
+with the same ID in "contact".
+
+Therefore, a "user" ID has to match a "contact", but a "contact" has not necessarily a "user" associated. 
+
+### Detecting inheritance relationships
+
+You can use `SchemaAnalyzer` to detect parent / child relationships.
+
+```php
+$parent = $schemaAnalyzer->getParentTable("user");
+// This will return the "contact" table (as a string)
+
+$children = $schemaAnalyzer->getChildrenTables("contact");
+// This will return an array of tables whose parent is contact: ["user"]
+```
+
 ## Computing the shortest path between 2 tables
 
 Following foreign keys, the `getShortestPath` function will try to find the shortest path between 2 tables.
@@ -56,6 +78,8 @@ Internals:
 
 - Each foreign key has a *cost* of 1
 - Junction tables have a *cost* of 1.5, instead of 2 (one for each foreign key)
+- Foreign keys representing an inheritance relationship (i.e. foreign keys binding the primary keys of 2 tables)
+  have a *cost* of 0.1
 
 ```php
 // $conn is the DBAL connection.

src/SchemaAnalyzer.php

@@ -22,6 +22,7 @@
 class SchemaAnalyzer
 {
     private static $WEIGHT_FK = 1;
+    private static $WEIGHT_INHERITANCE_FK = 0.1;
     private static $WEIGHT_JOINTURE_TABLE = 1.5;
 
     const WEIGHT_IMPORTANT = 0.75;
@@ -49,13 +50,15 @@ class SchemaAnalyzer
     private $cachePrefix;
 
     /**
-     * Nested arrays containing table => column => cost
+     * Nested arrays containing table => column => cost.
+     *
      * @var float[][]
      */
     private $alteredCosts = [];
 
     /**
-     * Array containing table cost
+     * Array containing table cost.
+     *
      * @var float[]
      */
     private $alteredTableCosts = [];
@@ -124,7 +127,11 @@ private function isJunctionTable(Table $table)
             return false;
         }
 
-        $pkColumns = $table->getPrimaryKeyColumns();
+        if ($table->hasPrimaryKey()) {
+            $pkColumns = $table->getPrimaryKeyColumns();
+        } else {
+            $pkColumns = [];
+        }
 
         if (count($pkColumns) == 1 && count($columns) == 2) {
             return false;
@@ -170,14 +177,9 @@ private function isJunctionTable(Table $table)
      */
     public function getShortestPath($fromTable, $toTable)
     {
-        $cacheKey = $this->cachePrefix.'_shortest_'.$fromTable.'```'.$toTable;
-        $path = $this->cache->fetch($cacheKey);
-        if ($path === false) {
-            $path = $this->getShortestPathWithoutCache($fromTable, $toTable);
-            $this->cache->save($cacheKey, $path);
-        }
-
-        return $path;
+        return $this->fromCache($this->cachePrefix.'_shortest_'.$fromTable.'```'.$toTable, function () use ($fromTable, $toTable) {
+            return $this->getShortestPathWithoutCache($fromTable, $toTable);
+        });
     }
 
     /**
@@ -255,8 +257,10 @@ private function buildSchemaGraph()
             foreach ($table->getForeignKeys() as $fk) {
                 // Create an undirected edge, with weight = 1
                 $edge = $graph->getVertex($table->getName())->createEdge($graph->getVertex($fk->getForeignTableName()));
-                if (isset($this->alteredCosts[$fk->getLocalTable()->getName()][implode(',',$fk->getLocalColumns())])) {
-                    $cost = $this->alteredCosts[$fk->getLocalTable()->getName()][implode(',',$fk->getLocalColumns())];
+                if (isset($this->alteredCosts[$fk->getLocalTable()->getName()][implode(',', $fk->getLocalColumns())])) {
+                    $cost = $this->alteredCosts[$fk->getLocalTable()->getName()][implode(',', $fk->getLocalColumns())];
+                } elseif ($this->isInheritanceRelationship($fk)) {
+                    $cost = self::$WEIGHT_INHERITANCE_FK;
                 } else {
                     $cost = self::$WEIGHT_FK;
                 }
@@ -386,21 +390,25 @@ private function getTextualPath(array $path, Vertex $startVertex)
      *
      * @param string $tableName
      * @param string $columnName
-     * @param float $cost
+     * @param float  $cost
+     *
      * @return $this
      */
-    public function setForeignKeyCost($tableName, $columnName, $cost) {
+    public function setForeignKeyCost($tableName, $columnName, $cost)
+    {
         $this->alteredCosts[$tableName][$columnName] = $cost;
     }
 
     /**
      * Sets the cost modifier of a table.
      *
      * @param string $tableName
-     * @param float $cost
+     * @param float  $cost
+     *
      * @return $this
      */
-    public function setTableCostModifier($tableName, $cost) {
+    public function setTableCostModifier($tableName, $cost)
+    {
         $this->alteredTableCosts[$tableName] = $cost;
     }
 
@@ -409,7 +417,8 @@ public function setTableCostModifier($tableName, $cost) {
      *
      * @param array<string, float> $tableCosts The key is the table name, the value is the cost modifier.
      */
-    public function setTableCostModifiers(array $tableCosts) {
+    public function setTableCostModifiers(array $tableCosts)
+    {
         $this->alteredTableCosts = $tableCosts;
     }
 
@@ -418,7 +427,129 @@ public function setTableCostModifiers(array $tableCosts) {
      *
      * @param array<string, array<string, float>> $fkCosts First key is the table name, second key is the column name, the value is the cost.
      */
-    public function setForeignKeyCosts(array $fkCosts) {
+    public function setForeignKeyCosts(array $fkCosts)
+    {
         $this->alteredCosts = $fkCosts;
     }
+
+    /**
+     * Returns true if this foreign key represents an inheritance relationship,
+     * i.e. if this foreign key is based on a primary key.
+     *
+     * @param ForeignKeyConstraint $fk
+     *
+     * @return true
+     */
+    private function isInheritanceRelationship(ForeignKeyConstraint $fk)
+    {
+        if (!$fk->getLocalTable()->hasPrimaryKey()) {
+            return false;
+        }
+        $fkColumnNames = $fk->getLocalColumns();
+        $pkColumnNames = $fk->getLocalTable()->getPrimaryKeyColumns();
+
+        sort($fkColumnNames);
+        sort($pkColumnNames);
+
+        return $fkColumnNames == $pkColumnNames;
+    }
+
+    /**
+     * If this table is pointing to a parent table (if its primary key is a foreign key pointing on another table),
+     * this function will return the pointed table.
+     * This function will return null if there is no parent table.
+     *
+     * @param string $tableName
+     *
+     * @return string|null
+     */
+    public function getParentTable($tableName)
+    {
+        return $this->fromCache($this->cachePrefix.'_parent_'.$tableName, function () use ($tableName) {
+            return $this->getParentTableWithoutCache($tableName);
+        });
+    }
+
+    /**
+     * If this table is pointing to a parent table (if its primary key is a foreign key pointing on another table),
+     * this function will return the pointed table.
+     * This function will return null if there is no parent table.
+     *
+     * @param string $tableName
+     *
+     * @return string|null
+     */
+    private function getParentTableWithoutCache($tableName)
+    {
+        $table = $this->getSchema()->getTable($tableName);
+        foreach ($table->getForeignKeys() as $fk) {
+            if ($this->isInheritanceRelationship($fk)) {
+                return $fk->getForeignTableName();
+            }
+        }
+
+        return;
+    }
+
+    /**
+     * If this table is pointed by children tables (if other child tables have a primary key that is also a
+     * foreign key to this table), this function will return the list of child tables.
+     * This function will return an empty array if there are no children tables.
+     *
+     * @param string $tableName
+     *
+     * @return string[]
+     */
+    public function getChildrenTables($tableName)
+    {
+        return $this->fromCache($this->cachePrefix.'_children_'.$tableName, function () use ($tableName) {
+            return $this->getChildrenTablesWithoutCache($tableName);
+        });
+    }
+
+    /**
+     * If this table is pointed by children tables (if other child tables have a primary key that is also a
+     * foreign key to this table), this function will return the list of child tables.
+     * This function will return an empty array if there are no children tables.
+     *
+     * @param string $tableName
+     *
+     * @return string[]
+     */
+    private function getChildrenTablesWithoutCache($tableName)
+    {
+        $schema = $this->getSchema();
+        $children = [];
+        foreach ($schema->getTables() as $table) {
+            if ($table->getName() === $tableName) {
+                continue;
+            }
+            foreach ($table->getForeignKeys() as $fk) {
+                if ($fk->getForeignTableName() === $tableName && $this->isInheritanceRelationship($fk)) {
+                    $children[] = $fk->getLocalTableName();
+                }
+            }
+        }
+
+        return $children;
+    }
+
+    /**
+     * Returns an item from cache or computes it using $closure and puts it in cache.
+     *
+     * @param string   $key
+     * @param callable $closure
+     *
+     * @return mixed
+     */
+    private function fromCache($key, callable $closure)
+    {
+        $item = $this->cache->fetch($key);
+        if ($item === false) {
+            $item = $closure();
+            $this->cache->save($key, $item);
+        }
+
+        return $item;
+    }
 }