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;
+ }
 }