1
0
mirror of synced 2024-12-15 07:36:03 +03:00
doctrine2/lib/Doctrine/Mapper/JoinedStrategy.php

293 lines
11 KiB
PHP
Raw Normal View History

<?php
class Doctrine_Mapper_JoinedStrategy extends Doctrine_Mapper_Strategy
{
protected $_columnNameFieldNameMap = array();
/**
2008-02-07 13:40:27 +03:00
* Inserts an entity that is part of a Class Table Inheritance hierarchy.
*
* @param Doctrine_Record $record record to be inserted
* @return boolean
*/
public function doInsert(Doctrine_Record $record)
{
$class = $this->_mapper->getClassMetadata();
$conn = $this->_mapper->getConnection();
$dataSet = $this->_groupFieldsByDefiningClass($record);
2008-02-12 15:31:28 +03:00
$component = $class->getClassName();
$classes = $class->getParentClasses();
array_unshift($classes, $component);
try {
$conn->beginInternalTransaction();
$identifier = null;
foreach (array_reverse($classes) as $k => $parent) {
$parentClass = $conn->getClassMetadata($parent);
if ($k == 0) {
2008-02-12 15:31:28 +03:00
$identifierType = $parentClass->getIdentifierType();
if ($identifierType == Doctrine::IDENTIFIER_AUTOINC) {
$this->_insertRow($parentClass->getTableName(), $dataSet[$parent]);
$identifier = $conn->sequence->lastInsertId();
} else if ($identifierType == Doctrine::IDENTIFIER_SEQUENCE) {
2008-02-12 15:31:28 +03:00
$seq = $record->getClassMetadata()->getTableOption('sequenceName');
if ( ! empty($seq)) {
$id = $conn->sequence->nextId($seq);
$identifierFields = (array)$parentClass->getIdentifier();
$dataSet[$parent][$identifierFields[0]] = $id;
$this->_insertRow($parentClass->getTableName(), $dataSet[$parent]);
}
} else {
throw new Doctrine_Mapper_Exception("Unsupported identifier type '$identifierType'.");
}
$record->assignIdentifier($identifier);
} else {
foreach ((array) $record->identifier() as $id => $value) {
2008-02-12 15:31:28 +03:00
$dataSet[$parent][$parentClass->getColumnName($id)] = $value;
}
$this->_insertRow($parentClass->getTableName(), $dataSet[$parent]);
}
}
$conn->commit();
} catch (Exception $e) {
$conn->rollback();
throw $e;
}
return true;
}
/**
2008-02-07 13:40:27 +03:00
* Updates an entity that is part of a Class Table Inheritance hierarchy.
*
* @param Doctrine_Record $record record to be updated
* @return boolean whether or not the update was successful
* @todo Move to Doctrine_Table (which will become Doctrine_Mapper).
*/
public function doUpdate(Doctrine_Record $record)
{
$conn = $this->_mapper->getConnection();
$classMetadata = $this->_mapper->getClassMetadata();
$identifier = $this->_convertFieldToColumnNames($record->identifier(), $classMetadata);
$dataSet = $this->_groupFieldsByDefiningClass($record);
$component = $classMetadata->getClassName();
$classes = $classMetadata->getParentClasses();
array_unshift($classes, $component);
foreach ($record as $field => $value) {
if ($value instanceof Doctrine_Record) {
if ( ! $value->exists()) {
$value->save();
}
$record->set($field, $value->getIncremented());
}
}
foreach (array_reverse($classes) as $class) {
$parentTable = $conn->getClassMetadata($class);
$this->_updateRow($parentTable->getTableName(), $dataSet[$class], $identifier);
}
$record->assignIdentifier(true);
return true;
}
2008-02-07 13:40:27 +03:00
/**
* Deletes an entity that is part of a Class Table Inheritance hierarchy.
*
*/
public function doDelete(Doctrine_Record $record)
{
$conn = $this->_mapper->getConnection();
try {
$class = $this->_mapper->getClassMetadata();
$conn->beginInternalTransaction();
$this->deleteComposites($record);
$record->state(Doctrine_Record::STATE_TDIRTY);
2008-02-12 15:31:28 +03:00
$identifier = $this->_convertFieldToColumnNames($record->identifier(), $class);
foreach ($class->getParentClasses() as $parent) {
$parentClass = $conn->getClassMetadata($parent);
$this->_deleteRow($parentClass->getTableName(), $identifier);
}
2008-02-12 15:31:28 +03:00
$conn->delete($class->getTableName(), $identifier);
$record->state(Doctrine_Record::STATE_TCLEAN);
$this->_mapper->removeRecord($record);
$conn->commit();
} catch (Exception $e) {
$conn->rollback();
throw $e;
}
return true;
}
/**
2008-02-07 13:40:27 +03:00
* Adds all parent classes as INNER JOINs and subclasses as OUTER JOINs
* to the query.
*
2008-02-07 13:40:27 +03:00
* Callback that is invoked during the SQL construction process.
*
2008-02-07 13:40:27 +03:00
* @return array The custom joins in the format <className> => <joinType>
*/
public function getCustomJoins()
{
$customJoins = array();
$classMetadata = $this->_mapper->getClassMetadata();
foreach ($classMetadata->getParentClasses() as $parentClass) {
$customJoins[$parentClass] = 'INNER';
}
foreach ((array)$classMetadata->getSubclasses() as $subClass) {
if ($subClass != $this->_mapper->getComponentName()) {
$customJoins[$subClass] = 'LEFT';
}
}
2008-02-07 13:40:27 +03:00
return $customJoins;
}
2008-02-07 13:40:27 +03:00
/**
* Adds the discriminator column to the selected fields in a query as well as
* all fields of subclasses. In Class Table Inheritance the default behavior is that
* all subclasses are joined in through OUTER JOINs when querying a base class.
*
* Callback that is invoked during the SQL construction process.
*
* @return array An array with the field names that will get added to the query.
*/
public function getCustomFields()
{
$classMetadata = $this->_mapper->getClassMetadata();
$conn = $this->_mapper->getConnection();
$fields = array($classMetadata->getInheritanceOption('discriminatorColumn'));
if ($classMetadata->getSubclasses()) {
foreach ($classMetadata->getSubclasses() as $subClass) {
$fields = array_merge($conn->getMetadata($subClass)->getFieldNames(), $fields);
}
}
2008-02-07 13:40:27 +03:00
return array_unique($fields);
}
/**
*
*/
public function getFieldNames()
{
if ($this->_fieldNames) {
return $this->_fieldNames;
}
$fieldNames = $this->_mapper->getClassMetadata()->getFieldNames();
$this->_fieldNames = array_unique($fieldNames);
return $fieldNames;
}
2008-02-07 13:40:27 +03:00
/**
*
*/
public function getFieldName($columnName)
{
if (isset($this->_columnNameFieldNameMap[$columnName])) {
return $this->_columnNameFieldNameMap[$columnName];
}
$classMetadata = $this->_mapper->getClassMetadata();
$conn = $this->_mapper->getConnection();
if ($classMetadata->hasColumn($columnName)) {
$this->_columnNameFieldNameMap[$columnName] = $classMetadata->getFieldName($columnName);
return $this->_columnNameFieldNameMap[$columnName];
}
foreach ($classMetadata->getParentClasses() as $parentClass) {
$parentTable = $conn->getClassMetadata($parentClass);
if ($parentTable->hasColumn($columnName)) {
$this->_columnNameFieldNameMap[$columnName] = $parentTable->getFieldName($columnName);
return $this->_columnNameFieldNameMap[$columnName];
}
}
foreach ((array)$classMetadata->getSubclasses() as $subClass) {
$subTable = $conn->getClassMetadata($subClass);
if ($subTable->hasColumn($columnName)) {
$this->_columnNameFieldNameMap[$columnName] = $subTable->getFieldName($columnName);
return $this->_columnNameFieldNameMap[$columnName];
}
}
throw new Doctrine_Mapper_Exception("No field name found for column name '$columnName'.");
}
2008-02-07 13:40:27 +03:00
/**
*
* @todo Looks like this better belongs into the ClassMetadata class.
*/
public function getOwningTable($fieldName)
{
$conn = $this->_mapper->getConnection();
$classMetadata = $this->_mapper->getClassMetadata();
if ($classMetadata->hasField($fieldName) && ! $classMetadata->isInheritedField($fieldName)) {
return $classMetadata;
}
foreach ($classMetadata->getParentClasses() as $parentClass) {
$parentTable = $conn->getClassMetadata($parentClass);
if ($parentTable->hasField($fieldName) && ! $parentTable->isInheritedField($fieldName)) {
return $parentTable;
}
}
foreach ((array)$classMetadata->getSubclasses() as $subClass) {
$subTable = $conn->getClassMetadata($subClass);
if ($subTable->hasField($fieldName) && ! $subTable->isInheritedField($fieldName)) {
return $subTable;
}
}
throw new Doctrine_Mapper_Exception("Unable to find owner of field '$fieldName'.");
}
/**
2008-02-07 13:40:27 +03:00
* Analyzes the fields of the entity and creates a map in which the field names
* are grouped by the class names they belong to.
*
*/
protected function _groupFieldsByDefiningClass(Doctrine_Record $record)
{
$conn = $this->_mapper->getConnection();
$classMetadata = $this->_mapper->getClassMetadata();
$dataSet = array();
$component = $classMetadata->getClassName();
$array = $record->getPrepared();
$classes = array_merge(array($component), $classMetadata->getParentClasses());
foreach ($classes as $class) {
2008-02-07 13:40:27 +03:00
$dataSet[$class] = array();
$parentClassMetadata = $conn->getClassMetadata($class);
foreach ($parentClassMetadata->getColumns() as $columnName => $definition) {
if ((isset($definition['primary']) && $definition['primary'] === true) ||
(isset($definition['inherited']) && $definition['inherited'] === true)) {
continue;
}
$fieldName = $classMetadata->getFieldName($columnName);
2008-02-07 13:40:27 +03:00
if ( ! array_key_exists($fieldName, $array)) {
continue;
}
2008-02-12 15:31:28 +03:00
$dataSet[$class][$columnName] = $array[$fieldName];
}
}
return $dataSet;
}
}