Changeset 4866 for trunk/lib/Doctrine

Timestamp:

08/31/08 19:27:16 (4 months ago)

Author:

romanb

Message:

checkin of occasional work from the past weeks.

Location:

trunk/lib/Doctrine

Files:

• Association.php (modified) (5 diffs)
• Association/OneToOne.php (modified) (1 diff)
• Builder/Record.php (modified) (1 diff)
• ClassMetadata.php (modified) (11 diffs)
• Collection.php (modified) (25 diffs)
• Configuration.php (modified) (5 diffs)
• Connection.php (modified) (6 diffs)
• Connection/Mysql.php (modified) (1 diff)
• Connection/Pgsql.php (modified) (3 diffs)
• ConnectionFactory.php (modified) (3 diffs)
• DatabasePlatform.php (modified) (4 diffs)
• DatabasePlatform/MockPlatform.php (added)
• DatabasePlatform/MySqlPlatform.php (modified) (5 diffs)
• DatabasePlatform/PostgreSqlPlatform.php (modified) (1 diff)
• DataType (added)
• DataType.php (added)
• DataType/ArrayType.php (added)
• DataType/BooleanType.php (added)
• DataType/DateTimeType.php (added)
• DataType/DecimalType.php (added)
• DataType/IntegerType.php (added)
• DataType/StringType.php (added)
• DataType/TextType.php (added)
• Entity.php (modified) (5 diffs)
• EntityManager.php (modified) (1 diff)
• EntityManagerFactory.php (modified) (2 diffs)
• EntityPersister/Abstract.php (modified) (2 diffs)
• EntityRepository.php (modified) (1 diff)
• Hydrator/RecordDriver.php (modified) (2 diffs)
• HydratorNew.php (modified) (2 diffs)
• Id (added)
• Id/AbstractIdGenerator.php (added)
• Id/IdentityGenerator.php (added)
• Id/SequenceGenerator.php (added)
• Id/TableGenerator.php (added)
• Import.php (modified) (2 diffs)
• Query/AbstractResult.php (modified) (1 diff)
• Query/Parser.php (modified) (1 diff)
• Query/ParserResult.php (modified) (1 diff)
• Query/QueryResult.php (modified) (2 diffs)
• Query/Registry.php (modified) (1 diff)
• Query/Registry/Exception.php (modified) (2 diffs)
• Query/Scanner.php (modified) (2 diffs)
• Query/SqlBuilder.php (modified) (1 diff)
• Query/Tokenizer.php (modified) (1 diff)
• Query/Tokenizer/Exception.php (modified) (2 diffs)
• Schema/MsSqlSchemaManager.php (modified) (1 diff)
• Schema/MySqlSchemaManger.php (modified) (6 diffs)
• Schema/PostgreSqlSchemaManager.php (modified) (3 diffs)
• Schema/SchemaManager.php (modified) (26 diffs)

trunk/lib/Doctrine/Association.php

@@ -104 +104 @@
     
     /**
-     * Identifies the field on the owning side that has the mapping for the
+     * Identifies the field on the owning side that controls the mapping for the
      * association. This is only set on the inverse side of an association.
      *
@@ -110 +110 @@
      */
     protected $_mappedByFieldName;
+    
+    /**
+     * Identifies the field on the inverse side of a bidirectional association.
+     * This is only set on the owning side of an association.
+     *
+     * @var string
+     */
+    //protected $_inverseSideFieldName;
     
     /**
@@ -128 +136 @@
     public function __construct(array $mapping)
     {
-        /*$this->_mapping = array(
+        //$this->_initMappingArray();
+        //$mapping = $this->_validateAndCompleteMapping($mapping);
+        //$this->_mapping = array_merge($this->_mapping, $mapping);*/
+        
+        $this->_validateAndCompleteMapping($mapping);
+    }
+    
+    protected function _initMappingArray()
+    {
+        $this->_mapping = array(
             'fieldName' => null,
             'sourceEntity' => null,
@@ -138 +155 @@
             'mutator' => null,
             'optional' => true,
-            'cascade' => array()
+            'cascades' => array()
         );
-        $this->_mapping = array_merge($this->_mapping, $mapping);*/
-        $this->_validateAndCompleteMapping($mapping);
     }
     
