vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/YamlDriver.php

   1 <?php
   2 /*
   3  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   4  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   5  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   6  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   7  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   8  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   9  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14  *
  15  * This software consists of voluntary contributions made by many individuals
  16  * and is licensed under the MIT license. For more information, see
  17  * <http://www.doctrine-project.org>.
  18  */
  19
  20 namespace Doctrine\ORM\Mapping\Driver;
  21
  22 use Doctrine\Common\Persistence\Mapping\ClassMetadata,
  23     Doctrine\Common\Persistence\Mapping\Driver\FileDriver,
  24     Doctrine\ORM\Mapping\MappingException,
  25     Symfony\Component\Yaml\Yaml;
  26
  27 /**
  28  * The YamlDriver reads the mapping metadata from yaml schema files.
  29  *
  30  * @since 2.0
  31  * @author Benjamin Eberlei <kontakt@beberlei.de>
  32  * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
  33  * @author Jonathan H. Wage <jonwage@gmail.com>
  34  * @author Roman Borschel <roman@code-factory.org>
  35  */
  36 class YamlDriver extends FileDriver
  37 {
  38     const DEFAULT_FILE_EXTENSION = '.dcm.yml';
  39
  40     /**
  41      * {@inheritDoc}
  42      */
  43     public function __construct($locator, $fileExtension = self::DEFAULT_FILE_EXTENSION)
  44     {
  45         parent::__construct($locator, $fileExtension);
  46     }
  47
  48     /**
  49      * {@inheritDoc}
  50      */
  51     public function loadMetadataForClass($className, ClassMetadata $metadata)
  52     {
  53         /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadataInfo */
  54         $element = $this->getElement($className);
  55
  56         if ($element['type'] == 'entity') {
  57             if (isset($element['repositoryClass'])) {
  58                 $metadata->setCustomRepositoryClass($element['repositoryClass']);
  59             }
  60             if (isset($element['readOnly']) && $element['readOnly'] == true) {
  61                 $metadata->markReadOnly();
  62             }
  63         } else if ($element['type'] == 'mappedSuperclass') {
  64             $metadata->setCustomRepositoryClass(
  65                 isset($element['repositoryClass']) ? $element['repositoryClass'] : null
  66             );
  67             $metadata->isMappedSuperclass = true;
  68         } else {
  69             throw MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
  70         }
  71
  72         // Evaluate root level properties
  73         $table = array();
  74         if (isset($element['table'])) {
  75             $table['name'] = $element['table'];
  76         }
  77         $metadata->setPrimaryTable($table);
  78
  79         // Evaluate named queries
  80         if (isset($element['namedQueries'])) {
  81             foreach ($element['namedQueries'] as $name => $queryMapping) {
  82                 if (is_string($queryMapping)) {
  83                     $queryMapping = array('query' => $queryMapping);
  84                 }
  85
  86                 if ( ! isset($queryMapping['name'])) {
  87                     $queryMapping['name'] = $name;
  88                 }
  89
  90                 $metadata->addNamedQuery($queryMapping);
  91             }
  92         }
  93
  94         // Evaluate named native queries
  95         if (isset($element['namedNativeQueries'])) {
  96             foreach ($element['namedNativeQueries'] as $name => $mappingElement) {
  97                 if (!isset($mappingElement['name'])) {
  98                     $mappingElement['name'] = $name;
  99                 }
 100                 $metadata->addNamedNativeQuery(array(
 101                     'name'              => $mappingElement['name'],
 102                     'query'             => isset($mappingElement['query']) ? $mappingElement['query'] : null,
 103                     'resultClass'       => isset($mappingElement['resultClass']) ? $mappingElement['resultClass'] : null,
 104                     'resultSetMapping'  => isset($mappingElement['resultSetMapping']) ? $mappingElement['resultSetMapping'] : null,
 105                 ));
 106             }
 107         }
 108
 109         // Evaluate sql result set mappings
 110         if (isset($element['sqlResultSetMappings'])) {
 111             foreach ($element['sqlResultSetMappings'] as $name => $resultSetMapping) {
 112                 if (!isset($resultSetMapping['name'])) {
 113                     $resultSetMapping['name'] = $name;
 114                 }
 115
 116                 $entities = array();
 117                 $columns  = array();
 118                 if (isset($resultSetMapping['entityResult'])) {
 119                     foreach ($resultSetMapping['entityResult'] as $entityResultElement) {
 120                         $entityResult = array(
 121                             'fields'                => array(),
 122                             'entityClass'           => isset($entityResultElement['entityClass']) ? $entityResultElement['entityClass'] : null,
 123                             'discriminatorColumn'   => isset($entityResultElement['discriminatorColumn']) ? $entityResultElement['discriminatorColumn'] : null,
 124                         );
 125
 126                         if (isset($entityResultElement['fieldResult'])) {
 127                             foreach ($entityResultElement['fieldResult'] as $fieldResultElement) {
 128                                 $entityResult['fields'][] = array(
 129                                     'name'      => isset($fieldResultElement['name']) ? $fieldResultElement['name'] : null,
 130                                     'column'    => isset($fieldResultElement['column']) ? $fieldResultElement['column'] : null,
 131                                 );
 132                             }
 133                         }
 134
 135                         $entities[] = $entityResult;
 136                     }
 137                 }
 138
 139
 140                 if (isset($resultSetMapping['columnResult'])) {
 141                     foreach ($resultSetMapping['columnResult'] as $columnResultAnnot) {
 142                         $columns[] = array(
 143                             'name' => isset($columnResultAnnot['name']) ? $columnResultAnnot['name'] : null,
 144                         );
 145                     }
 146                 }
 147
 148                 $metadata->addSqlResultSetMapping(array(
 149                     'name'          => $resultSetMapping['name'],
 150                     'entities'      => $entities,
 151                     'columns'       => $columns
 152                 ));
 153             }
 154         }
 155
 156         /* not implemented specially anyway. use table = schema.table
 157         if (isset($element['schema'])) {
 158             $metadata->table['schema'] = $element['schema'];
 159         }*/
 160
 161         if (isset($element['inheritanceType'])) {
 162             $metadata->setInheritanceType(constant('Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_' . strtoupper($element['inheritanceType'])));
 163
 164             if ($metadata->inheritanceType != \Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_NONE) {
 165                 // Evaluate discriminatorColumn
 166                 if (isset($element['discriminatorColumn'])) {
 167                     $discrColumn = $element['discriminatorColumn'];
 168                     $metadata->setDiscriminatorColumn(array(
 169                         'name' => isset($discrColumn['name']) ? (string)$discrColumn['name'] : null,
 170                         'type' => isset($discrColumn['type']) ? (string)$discrColumn['type'] : null,
 171                         'length' => isset($discrColumn['length']) ? (string)$discrColumn['length'] : null,
 172                         'columnDefinition' => isset($discrColumn['columnDefinition']) ? (string)$discrColumn['columnDefinition'] : null
 173                     ));
 174                 } else {
 175                     $metadata->setDiscriminatorColumn(array('name' => 'dtype', 'type' => 'string', 'length' => 255));
 176                 }
 177
 178                 // Evaluate discriminatorMap
 179                 if (isset($element['discriminatorMap'])) {
 180                     $metadata->setDiscriminatorMap($element['discriminatorMap']);
 181                 }
 182             }
 183         }
 184
 185
 186         // Evaluate changeTrackingPolicy
 187         if (isset($element['changeTrackingPolicy'])) {
 188             $metadata->setChangeTrackingPolicy(constant('Doctrine\ORM\Mapping\ClassMetadata::CHANGETRACKING_'
 189                     . strtoupper($element['changeTrackingPolicy'])));
 190         }
 191
 192         // Evaluate indexes
 193         if (isset($element['indexes'])) {
 194             foreach ($element['indexes'] as $name => $index) {
 195                 if ( ! isset($index['name'])) {
 196                     $index['name'] = $name;
 197                 }
 198
 199                 if (is_string($index['columns'])) {
 200                     $columns = explode(',', $index['columns']);
 201                 } else {
 202                     $columns = $index['columns'];
 203                 }
 204
 205                 $metadata->table['indexes'][$index['name']] = array(
 206                     'columns' => $columns
 207                 );
 208             }
 209         }
 210
 211         // Evaluate uniqueConstraints
 212         if (isset($element['uniqueConstraints'])) {
 213             foreach ($element['uniqueConstraints'] as $name => $unique) {
 214                 if ( ! isset($unique['name'])) {
 215                     $unique['name'] = $name;
 216                 }
 217
 218                 if (is_string($unique['columns'])) {
 219                     $columns = explode(',', $unique['columns']);
 220                 } else {
 221                     $columns = $unique['columns'];
 222                 }
 223
 224                 $metadata->table['uniqueConstraints'][$unique['name']] = array(
 225                     'columns' => $columns
 226                 );
 227             }
 228         }
 229
 230         if (isset($element['options'])) {
 231             $metadata->table['options'] = $element['options'];
 232         }
 233
 234         $associationIds = array();
 235         if (isset($element['id'])) {
 236             // Evaluate identifier settings
 237             foreach ($element['id'] as $name => $idElement) {
 238                 if (isset($idElement['associationKey']) && $idElement['associationKey'] == true) {
 239                     $associationIds[$name] = true;
 240                     continue;
 241                 }
 242
 243                 $mapping = array(
 244                     'id' => true,
 245                     'fieldName' => $name
 246                 );
 247
 248                 if (isset($idElement['type'])) {
 249                     $mapping['type'] = $idElement['type'];
 250                 }
 251
 252                 if (isset($idElement['column'])) {
 253                     $mapping['columnName'] = $idElement['column'];
 254                 }
 255
 256                 if (isset($idElement['length'])) {
 257                     $mapping['length'] = $idElement['length'];
 258                 }
 259
 260                 if (isset($idElement['columnDefinition'])) {
 261                     $mapping['columnDefinition'] = $idElement['columnDefinition'];
 262                 }
 263
 264                 $metadata->mapField($mapping);
 265
 266                 if (isset($idElement['generator'])) {
 267                     $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_'
 268                             . strtoupper($idElement['generator']['strategy'])));
 269                 }
 270                 // Check for SequenceGenerator/TableGenerator definition
 271                 if (isset($idElement['sequenceGenerator'])) {
 272                     $metadata->setSequenceGeneratorDefinition($idElement['sequenceGenerator']);
 273                 } else if (isset($idElement['customIdGenerator'])) {
 274                     $customGenerator = $idElement['customIdGenerator'];
 275                     $metadata->setCustomGeneratorDefinition(array(
 276                         'class' => (string) $customGenerator['class']
 277                     ));
 278                 } else if (isset($idElement['tableGenerator'])) {
 279                     throw MappingException::tableIdGeneratorNotImplemented($className);
 280                 }
 281             }
 282         }
 283
 284         // Evaluate fields
 285         if (isset($element['fields'])) {
 286             foreach ($element['fields'] as $name => $fieldMapping) {
 287
 288                 $mapping = $this->columnToArray($name, $fieldMapping);
 289
 290                 if (isset($fieldMapping['id'])) {
 291                     $mapping['id'] = true;
 292                     if (isset($fieldMapping['generator']['strategy'])) {
 293                         $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_'
 294                                 . strtoupper($fieldMapping['generator']['strategy'])));
 295                     }
 296                 }
 297
 298                 $metadata->mapField($mapping);
 299             }
 300         }
 301
 302         // Evaluate oneToOne relationships
 303         if (isset($element['oneToOne'])) {
 304             foreach ($element['oneToOne'] as $name => $oneToOneElement) {
 305                 $mapping = array(
 306                     'fieldName' => $name,
 307                     'targetEntity' => $oneToOneElement['targetEntity']
 308                 );
 309
 310                 if (isset($associationIds[$mapping['fieldName']])) {
 311                     $mapping['id'] = true;
 312                 }
 313
 314                 if (isset($oneToOneElement['fetch'])) {
 315                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $oneToOneElement['fetch']);
 316                 }
 317
 318                 if (isset($oneToOneElement['mappedBy'])) {
 319                     $mapping['mappedBy'] = $oneToOneElement['mappedBy'];
 320                 } else {
 321                     if (isset($oneToOneElement['inversedBy'])) {
 322                         $mapping['inversedBy'] = $oneToOneElement['inversedBy'];
 323                     }
 324
 325                     $joinColumns = array();
 326
 327                     if (isset($oneToOneElement['joinColumn'])) {
 328                         $joinColumns[] = $this->joinColumnToArray($oneToOneElement['joinColumn']);
 329                     } else if (isset($oneToOneElement['joinColumns'])) {
 330                         foreach ($oneToOneElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
 331                             if ( ! isset($joinColumnElement['name'])) {
 332                                 $joinColumnElement['name'] = $joinColumnName;
 333                             }
 334
 335                             $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
 336                         }
 337                     }
 338
 339                     $mapping['joinColumns'] = $joinColumns;
 340                 }
 341
 342                 if (isset($oneToOneElement['cascade'])) {
 343                     $mapping['cascade'] = $oneToOneElement['cascade'];
 344                 }
 345
 346                 if (isset($oneToOneElement['orphanRemoval'])) {
 347                     $mapping['orphanRemoval'] = (bool)$oneToOneElement['orphanRemoval'];
 348                 }
 349
 350                 $metadata->mapOneToOne($mapping);
 351             }
 352         }
 353
 354         // Evaluate oneToMany relationships
 355         if (isset($element['oneToMany'])) {
 356             foreach ($element['oneToMany'] as $name => $oneToManyElement) {
 357                 $mapping = array(
 358                     'fieldName' => $name,
 359                     'targetEntity' => $oneToManyElement['targetEntity'],
 360                     'mappedBy' => $oneToManyElement['mappedBy']
 361                 );
 362
 363                 if (isset($oneToManyElement['fetch'])) {
 364                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $oneToManyElement['fetch']);
 365                 }
 366
 367                 if (isset($oneToManyElement['cascade'])) {
 368                     $mapping['cascade'] = $oneToManyElement['cascade'];
 369                 }
 370
 371                 if (isset($oneToManyElement['orphanRemoval'])) {
 372                     $mapping['orphanRemoval'] = (bool)$oneToManyElement['orphanRemoval'];
 373                 }
 374
 375                 if (isset($oneToManyElement['orderBy'])) {
 376                     $mapping['orderBy'] = $oneToManyElement['orderBy'];
 377                 }
 378
 379                 if (isset($oneToManyElement['indexBy'])) {
 380                     $mapping['indexBy'] = $oneToManyElement['indexBy'];
 381                 }
 382
 383                 $metadata->mapOneToMany($mapping);
 384             }
 385         }
 386
 387         // Evaluate manyToOne relationships
 388         if (isset($element['manyToOne'])) {
 389             foreach ($element['manyToOne'] as $name => $manyToOneElement) {
 390                 $mapping = array(
 391                     'fieldName' => $name,
 392                     'targetEntity' => $manyToOneElement['targetEntity']
 393                 );
 394
 395                 if (isset($associationIds[$mapping['fieldName']])) {
 396                     $mapping['id'] = true;
 397                 }
 398
 399                 if (isset($manyToOneElement['fetch'])) {
 400                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $manyToOneElement['fetch']);
 401                 }
 402
 403                 if (isset($manyToOneElement['inversedBy'])) {
 404                     $mapping['inversedBy'] = $manyToOneElement['inversedBy'];
 405                 }
 406
 407                 $joinColumns = array();
 408
 409                 if (isset($manyToOneElement['joinColumn'])) {
 410                     $joinColumns[] = $this->joinColumnToArray($manyToOneElement['joinColumn']);
 411                 } else if (isset($manyToOneElement['joinColumns'])) {
 412                     foreach ($manyToOneElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
 413                         if ( ! isset($joinColumnElement['name'])) {
 414                             $joinColumnElement['name'] = $joinColumnName;
 415                         }
 416
 417                         $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
 418                     }
 419                 }
 420
 421                 $mapping['joinColumns'] = $joinColumns;
 422
 423                 if (isset($manyToOneElement['cascade'])) {
 424                     $mapping['cascade'] = $manyToOneElement['cascade'];
 425                 }
 426
 427                 $metadata->mapManyToOne($mapping);
 428             }
 429         }
 430
 431         // Evaluate manyToMany relationships
 432         if (isset($element['manyToMany'])) {
 433             foreach ($element['manyToMany'] as $name => $manyToManyElement) {
 434                 $mapping = array(
 435                     'fieldName' => $name,
 436                     'targetEntity' => $manyToManyElement['targetEntity']
 437                 );
 438
 439                 if (isset($manyToManyElement['fetch'])) {
 440                     $mapping['fetch'] = constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $manyToManyElement['fetch']);
 441                 }
 442
 443                 if (isset($manyToManyElement['mappedBy'])) {
 444                     $mapping['mappedBy'] = $manyToManyElement['mappedBy'];
 445                 } else if (isset($manyToManyElement['joinTable'])) {
 446
 447                     $joinTableElement = $manyToManyElement['joinTable'];
 448                     $joinTable = array(
 449                         'name' => $joinTableElement['name']
 450                     );
 451
 452                     if (isset($joinTableElement['schema'])) {
 453                         $joinTable['schema'] = $joinTableElement['schema'];
 454                     }
 455
 456                     foreach ($joinTableElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
 457                         if ( ! isset($joinColumnElement['name'])) {
 458                             $joinColumnElement['name'] = $joinColumnName;
 459                         }
 460
 461                         $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
 462                     }
 463
 464                     foreach ($joinTableElement['inverseJoinColumns'] as $joinColumnName => $joinColumnElement) {
 465                         if ( ! isset($joinColumnElement['name'])) {
 466                             $joinColumnElement['name'] = $joinColumnName;
 467                         }
 468
 469                         $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
 470                     }
 471
 472                     $mapping['joinTable'] = $joinTable;
 473                 }
 474
 475                 if (isset($manyToManyElement['inversedBy'])) {
 476                     $mapping['inversedBy'] = $manyToManyElement['inversedBy'];
 477                 }
 478
 479                 if (isset($manyToManyElement['cascade'])) {
 480                     $mapping['cascade'] = $manyToManyElement['cascade'];
 481                 }
 482
 483                 if (isset($manyToManyElement['orderBy'])) {
 484                     $mapping['orderBy'] = $manyToManyElement['orderBy'];
 485                 }
 486
 487                 if (isset($manyToManyElement['indexBy'])) {
 488                     $mapping['indexBy'] = $manyToManyElement['indexBy'];
 489                 }
 490
 491                 if (isset($manyToManyElement['orphanRemoval'])) {
 492                     $mapping['orphanRemoval'] = (bool)$manyToManyElement['orphanRemoval'];
 493                 }
 494
 495                 $metadata->mapManyToMany($mapping);
 496             }
 497         }
 498
 499         // Evaluate associationOverride
 500         if (isset($element['associationOverride']) && is_array($element['associationOverride'])) {
 501
 502             foreach ($element['associationOverride'] as $fieldName => $associationOverrideElement) {
 503                 $override   = array();
 504
 505                 // Check for joinColumn
 506                 if (isset($associationOverrideElement['joinColumn'])) {
 507                     $joinColumns = array();
 508                     foreach ($associationOverrideElement['joinColumn'] as $name => $joinColumnElement) {
 509                         if ( ! isset($joinColumnElement['name'])) {
 510                             $joinColumnElement['name'] = $name;
 511                         }
 512                         $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
 513                     }
 514                     $override['joinColumns'] = $joinColumns;
 515                 }
 516
 517                 // Check for joinTable
 518                 if (isset($associationOverrideElement['joinTable'])) {
 519
 520                     $joinTableElement   = $associationOverrideElement['joinTable'];
 521                     $joinTable          =  array(
 522                         'name' => $joinTableElement['name']
 523                     );
 524
 525                     if (isset($joinTableElement['schema'])) {
 526                         $joinTable['schema'] = $joinTableElement['schema'];
 527                     }
 528
 529                     foreach ($joinTableElement['joinColumns'] as $name => $joinColumnElement) {
 530                         if ( ! isset($joinColumnElement['name'])) {
 531                             $joinColumnElement['name'] = $name;
 532                         }
 533
 534                         $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
 535                     }
 536
 537                     foreach ($joinTableElement['inverseJoinColumns'] as $name => $joinColumnElement) {
 538                         if ( ! isset($joinColumnElement['name'])) {
 539                             $joinColumnElement['name'] = $name;
 540                         }
 541
 542                         $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
 543                     }
 544
 545                     $override['joinTable'] = $joinTable;
 546                 }
 547
 548                 $metadata->setAssociationOverride($fieldName, $override);
 549             }
 550         }
 551
 552         // Evaluate associationOverride
 553         if (isset($element['attributeOverride']) && is_array($element['attributeOverride'])) {
 554
 555             foreach ($element['attributeOverride'] as $fieldName => $attributeOverrideElement) {
 556                 $mapping = $this->columnToArray($fieldName, $attributeOverrideElement);
 557                 $metadata->setAttributeOverride($fieldName, $mapping);
 558             }
 559         }
 560
 561         // Evaluate lifeCycleCallbacks
 562         if (isset($element['lifecycleCallbacks'])) {
 563             foreach ($element['lifecycleCallbacks'] as $type => $methods) {
 564                 foreach ($methods as $method) {
 565                     $metadata->addLifecycleCallback($method, constant('Doctrine\ORM\Events::' . $type));
 566                 }
 567             }
 568         }
 569     }
 570
 571     /**
 572      * Constructs a joinColumn mapping array based on the information
 573      * found in the given join column element.
 574      *
 575      * @param array $joinColumnElement The array join column element
 576      * @return array The mapping array.
 577      */
 578     private function joinColumnToArray($joinColumnElement)
 579     {
 580         $joinColumn = array();
 581         if (isset($joinColumnElement['referencedColumnName'])) {
 582             $joinColumn['referencedColumnName'] = (string) $joinColumnElement['referencedColumnName'];
 583         }
 584
 585         if (isset($joinColumnElement['name'])) {
 586             $joinColumn['name'] = (string) $joinColumnElement['name'];
 587         }
 588
 589         if (isset($joinColumnElement['fieldName'])) {
 590             $joinColumn['fieldName'] = (string) $joinColumnElement['fieldName'];
 591         }
 592
 593         if (isset($joinColumnElement['unique'])) {
 594             $joinColumn['unique'] = (bool) $joinColumnElement['unique'];
 595         }
 596
 597         if (isset($joinColumnElement['nullable'])) {
 598             $joinColumn['nullable'] = (bool) $joinColumnElement['nullable'];
 599         }
 600
 601         if (isset($joinColumnElement['onDelete'])) {
 602             $joinColumn['onDelete'] = $joinColumnElement['onDelete'];
 603         }
 604
 605         if (isset($joinColumnElement['columnDefinition'])) {
 606             $joinColumn['columnDefinition'] = $joinColumnElement['columnDefinition'];
 607         }
 608
 609         return $joinColumn;
 610     }
 611
 612     /**
 613      * Parse the given column as array
 614      *
 615      * @param   string  $fieldName
 616      * @param   array   $column
 617      * @return  array
 618      */
 619     private function columnToArray($fieldName, $column)
 620     {
 621         $mapping = array(
 622             'fieldName' => $fieldName
 623         );
 624
 625         if (isset($column['type'])) {
 626             $params = explode('(', $column['type']);
 627             $column['type']  = $params[0];
 628             $mapping['type'] = $column['type'];
 629
 630             if (isset($params[1])) {
 631                 $column['length'] = substr($params[1], 0, strlen($params[1]) - 1);
 632             }
 633         }
 634
 635         if (isset($column['column'])) {
 636             $mapping['columnName'] = $column['column'];
 637         }
 638
 639         if (isset($column['length'])) {
 640             $mapping['length'] = $column['length'];
 641         }
 642
 643         if (isset($column['precision'])) {
 644             $mapping['precision'] = $column['precision'];
 645         }
 646
 647         if (isset($column['scale'])) {
 648             $mapping['scale'] = $column['scale'];
 649         }
 650
 651         if (isset($column['unique'])) {
 652             $mapping['unique'] = (bool)$column['unique'];
 653         }
 654
 655         if (isset($column['options'])) {
 656             $mapping['options'] = $column['options'];
 657         }
 658
 659         if (isset($column['nullable'])) {
 660             $mapping['nullable'] = $column['nullable'];
 661         }
 662
 663         if (isset($column['version']) && $column['version']) {
 664             $mapping['version'] = $column['version'];
 665         }
 666
 667         if (isset($column['columnDefinition'])) {
 668             $mapping['columnDefinition'] = $column['columnDefinition'];
 669         }
 670
 671         return $mapping;
 672     }
 673
 674     /**
 675      * {@inheritDoc}
 676      */
 677     protected function loadMappingFile($file)
 678     {
 679         return Yaml::parse($file);
 680     }
 681 }