/**
  * {@inheritdoc}
  */
 public function acceptForeignKey(Table $localTable, ForeignKeyConstraint $fkConstraint)
 {
     if (strlen($fkConstraint->getName()) == 0) {
         throw SchemaException::namedForeignKeyRequired($localTable, $fkConstraint);
     }
     $this->constraints->attach($fkConstraint, $localTable);
 }

 /**
  * @group DBAL-1062
  *
  * @dataProvider getIntersectsIndexColumnsData
  */
 public function testIntersectsIndexColumns(array $indexColumns, $expectedResult)
 {
     $foreignKey = new ForeignKeyConstraint(array('foo', 'bar'), 'foreign_table', array('fk_foo', 'fk_bar'));
     $index = $this->getMockBuilder('Doctrine\\DBAL\\Schema\\Index')->disableOriginalConstructor()->getMock();
     $index->expects($this->once())->method('getColumns')->will($this->returnValue($indexColumns));
     $this->assertSame($expectedResult, $foreignKey->intersectsIndexColumns($index));
 }

 /**
  * @param Table $localTable
  * @param ForeignKeyConstraint $fkConstraint
  */
 public function acceptForeignKey(Table $localTable, ForeignKeyConstraint $fkConstraint)
 {
     if (strlen($fkConstraint->getName()) == 0) {
         throw SchemaException::namedForeignKeyRequired($localTable, $fkConstraint);
     }
     $this->_constraints[] = $this->_platform->getDropForeignKeySQL($fkConstraint->getQuotedName($this->_platform), $localTable->getQuotedName($this->_platform));
 }

 /**
  * @param Table $localTable
  * @param ForeignKeyConstraint $fkConstraint
  */
 public function acceptForeignKey(Table $localTable, ForeignKeyConstraint $fkConstraint)
 {
     if ($this->_addExplicitIndexForForeignKey) {
         $columns = $fkConstraint->getColumns();
         if ($localTable->columnsAreIndexed($columns)) {
             return;
         }
         $localTable->addIndex($columns);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function acceptForeignKey(Table $localTable, ForeignKeyConstraint $fkConstraint)
 {
     // The table may already be deleted in a previous
     // RemoveNamespacedAssets#acceptTable call. Removing Foreign keys that
     // point to nowhere.
     if (!$this->schema->hasTable($fkConstraint->getForeignTableName())) {
         $localTable->removeForeignKey($fkConstraint->getName());
         return;
     }
     $foreignTable = $this->schema->getTable($fkConstraint->getForeignTableName());
     if (!$foreignTable->isInDefaultNamespace($this->schema->getName())) {
         $localTable->removeForeignKey($fkConstraint->getName());
     }
 }

 /**
  * @param ForeignKeyConstraint $constraint
  */
 protected function _addForeignKeyConstraint(ForeignKeyConstraint $constraint)
 {
     $constraint->setLocalTable($this);
     if (strlen($constraint->getName())) {
         $name = $constraint->getName();
     } else {
         $name = $this->_generateIdentifierName(array_merge((array) $this->getName(), $constraint->getLocalColumns()), "fk", $this->_getMaxIdentifierLength());
     }
     $name = strtolower($name);
     $this->_fkConstraints[$name] = $constraint;
 }

 /**
  * @param \Doctrine\DBAL\Schema\ForeignKeyConstraint $key1
  * @param \Doctrine\DBAL\Schema\ForeignKeyConstraint $key2
  *
  * @return boolean
  */
 public function diffForeignKey(ForeignKeyConstraint $key1, ForeignKeyConstraint $key2)
 {
     if (array_map('strtolower', $key1->getUnquotedLocalColumns()) != array_map('strtolower', $key2->getUnquotedLocalColumns())) {
         return true;
     }
     if (array_map('strtolower', $key1->getUnquotedForeignColumns()) != array_map('strtolower', $key2->getUnquotedForeignColumns())) {
         return true;
     }
     if ($key1->getUnqualifiedForeignTableName() !== $key2->getUnqualifiedForeignTableName()) {
         return true;
     }
     if ($key1->onUpdate() != $key2->onUpdate()) {
         return true;
     }
     if ($key1->onDelete() != $key2->onDelete()) {
         return true;
     }
     return false;
 }

 public function getGenerateConstraintForeignKeySql(ForeignKeyConstraint $fk)
 {
     $quotedForeignTable = $fk->getQuotedForeignTableName($this->_platform);
     return 'ALTER TABLE test ADD CONSTRAINT FOREIGN KEY (fk_name) ' . 'REFERENCES ' . $quotedForeignTable . ' (id) CONSTRAINT constraint_fk';
 }

 /**
  * {@inheritDoc}
  */
 public function getAdvancedForeignKeyOptionsSQL(\Doctrine\DBAL\Schema\ForeignKeyConstraint $foreignKey)
 {
     $query = '';
     if ($foreignKey->hasOption('match')) {
         $query .= ' MATCH ' . $foreignKey->getOption('match');
     }
     $query .= parent::getAdvancedForeignKeyOptionsSQL($foreignKey);
     return $query;
 }

 /**
  * {@inheritDoc}
  */
 public function getAdvancedForeignKeyOptionsSQL(\Doctrine\DBAL\Schema\ForeignKeyConstraint $foreignKey)
 {
     $query = '';
     if ($foreignKey->hasOption('match')) {
         $query .= ' MATCH ' . $foreignKey->getOption('match');
     }
     $query .= parent::getAdvancedForeignKeyOptionsSQL($foreignKey);
     if ($foreignKey->hasOption('deferrable') && $foreignKey->getOption('deferrable') !== false) {
         $query .= ' DEFERRABLE';
     } else {
         $query .= ' NOT DEFERRABLE';
     }
     if ($foreignKey->hasOption('feferred') && $foreignKey->getOption('feferred') !== false || $foreignKey->hasOption('deferred') && $foreignKey->getOption('deferred') !== false) {
         $query .= ' INITIALLY DEFERRED';
     } else {
         $query .= ' INITIALLY IMMEDIATE';
     }
     return $query;
 }

 /**
  * Obtain DBMS specific SQL code portion needed to set the FOREIGN KEY constraint
  * of a field declaration to be used in statements like CREATE TABLE.
  *
  * @param ForeignKeyConstraint $foreignKey
  * @return string
  */
 public function getForeignKeyBaseDeclarationSQL(ForeignKeyConstraint $foreignKey)
 {
     $sql = '';
     if (strlen($foreignKey->getName())) {
         $sql .= 'CONSTRAINT ' . $foreignKey->getQuotedName($this) . ' ';
     }
     $sql .= 'FOREIGN KEY (';
     if (count($foreignKey->getLocalColumns()) == 0) {
         throw new \InvalidArgumentException("Incomplete definition. 'local' required.");
     }
     if (count($foreignKey->getForeignColumns()) == 0) {
         throw new \InvalidArgumentException("Incomplete definition. 'foreign' required.");
     }
     if (strlen($foreignKey->getForeignTableName()) == 0) {
         throw new \InvalidArgumentException("Incomplete definition. 'foreignTable' required.");
     }
     $sql .= implode(', ', $foreignKey->getLocalColumns()) . ') REFERENCES ' . $foreignKey->getForeignTableName() . ' (' . implode(', ', $foreignKey->getForeignColumns()) . ')';
     return $sql;
 }

 /**
  * @param ForeignKeyConstraint $constraint
  *
  * @return void
  */
 protected function _addForeignKeyConstraint(ForeignKeyConstraint $constraint)
 {
     $constraint->setLocalTable($this);
     if (strlen($constraint->getName())) {
         $name = $constraint->getName();
     } else {
         $name = $this->_generateIdentifierName(array_merge((array) $this->getName(), $constraint->getLocalColumns()), "fk", $this->_getMaxIdentifierLength());
     }
     $name = $this->normalizeIdentifier($name);
     $this->_fkConstraints[$name] = $constraint;
     // add an explicit index on the foreign key columns. If there is already an index that fulfils this requirements drop the request.
     // In the case of __construct calling this method during hydration from schema-details all the explicitly added indexes
     // lead to duplicates. This creates computation overhead in this case, however no duplicate indexes are ever added (based on columns).
     $indexName = $this->_generateIdentifierName(array_merge(array($this->getName()), $constraint->getColumns()), "idx", $this->_getMaxIdentifierLength());
     $indexCandidate = $this->_createIndex($constraint->getColumns(), $indexName, false, false);
     foreach ($this->_indexes as $existingIndex) {
         if ($indexCandidate->isFullfilledBy($existingIndex)) {
             return;
         }
     }
     $this->_addIndex($indexCandidate);
     $this->implicitIndexes[$this->normalizeIdentifier($indexName)] = $indexCandidate;
 }

 /**
  * Returns the FOREIGN KEY query section dealing with non-standard options
  * as MATCH, INITIALLY DEFERRED, ON UPDATE, ...
  *
  * @param \Doctrine\DBAL\Schema\ForeignKeyConstraint $foreignKey The foreign key definition.
  *
  * @return string
  */
 public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey)
 {
     $query = '';
     if ($this->supportsForeignKeyOnUpdate() && $foreignKey->hasOption('onUpdate')) {
         $query .= ' ON UPDATE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onUpdate'));
     }
     if ($foreignKey->hasOption('onDelete')) {
         $query .= ' ON DELETE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onDelete'));
     }
     return $query;
 }

 /**
  * Creates a foreign index replacement, which has quoted column names.
  *
  * @param ForeignKeyConstraint $fk
  *
  * @return ForeignKeyConstraint
  */
 private function createForeignKeyReplacement(ForeignKeyConstraint $fk)
 {
     return new ForeignKeyConstraint($this->quoteIdentifiers($fk->getLocalColumns()), $this->platform->quoteIdentifier($fk->getForeignTableName()), $this->quoteIdentifiers($fk->getForeignColumns()), $this->platform->quoteIdentifier($fk->getName()), $fk->getOptions());
 }

 /**
  * @param ForeignKeyConstraint $foreignKey
  * @param Table|string         $table
  *
  * @return string
  */
 public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table)
 {
     $columns = $foreignKey->getColumns();
     $column = reset($columns);
     $column = $table->getColumn($column);
     $sql = array();
     if ($column->hasCustomSchemaOption('definedIn') and $column->getCustomSchemaOption('definedIn') === 'link') {
         $sql = $this->_getCreateColumnSQL($foreignKey->getLocalTableName(), $column->getName(), $column->toArray());
     }
     return $sql;
 }

 /**
  * Do checks for foreignKey constraints.
  *
  * @param ForeignKeyConstraint $foreignKeyConstraint
  * @param IgnoredChange        $ignoredChange
  *
  * @return boolean
  */
 protected function checkForeignKeyConstraint(ForeignKeyConstraint $foreignKeyConstraint, IgnoredChange $ignoredChange)
 {
     // Not needed to be implemented yet
     if ($ignoredChange->getPropertyName() !== $foreignKeyConstraint->getName()) {
         return false;
     }
     return false;
 }

 /**
  * {@inheritDoc}
  */
 public function getForeignKeyDeclarationSQL(ForeignKeyConstraint $foreignKey)
 {
     return parent::getForeignKeyDeclarationSQL(new ForeignKeyConstraint($foreignKey->getQuotedLocalColumns($this), str_replace('.', '__', $foreignKey->getQuotedForeignTableName($this)), $foreignKey->getQuotedForeignColumns($this), $foreignKey->getName(), $foreignKey->getOptions()));
 }

 /**
  * Do checks for foreignKey constraints.
  *
  * @param ForeignKeyConstraint $foreignKeyConstraint
  * @param array                $alterData
  *
  * @return boolean
  */
 protected function checkForeignKeyConstraint(ForeignKeyConstraint $foreignKeyConstraint, array $alterData)
 {
     // Not needed to be implemented yet
     if ($alterData['propertyName'] !== $foreignKeyConstraint->getName()) {
         return false;
     }
     return false;
 }

 /**
  * {@inheritdoc}
  */
 public function acceptForeignKey(Table $localTable, ForeignKeyConstraint $fkConstraint)
 {
     $this->output .= $this->createNodeRelation($fkConstraint->getLocalTableName() . ":col" . current($fkConstraint->getLocalColumns()) . ":se", $fkConstraint->getForeignTableName() . ":col" . current($fkConstraint->getForeignColumns()) . ":se", array('dir' => 'back', 'arrowtail' => 'dot', 'arrowhead' => 'normal'));
 }

 /**
  * {@inheritdoc}
  */
 public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey)
 {
     $referentialAction = null;
     if ($foreignKey->hasOption('onDelete')) {
         $referentialAction = $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onDelete'));
     }
     return $referentialAction ? ' ON DELETE ' . $referentialAction : '';
 }