@@ -343 +358 @@
     }
     
+    /*public function getInverseSideFieldName()
+    {
+        return $this->_inverseSideFieldName;
+    }*/
+    /**
+     * Marks the association as bidirectional, specifying the field name of
+     * the inverse side.
+     * This is called on the owning side, when an inverse side is discovered.
+     * This does only make sense to call on the owning side.
+     *
+     * @param string $inverseSideFieldName
+     */
+    /*public function setBidirectional($inverseSideFieldName)
+    {
+        if ( ! $this->_isOwningSide) {
+            return; //TODO: exception?
+        }
+        $this->_inverseSideFieldName = $inverseSideFieldName;
+    }*/
+    
+    /**
+     * Whether the association is bidirectional.
+     *
+     * @return boolean
+     */
+    /*public function isBidirectional()
+    {
+        return $this->_mappedByFieldName || $this->_inverseSideFieldName;
+    }*/
+    
     /**
      * Whether the source field of the association has a custom accessor.

trunk/lib/Doctrine/Association/OneToOne.php

@@ -64 +64 @@
     {
         parent::__construct($mapping);
+    }
+    
+    protected function _initMappingArray()
+    {
+        parent::_initMappingArray();
+        $this->_mapping['deleteOrphans'] = false;
     }
     

trunk/lib/Doctrine/Builder/Record.php

@@ -667 +667 @@
     public function buildRecord(array $definition)
     {
-        if ( !isset($definition['className'])) {
+        if ( ! isset($definition['className'])) {
             throw new Doctrine_Builder_Exception('Missing class name.');
         }

trunk/lib/Doctrine/ClassMetadata.php

@@ -178 +178 @@
      * The name of the field in the Entity. 
      * 
-     * - <b>type</b> (string)
-     * The database type of the column. Can be one of Doctrine's portable types.
+     * - <b>type</b> (object Doctrine::DBAL::Types::* or custom type)
+     * The database type of the column. Can be one of Doctrine's portable types
+     * or a custom type.
      * 
      * - <b>columnName</b> (string, optional)
@@ -185 +186 @@
      * 
      * - <b>length</b> (integer, optional)
-     * The database length of the column. Optional. Defaults to Doctrine's 
-     * default values for the portable types.
+     * The database length of the column. Optional. Default value taken from
+     * the type.
      * 
      * - <b>id</b> (boolean, optional)
@@ -201 +202 @@
      * Whether the column is nullable. Defaults to TRUE.
      * 
-     * - <b>columnDefinition</b> (string, optional)
+     * - <b>columnDefinition</b> (string, optional, schema-only)
      * The SQL fragment that is used when generating the DDL for the column.
      * 
-     * - <b>precision</b> (integer, optional)
+     * - <b>precision</b> (integer, optional, schema-only)
      * The precision of a decimal column. Only valid if the column type is decimal.
      * 
-     * - <b>scale</b> (integer, optional)
+     * - <b>scale</b> (integer, optional, schema-only)
      * The scale of a decimal column. Only valid if the column type is decimal.
+     * 
+     * - <b>index (string, optional, schema-only)</b>
+     * Whether an index should be generated for the column.
+     * The value specifies the name of the index. To create a multi-column index,
+     * just use the same name for several mappings.
+     * 
+     * - <b>unique (string, optional, schema-only)</b>
+     * Whether a unique constraint should be generated for the column.
+     * The value specifies the name of the unique constraint. To create a multi-column 
+     * unique constraint, just use the same name for several mappings.
+     * 
+     * - <b>foreignKey (string, optional, schema-only)</b>
      *
      * @var array
@@ -276 +289 @@
      *      -- charset                      character set
      *
-     *      -- checks                       the check constraints of this table, eg. 'price > dicounted_price'
-     *
-     *      -- collation                    collation attribute
-     *
-     *      -- indexes                      the index definitions of this table
-     *
-     *      -- sequenceName                 Some databases need sequences instead of auto incrementation primary keys,
-     *                                      you can set specific sequence for your table by calling setOption('sequenceName', $seqName)
-     *                                      where $seqName is the name of the desired sequence
+     *      -- collate                    collation attribute
      */
     protected $_tableOptions = array(
-            'tableName'      => null,
-            'sequenceName'   => null,
-            'type'           => null,
-            'charset'        => null,
-            'collation'      => null,
-            'collate'        => null,
-            'indexes'        => array(),
-            'checks'         => array()
+            'tableName' => null,
+            'type' => null,
+            'charset' => null,
+            'collate' => null
     );
     
