Doctrine

Timestamp:

07/08/09 11:25:41 (14 months ago)

Author:

romanb

Message:

[2.0] Migrated AnnotationDriver? to new annotation parser. Removed addendum vendor library.

Location:

trunk

Files:

• lib/Doctrine/Common/Annotations/Lexer.php (modified) (1 diff)
• lib/Doctrine/Common/Annotations/Parser.php (modified) (8 diffs)
• lib/Doctrine/ORM/Mapping/Driver/AnnotationDriver.php (modified) (11 diffs)
• lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php (modified) (9 diffs)
• lib/vendor/addendum (deleted)
• tests/Doctrine/Tests/Common/Annotations/AnnotationReaderTest.php (modified) (2 diffs)
• tests/Doctrine/Tests/Common/Annotations/ParserTest.php (modified) (1 diff)
• tests/Doctrine/Tests/Models/CMS/CmsUser.php (modified) (1 diff)
• tests/Doctrine/Tests/Models/Company/CompanyPerson.php (modified) (1 diff)
• tests/Doctrine/Tests/Models/ECommerce/ECommerceCart.php (modified) (1 diff)
• tests/Doctrine/Tests/Models/ECommerce/ECommerceProduct.php (modified) (2 diffs)

trunk/lib/Doctrine/Common/Annotations/Lexer.php

@@ -38 +38 @@
     const T_STRING = 4;
     const T_IDENTIFIER = 5;
+    const T_TRUE = 6;
+    const T_FALSE = 7;
 
     /**

trunk/lib/Doctrine/Common/Annotations/Parser.php

@@ -1 +1 @@
 <?php
+/*
+ *  $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
 
 namespace Doctrine\Common\Annotations;
@@ -70 +89 @@
         $this->_lexer->moveNext();
         
-        return $this->Annotations();
+        if ($this->_lexer->isNextToken('@')) {
+            return $this->Annotations();
+        }
+        return array();
     }
 
@@ -91 +113 @@
 
         if ( ! $isMatch) {
-            $this->syntaxError($token['value']);
+            $this->syntaxError($token['value'], $this->_lexer->lookahead['value']);
         }
 
@@ -103 +125 @@
      * @throws Exception
      */