@@ -320 +321 @@
     
     /**
-     * The association mappings.
+     * The association mappings. All mappings, inverse and owning side.
      *
      * @var array
      */
     protected $_associationMappings = array();
+    
+    /**
+     * List of inverse association mappings, indexed by mappedBy field name.
+     *
+     * @var array
+     */
+    protected $_inverseMappings = array();
     
     /**
@@ -552 +560 @@
         
         return $this->_associationMappings[$fieldName];
+    }
+    
+    /**
+     * Gets the inverse association mapping for the given fieldname.
+     *
+     * @param string $mappedByFieldName
+     * @return Doctrine::ORM::Mapping::AssociationMapping The mapping.
+     */
+    public function getInverseAssociationMapping($mappedByFieldName)
+    {
+        if ( ! isset($this->_associationMappings[$fieldName])) {
+            throw Doctrine_MappingException::mappingNotFound($fieldName);
+        }
+        
+        return $this->_inverseMappings[$mappedByFieldName];
+    }
+    
+    /**
+     * Whether the class has an inverse association mapping on the given fieldname.
+     *
+     * @param string $mappedByFieldName
+     * @return boolean
+     */
+    public function hasInverseAssociationMapping($mappedByFieldName)
+    {
+        return isset($this->_inverseMappings[$mappedByFieldName]);
     }
     
@@ -719 +753 @@
                 $this->_isIdentifierComposite = true;
             }
-            
         }
         
@@ -1273 +1306 @@
             // Remove inherited, non-pk fields. They're not in the table of this class
             foreach ($allColumns as $name => $definition) {
-                if (isset($definition['primary']) && $definition['primary'] === true) {
+                if (isset($definition['id']) && $definition['id'] === true) {
                     if ($this->getParentClasses() && isset($definition['autoincrement'])) {
                         unset($allColumns[$name]['autoincrement']);
@@ -1287 +1320 @@
             if ($this->getParentClasses()) {
                 foreach ($allColumns as $name => $definition) {
-                    if (isset($definition['primary']) && $definition['primary'] === true) {
+                    if (isset($definition['id']) && $definition['id'] === true) {
                         if (isset($definition['autoincrement'])) {
                             unset($allColumns[$name]['autoincrement']);
@@ -1312 +1345 @@
             $columns[$name] = $definition;
 
-            if (isset($definition['primary']) && $definition['primary']) {
+            if (isset($definition['id']) && $definition['id']) {
                 $primary[] = $name;
             }
@@ -1494 +1527 @@
         $mapping = $this->_completeAssociationMapping($mapping);
         $oneToOneMapping = new Doctrine_Association_OneToOne($mapping);
-        $sourceFieldName = $oneToOneMapping->getSourceFieldName();
+        $this->_storeAssociationMapping($oneToOneMapping);
+        
+        /*if ($oneToOneMapping->isInverseSide()) {
+            //FIXME: infinite recursion possible?
+            // Alternative: Store inverse side mappings indexed by mappedBy fieldname
+            // ($this->_inverseMappings). Then look it up.            
+            $owningClass = $this->_em->getClassMetadata($oneToOneMapping->getTargetEntityName());
+            $owningClass->getAssociationMapping($oneToOneMapping->getMappedByFieldName())
+                    ->setBidirectional($oneToOneMapping->getSourceFieldName());
+        }*/
+    }
+    
+    private function _registerMappingIfInverse(Doctrine_Association $assoc)
+    {
+        if ($assoc->isInverseSide()) {
+            $this->_inverseMappings[$assoc->getMappedByFieldName()] = $assoc;
+        }
+    }
+
+    /**
+     * Adds a one-to-many mapping.
+     * 
+     * @param array $mapping The mapping.
+     */
+    public function mapOneToMany(array $mapping)
+    {
+        $mapping = $this->_completeAssociationMapping($mapping);
+        $oneToManyMapping = new Doctrine_Association_OneToMany($mapping);
+        $this->_storeAssociationMapping($oneToManyMapping);
+    }
+
+    /**
+     * Adds a many-to-one mapping.
+     * 
+     * @param array $mapping The mapping.
+     */
+    public function mapManyToOne(array $mapping)
+    {
+        // A many-to-one mapping is simply a one-one backreference
+        $this->mapOneToOne($mapping);
+    }
+
+    /**
+     * Adds a many-to-many mapping.
+     * 
+     * @param array $mapping The mapping.
+     */
+    public function mapManyToMany(array $mapping)
+    {
+        $mapping = $this->_completeAssociationMapping($mapping);
+        $manyToManyMapping = new Doctrine_Association_ManyToManyMapping($mapping);
+        $this->_storeAssociationMapping($manyToManyMapping);
+    }
+    
+    /**
+     * Stores the association mapping.
+     *
+     * @param Doctrine_Association $assocMapping
+     */
+    private function _storeAssociationMapping(Doctrine_Association $assocMapping)
+    {
+        $sourceFieldName = $assocMapping->getSourceFieldName();
         if (isset($this->_associationMappings[$sourceFieldName])) {
             throw Doctrine_MappingException::duplicateFieldMapping();
         }
-        $this->_associationMappings[$sourceFieldName] = $oneToOneMapping;
-        $this->_registerCustomAssociationAccessors($oneToOneMapping, $sourceFieldName);
-    }
-
-    /**
-     * Adds a one-to-many mapping.
-     * 
-     * @param array $mapping The mapping.
-     */
-    public function mapOneToMany(array $mapping)
-    {
-        $mapping = $this->_completeAssociationMapping($mapping);
-        $oneToManyMapping = new Doctrine_Association_OneToMany($mapping);
-        $sourceFieldName = $oneToManyMapping->getSourceFieldName();
-        if (isset($this->_associationMappings[$sourceFieldName])) {
-            throw Doctrine_MappingException::duplicateFieldMapping();
-        }
-        $this->_associationMappings[$sourceFieldName] = $oneToManyMapping;
-        $this->_registerCustomAssociationAccessors($oneToManyMapping, $sourceFieldName);
-    }
-
-    /**
-     * Adds a many-to-one mapping.
-     * 
-     * @param array $mapping The mapping.
-     */
-    public function mapManyToOne(array $mapping)
-    {
-        // A many-to-one mapping is simply a one-one backreference
-        $this->mapOneToOne($mapping);
-    }
-
-    /**
-     * @todo Implementation.
-     */
-    public function mapManyToMany(array $mapping)
-    {
-
+        $this->_associationMappings[$sourceFieldName] = $assocMapping;
+        $this->_registerCustomAssociationAccessors($assocMapping, $sourceFieldName);
+        $this->_registerMappingIfInverse($assocMapping);
     }
     

trunk/lib/Doctrine/Collection.php

@@ -32 +32 @@
  * A collection of entities represents only the associations (links) to those entities.
  * That means, if the collection is part of a many-many mapping and you remove
- * entities from the collection, only the links in the xref table are removed.
+ * entities from the collection, only the links in the xref table are removed (on flush).
  * Similarly, if you remove entities from a collection that is part of a one-many
- * mapping this will only result in the nulling out of the foreign keys
+ * mapping this will only result in the nulling out of the foreign keys on flush
  * (or removal of the links in the xref table if the one-many is mapped through an
  * xref table). If you want entities in a one-many collection to be removed when
@@ -45 +45 @@
  * @author    Konsta Vesterinen <kvesteri@cc.hut.fi>
  * @author    Roman Borschel <roman@code-factory.org>
+ * @todo Add more typical Collection methods.
  */
 class Doctrine_Collection implements Countable, IteratorAggregate, Serializable, ArrayAccess
@@ -87 +88 @@
 
     /**
-     * The name of the column that is used for collection key mapping.
+     * The name of the field that is used for collection key mapping.
      *
      * @var string
@@ -101 +102 @@
     
     /**
-     * The EntityManager.
-     *
-     * @var EntityManager
+     * The EntityManager that manages the persistence of the collection.
+     *
+     * @var Doctrine::ORM::EntityManager
      */
     protected $_em;
+    
+    /**
+     * The name of the field on the target entities that points to the owner
+     * of the collection. This is only set if the association is bidirectional.
+     *
+     * @var string
+     */
+    protected $_backRefFieldName;
+    
+    /**
+     * Hydration flag.
+     *
+     * @var boolean
+     * @see _setHydrationFlag()
+     */
+    protected $_hydrationFlag;
 
     /**
      * Constructor.
+     * Creates a new persistent collection.
      */
     public function __construct($entityBaseType, $keyField = null)
@@ -127 +145 @@
      *
      * @param array $data
+     * @todo Remove?
      */
     public function setData(array $data) 
@@ -134 +153 @@
 
     /**
-     * Serializes the collection.
-     * This method is automatically called when the Collection is serialized.
-     *
-     * Part of the implementation of the Serializable interface.
-     *
-     * @return array
-     */
-    public function serialize()
-    {
-        $vars = get_object_vars($this);
-
-        unset($vars['reference']);
-        unset($vars['relation']);
-        unset($vars['expandable']);
-        unset($vars['expanded']);
-        unset($vars['generator']);
-
-        return serialize($vars);
-    }
-
-    /**
-     * Reconstitutes the collection object from it's serialized form.
-     * This method is automatically called everytime the Collection object is unserialized.
-     *
-     * Part of the implementation of the Serializable interface.
-     *
-     * @param string $serialized The serialized data
-     *
-     * @return void
-     */
-    public function unserialize($serialized)
-    {
-        $manager = Doctrine_EntityManagerFactory::getManager();
-        $connection = $manager->getConnection();
-        
-        $array = unserialize($serialized);
-
-        foreach ($array as $name => $values) {
-            $this->$name = $values;
-        }
-
-        $keyColumn = isset($array['keyField']) ? $array['keyField'] : null;
-
-        if ($keyColumn !== null) {
-            $this->_keyField = $keyColumn;
-        }
-    }
-
-    /**
-     * Sets the key column for this collection
+     * INTERNAL: Sets the key column for this collection
      *
      * @param string $column
@@ -195 +165 @@
 
     /**
-     * returns the name of the key column
+     * INTERNAL: returns the name of the key column
      *
      * @return string
@@ -209 +179 @@
      * @return array
      */
-    public function getData()
+    public function unwrap()
     {
         return $this->_data;
@@ -256 +226 @@
     /**
      * INTERNAL:
-     * sets a reference pointer
+     * Sets the collection owner. Used (only?) during hydration.
      *
      * @return void
      */
-    public function setReference(Doctrine_Entity $entity, Doctrine_Association $relation)
+    public function _setOwner(Doctrine_Entity $entity, Doctrine_Association $relation)
     {
         $this->_owner = $entity;
         $this->_association = $relation;
-
-        /*if ($relation instanceof Doctrine_Relation_ForeignKey || 
-                $relation instanceof Doctrine_Relation_LocalKey) {
-            $this->referenceField = $relation->getForeignFieldName();
-            $value = $entity->get($relation->getLocalFieldName());
-            foreach ($this->_data as $entity) {
-                if ($value !== null) {
-                    $entity->set($this->referenceField, $value, false);
-                } else {
-                    $entity->set($this->referenceField, $this->_owner, false);
-                }
-            }
-        } else if ($relation instanceof Doctrine_Relation_Association) {
-
-        }*/
+        if ($relation->isInverseSide()) {
+            // for sure bidirectional
+            $this->_backRefFieldName = $relation->getMappedByFieldName();
+        } else {
+            $targetClass = $this->_em->getClassMetadata($relation->getTargetEntityName());
+            if ($targetClass->hasInverseAssociationMapping($relation->getSourceFieldName())) {
+                // bidirectional
+                $this->_backRefFieldName = $targetClass->getInverseAssociationMapping(
+                        $relation->getSourceFieldName())->getSourceFieldName();
+            }
+        }
     }
 
@@ -287 +253 @@
      * @return mixed
      */
-    public function getReference()
+    public function _getOwner()
     {
         return $this->_owner;