-    private function syntaxError($expected)
-    {
-        throw new \Exception("Expected: $expected.");
+    private function syntaxError($expected, $got = "")
+    {
+        throw new \Exception("Expected: $expected. Got: $got");
     }
     
@@ -176 +198 @@
         if ( ! $this->_isNestedAnnotation && $this->_lexer->lookahead != null
                 && $this->_lexer->lookahead['value'] != '('
+                && $this->_lexer->lookahead['value'] != '@'
                 || ! is_subclass_of($name, 'Doctrine\Common\Annotations\Annotation')) {
             return false;
@@ -203 +226 @@
 
         $value = $this->Value();
-        if (is_array($value)) {
-            $k = key($value);
-            $v = $value[$k];
-            if (is_string($k)) {
-                // FieldAssignment
-                $values[$k] = $v;
-            } else {
-                $values['value'][] = $value;
-            }
-        } else {
-            $values['value'][] = $value;
-        }
-
-        while ($this->_lexer->isNextToken(',')) {
-            $this->match(',');
-            $value = $this->Value();
+        
+        if ($this->_lexer->isNextToken(')')) {
+            // Single value
             if (is_array($value)) {
                 $k = key($value);
@@ -226 +236 @@
                     $values[$k] = $v;
                 } else {
-                    $values['value'][] = $value;
+                    $values['value']= $value;
                 }
             } else {
-                $values['value'][] = $value;
-            }
+                $values['value'] = $value;
+            }
+            return $values;
+        } else {
+            // FieldAssignment
+            $k = key($value);
+            $v = $value[$k];
+            $values[$k] = $v;
+        }
+
+        while ($this->_lexer->isNextToken(',')) {
+            $this->match(',');
+            $value = $this->Value();
+            
+            if ( ! is_array($value)) {
+                $this->syntaxError('FieldAssignment', $value);
+            }
+            
+            $k = key($value);
+            $v = $value[$k];
+            $values[$k] = $v;
         }
 
@@ -270 +299 @@
                 $this->match(Lexer::T_FLOAT);
                 return $this->_lexer->token['value'];
+            case Lexer::T_TRUE:
+                $this->match(Lexer::T_TRUE);
+                return true;
+            case Lexer::T_FALSE:
+                $this->match(Lexer::T_FALSE);
+                return false;
             default:
                 var_dump($this->_lexer->lookahead);

trunk/lib/Doctrine/ORM/Mapping/Driver/AnnotationDriver.php

@@ -23 +23 @@
 
 use Doctrine\Common\DoctrineException;
+use Doctrine\Common\Cache\ArrayCache;
+use Doctrine\Common\Annotations\AnnotationReader;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\MappingException;
 
-/* Addendum annotation reflection extensions */
-if ( ! class_exists('Addendum', false)) {
-    require __DIR__ . '/../../../../vendor/addendum/annotations.php';
-}
 require __DIR__ . '/DoctrineAnnotations.php';
 
 /**
- * The AnnotationDriver reads the mapping metadata from docblock annotations
- * with the help of the Addendum reflection extensions.
+ * The AnnotationDriver reads the mapping metadata from docblock annotations.
  *
  * @author Roman Borschel <roman@code-factory.org>
@@ -46 +43 @@
     public function loadMetadataForClass($className, ClassMetadata $metadata)
     {
-        $annotClass = new \ReflectionAnnotatedClass($className);
+        $reader = new AnnotationReader(new ArrayCache);
+        $class = $metadata->getReflectionClass();
 
         // Evaluate DoctrineEntity annotation
-        if (($entityAnnot = $annotClass->getAnnotation('Entity')) === false) {
+        if (($entityAnnot = $reader->getClassAnnotation($class, 'Entity')) === null) {
             throw DoctrineException::updateMe("$className is no entity.");
         }
@@ -55 +53 @@
 
         // Evaluate DoctrineTable annotation
-        if ($tableAnnot = $annotClass->getAnnotation('Table')) {
+        if ($tableAnnot = $reader->getClassAnnotation($class, 'Table')) {
             $metadata->setPrimaryTable(array(
                 'name' => $tableAnnot->name,
@@ -63 +61 @@
 
         // Evaluate InheritanceType annotation
-        if ($inheritanceTypeAnnot = $annotClass->getAnnotation('InheritanceType')) {
+        if ($inheritanceTypeAnnot = $reader->getClassAnnotation($class, 'InheritanceType')) {
             $metadata->setInheritanceType(constant('\Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_' . $inheritanceTypeAnnot->value));
         }
 
         // Evaluate DiscriminatorColumn annotation
-        if ($discrColumnAnnot = $annotClass->getAnnotation('DiscriminatorColumn')) {
+        if ($discrColumnAnnot = $reader->getClassAnnotation($class, 'DiscriminatorColumn')) {
             $metadata->setDiscriminatorColumn(array(
                 'name' => $discrColumnAnnot->name,
@@ -77 +75 @@
 
         // Evaluate DiscriminatorValue annotation
-        if ($discrValueAnnot = $annotClass->getAnnotation('DiscriminatorValue')) {
+        if ($discrValueAnnot = $reader->getClassAnnotation($class, 'DiscriminatorValue')) {
             $metadata->setDiscriminatorValue($discrValueAnnot->value);
         }
 
         // Evaluate DoctrineSubClasses annotation
-        if ($subClassesAnnot = $annotClass->getAnnotation('SubClasses')) {
+        if ($subClassesAnnot = $reader->getClassAnnotation($class, 'SubClasses')) {
             $metadata->setSubclasses($subClassesAnnot->value);
         }
 
         // Evaluate DoctrineChangeTrackingPolicy annotation
-        if ($changeTrackingAnnot = $annotClass->getAnnotation('ChangeTrackingPolicy')) {
+        if ($changeTrackingAnnot = $reader->getClassAnnotation($class, 'ChangeTrackingPolicy')) {
             $metadata->setChangeTrackingPolicy($changeTrackingAnnot->value);
         }
 
         // Evaluate annotations on properties/fields
-        foreach ($annotClass->getProperties() as $property) {
+        foreach ($class->getProperties() as $property) {
             if ($metadata->hasField($property->getName())) {
                 continue;
@@ -102 +100 @@
             // Check for JoinColummn/JoinColumns annotations
             $joinColumns = array();
-            if ($joinColumnAnnot = $property->getAnnotation('JoinColumn')) {
+            if ($joinColumnAnnot = $reader->getPropertyAnnotation($property, 'JoinColumn')) {
                 $joinColumns[] = array(
                     'name' => $joinColumnAnnot->name,
@@ -111 +109 @@
                     'onUpdate' => $joinColumnAnnot->onUpdate
                 );
-            } else if ($joinColumnsAnnot = $property->getAnnotation('JoinColumns')) {
-                $joinColumns = $joinColumnsAnnot->value;
+            } else if ($joinColumnsAnnot = $reader->getPropertyAnnotation($property, 'JoinColumns')) {
+                foreach ($joinColumnsAnnot->value as $joinColumn) {
+                    //$joinColumns = $joinColumnsAnnot->value;
+                    $joinColumns[] = array(
+                        'name' => $joinColumn->name,
+                        'referencedColumnName' => $joinColumn->referencedColumnName,
+                        'unique' => $joinColumn->unique,
+                        'nullable' => $joinColumn->nullable,
+                        'onDelete' => $joinColumn->onDelete,
+                        'onUpdate' => $joinColumn->onUpdate
+                    );
+                }
             }
 
             // Field can only be annotated with one of:
             // @Column, @OneToOne, @OneToMany, @ManyToOne, @ManyToMany
-            if ($columnAnnot = $property->getAnnotation('Column')) {
+            if ($columnAnnot = $reader->getPropertyAnnotation($property, 'Column')) {
                 if ($columnAnnot->type == null) {
                     throw DoctrineException::updateMe("Missing type on property " . $property->getName());
@@ -127 +135 @@
                     $mapping['columnName'] = $columnAnnot->name;
                 }
-                if ($idAnnot = $property->getAnnotation('Id')) {
+                if ($idAnnot = $reader->getPropertyAnnotation($property, 'Id')) {
                     $mapping['id'] = true;
                 }
-                if ($generatedValueAnnot = $property->getAnnotation('GeneratedValue')) {
+                if ($generatedValueAnnot = $reader->getPropertyAnnotation($property, 'GeneratedValue')) {
                     $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_' . $generatedValueAnnot->strategy));
                 }
@@ -136 +144 @@
 
                 // Check for SequenceGenerator/TableGenerator definition
-                if ($seqGeneratorAnnot = $property->getAnnotation('SequenceGenerator')) {
+                if ($seqGeneratorAnnot = $reader->getPropertyAnnotation($property, 'SequenceGenerator')) {
                     $metadata->setSequenceGeneratorDefinition(array(
                         'sequenceName' => $seqGeneratorAnnot->sequenceName,
@@ -142 +150 @@
                         'initialValue' => $seqGeneratorAnnot->initialValue
                     ));
-                } else if ($tblGeneratorAnnot = $property->getAnnotation('TableGenerator')) {
+                } else if ($tblGeneratorAnnot = $reader->getPropertyAnnotation($property, 'TableGenerator')) {
                     throw new DoctrineException("DoctrineTableGenerator not yet implemented.");
                 }
                 
-            } else if ($oneToOneAnnot = $property->getAnnotation('OneToOne')) {
+            } else if ($oneToOneAnnot = $reader->getPropertyAnnotation($property, 'OneToOne')) {
                 $mapping['targetEntity'] = $oneToOneAnnot->targetEntity;
                 $mapping['joinColumns'] = $joinColumns;
@@ -152 +160 @@
                 $mapping['cascade'] = $oneToOneAnnot->cascade;
                 $metadata->mapOneToOne($mapping);
-            } else if ($oneToManyAnnot = $property->getAnnotation('OneToMany')) {
+            } else if ($oneToManyAnnot = $reader->getPropertyAnnotation($property, 'OneToMany')) {
                 $mapping['mappedBy'] = $oneToManyAnnot->mappedBy;
                 $mapping['targetEntity'] = $oneToManyAnnot->targetEntity;
                 $mapping['cascade'] = $oneToManyAnnot->cascade;
                 $metadata->mapOneToMany($mapping);
-            } else if ($manyToOneAnnot = $property->getAnnotation('ManyToOne')) {
+            } else if ($manyToOneAnnot = $reader->getPropertyAnnotation($property, 'ManyToOne')) {
                 $mapping['joinColumns'] = $joinColumns;
                 $mapping['cascade'] = $manyToOneAnnot->cascade;
                 $mapping['targetEntity'] = $manyToOneAnnot->targetEntity;
                 $metadata->mapManyToOne($mapping);
-            } else if ($manyToManyAnnot = $property->getAnnotation('ManyToMany')) {
+            } else if ($manyToManyAnnot = $reader->getPropertyAnnotation($property, 'ManyToMany')) {
                 $joinTable = array();
-                if ($joinTableAnnot = $property->getAnnotation('JoinTable')) {
+                if ($joinTableAnnot = $reader->getPropertyAnnotation($property, 'JoinTable')) {
                     $joinTable = array(
                         'name' => $joinTableAnnot->name,
                         'schema' => $joinTableAnnot->schema,
-                        'joinColumns' => $joinTableAnnot->joinColumns,
-                        'inverseJoinColumns' => $joinTableAnnot->inverseJoinColumns
+                        //'joinColumns' => $joinTableAnnot->joinColumns,
+                        //'inverseJoinColumns' => $joinTableAnnot->inverseJoinColumns
                     );
-                }
+                    
+                    foreach ($joinTableAnnot->joinColumns as $joinColumn) {
+                        $joinTable['joinColumns'][] = array(
+                            'name' => $joinColumn->name,
+                            'referencedColumnName' => $joinColumn->referencedColumnName,
+                            'unique' => $joinColumn->unique,
+                            'nullable' => $joinColumn->nullable,
+                            'onDelete' => $joinColumn->onDelete,
+                            'onUpdate' => $joinColumn->onUpdate
+                        );
+                    }
+
+                    foreach ($joinTableAnnot->inverseJoinColumns as $joinColumn) {
+                        $joinTable['inverseJoinColumns'][] = array(
+                            'name' => $joinColumn->name,
+                            'referencedColumnName' => $joinColumn->referencedColumnName,
+                            'unique' => $joinColumn->unique,
+                            'nullable' => $joinColumn->nullable,
+                            'onDelete' => $joinColumn->onDelete,
+                            'onUpdate' => $joinColumn->onUpdate
+                        );
+                    }
+                }
+                
                 $mapping['joinTable'] = $joinTable;
                 $mapping['targetEntity'] = $manyToManyAnnot->targetEntity;

trunk/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php

@@ -22 +22 @@
 /* Annotations */
 
-final class Entity extends \Annotation {
+final class Entity extends \Doctrine\Common\Annotations\Annotation {
     public $repositoryClass;
 }
-final class InheritanceType extends \Annotation {}
-final class DiscriminatorColumn extends \Annotation {
+final class InheritanceType extends \Doctrine\Common\Annotations\Annotation {}
+final class DiscriminatorColumn extends \Doctrine\Common\Annotations\Annotation {
     public $name;
     public $type;
     public $length;
 }
-//final class DiscriminatorMap extends \Annotation {}
-final class DiscriminatorValue extends \Annotation {}
-final class SubClasses extends \Annotation {}
-final class Id extends \Annotation {}
-final class GeneratedValue extends \Annotation {
+final class DiscriminatorValue extends \Doctrine\Common\Annotations\Annotation {}
+final class SubClasses extends \Doctrine\Common\Annotations\Annotation {}
+final class Id extends \Doctrine\Common\Annotations\Annotation {}
+final class GeneratedValue extends \Doctrine\Common\Annotations\Annotation {
     public $strategy;
     //public $generator;
 }
-final class Version extends \Annotation {}
-final class JoinColumn extends \Annotation {
+final class Version extends \Doctrine\Common\Annotations\Annotation {}
+final class JoinColumn extends \Doctrine\Common\Annotations\Annotation {
     public $name;
     public $referencedColumnName;
@@ -48 +47 @@
     public $onUpdate;
 }
-final class JoinColumns extends \Annotation {}
-final class Column extends \Annotation {
+final class JoinColumns extends \Doctrine\Common\Annotations\Annotation {}
+final class Column extends \Doctrine\Common\Annotations\Annotation {
     public $type;
     public $length;
@@ -56 +55 @@
     public $name;
 }
-final class OneToOne extends \Annotation {
+final class OneToOne extends \Doctrine\Common\Annotations\Annotation {
     public $targetEntity;
     public $mappedBy;
@@ -63 +62 @@
     public $optional;
 }
-final class OneToMany extends \Annotation {
+final class OneToMany extends \Doctrine\Common\Annotations\Annotation {
     public $mappedBy;
     public $targetEntity;
@@ -69 +68 @@
     public $fetch;
 }
-final class ManyToOne extends \Annotation {
+final class ManyToOne extends \Doctrine\Common\Annotations\Annotation {
     public $targetEntity;
     public $cascade;
@@ -75 +74 @@
     public $optional;
 }
-final class ManyToMany extends \Annotation {
+final class ManyToMany extends \Doctrine\Common\Annotations\Annotation {
     public $targetEntity;
     public $mappedBy;
@@ -81 +80 @@
     public $fetch;
 }
-final class ElementCollection extends \Annotation {
+final class ElementCollection extends \Doctrine\Common\Annotations\Annotation {
     public $tableName;
 }
-final class Table extends \Annotation {
+final class Table extends \Doctrine\Common\Annotations\Annotation {
     public $name;
     public $schema;
 }
-final class JoinTable extends \Annotation {
+final class JoinTable extends \Doctrine\Common\Annotations\Annotation {
     public $name;
     public $schema;
@@ -94 +93 @@
     public $inverseJoinColumns;
 }
-final class SequenceGenerator extends \Annotation {
+final class SequenceGenerator extends \Doctrine\Common\Annotations\Annotation {
     //public $name;
     public $sequenceName;
@@ -100 +99 @@
     public $initialValue = 1;
 }
-final class ChangeTrackingPolicy extends \Annotation {}
-final class DoctrineX extends \Annotation {}
+final class ChangeTrackingPolicy extends \Doctrine\Common\Annotations\Annotation {}
+final class DoctrineX extends \Doctrine\Common\Annotations\Annotation {}

trunk/tests/Doctrine/Tests/Common/Annotations/AnnotationReaderTest.php

@@ -32 +32 @@
         $this->assertEquals(1, count($methodAnnots));
         $this->assertTrue($methodAnnots[$annotName] instanceof DummyAnnotation);
-        $this->assertEquals("methodHello", $methodAnnots[$annotName]->dummyValue);
-        $this->assertEquals(array(array(1, 2, "three")), $methodAnnots[$annotName]->value);
+        $this->assertEquals(array(1, 2, "three"), $methodAnnots[$annotName]->value);
         
         $field2Prop = $class->getProperty('field2');
@@ -82 +81 @@
      *
      * @return mixed
-     * @DummyAnnotation({1,2,"three"}, dummyValue="methodHello")
+     * @DummyAnnotation({1,2,"three"})
      */
     public function getField1() {

trunk/tests/Doctrine/Tests/Common/Annotations/ParserTest.php

@@ -29 +29 @@
         
         // Nested arrays with nested annotations
-        $result = $parser->parse('@Name(foo=1, 2, 3, {1,2, {"key"=@Name}})');
+        $result = $parser->parse('@Name(foo={1,2, {"key"=@Name}})');
         $annot = $result['Doctrine\Tests\Common\Annotations\Name'];
-                
+
         $this->assertTrue($annot instanceof Name);
-        $this->assertEquals(3, count($annot->value));
-        $this->assertEquals(1, $annot->foo);
-        $this->assertEquals(2, $annot->value[0]);
-        $this->assertEquals(3, $annot->value[1]);
-        $this->assertTrue(is_array($annot->value[2]));
+        $this->assertNull($annot->value);
+        $this->assertEquals(3, count($annot->foo));
+        $this->assertEquals(1, $annot->foo[0]);
+        $this->assertEquals(2, $annot->foo[1]);
+        $this->assertTrue(is_array($annot->foo[2]));
         
-        $nestedArray = $annot->value[2];
-        $this->assertEquals(3, count($nestedArray));
-        $this->assertEquals(1, $nestedArray[0]);
-        $this->assertEquals(2, $nestedArray[1]);
-        $this->assertTrue(is_array($nestedArray[2]));
-        
-        $nestedArray2 = $nestedArray[2];
-        $this->assertTrue(isset($nestedArray2['key']));
-        $this->assertTrue($nestedArray2['key'] instanceof Name);
+        $nestedArray = $annot->foo[2];
+        $this->assertTrue(isset($nestedArray['key']));
+        $this->assertTrue($nestedArray['key'] instanceof Name);
         
         // Complete docblock

trunk/tests/Doctrine/Tests/Models/CMS/CmsUser.php

@@ -41 +41 @@
      * @ManyToMany(targetEntity="CmsGroup", cascade={"save"})
      * @JoinTable(name="cms_users_groups",
-            joinColumns={{"name"="user_id", "referencedColumnName"="id"}},
-            inverseJoinColumns={{"name"="group_id", "referencedColumnName"="id"}})
+            joinColumns={@JoinColumn(name="user_id", referencedColumnName="id")},
+            inverseJoinColumns={@JoinColumn(name="group_id", referencedColumnName="id")})
      */
     public $groups;

trunk/tests/Doctrine/Tests/Models/Company/CompanyPerson.php

@@ -36 +36 @@
      * @ManyToMany(targetEntity="CompanyPerson")
      * @JoinTable(name="company_persons_friends",
-            joinColumns={{"name"="person_id", "referencedColumnName"="id"}},
-            inverseJoinColumns={{"name"="friend_id", "referencedColumnName"="id"}})
+            joinColumns={@JoinColumn(name="person_id", referencedColumnName="id")},
+            inverseJoinColumns={@JoinColumn(name="friend_id", referencedColumnName="id")})
      */
     private $friends;

trunk/tests/Doctrine/Tests/Models/ECommerce/ECommerceCart.php

@@ -36 +36 @@
      * @ManyToMany(targetEntity="ECommerceProduct", cascade={"save"})
      * @JoinTable(name="ecommerce_carts_products",
-            joinColumns={{"name"="cart_id", "referencedColumnName"="id"}},
-            inverseJoinColumns={{"name"="product_id", "referencedColumnName"="id"}})
+            joinColumns={@JoinColumn(name="cart_id", referencedColumnName="id")},
+            inverseJoinColumns={@JoinColumn(name="product_id", referencedColumnName="id")})
      */
     private $products;

trunk/tests/Doctrine/Tests/Models/ECommerce/ECommerceProduct.php

@@ -41 +41 @@
      * @ManyToMany(targetEntity="ECommerceCategory", cascade={"save"})
      * @JoinTable(name="ecommerce_products_categories",
-            joinColumns={{"name"="product_id", "referencedColumnName"="id"}},
-            inverseJoinColumns={{"name"="category_id", "referencedColumnName"="id"}})
+            joinColumns={@JoinColumn(name="product_id", referencedColumnName="id")},
+            inverseJoinColumns={@JoinColumn(name="category_id", referencedColumnName="id")})
      */
     private $categories;
@@ -51 +51 @@
      * @ManyToMany(targetEntity="ECommerceProduct", cascade={"save"})
      * @JoinTable(name="ecommerce_products_related",
-            joinColumns={{"name"="product_id", "referencedColumnName"="id"}},
-            inverseJoinColumns={{"name"="related_id", "referencedColumnName"="id"}})
+            joinColumns={@JoinColumn(name="product_id", referencedColumnName="id")},
+            inverseJoinColumns={@JoinColumn(name="related_id", referencedColumnName="id")})
      */
     private $related;