Current File : /home/admin/public_html/old/libraries/rokcommon/Doctrine/Connection/UnitOfWork.php
<?php
/*
* $Id: UnitOfWork.php 10831 2013-05-29 19:32:17Z btowles $
*
* 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>.
*/
/**
* Doctrine_Connection_UnitOfWork
*
* Note: This class does not have the semantics of a real "Unit of Work" in 0.10/1.0.
* Database operations are not queued. All changes to objects are immediately written
* to the database. You can think of it as a unit of work in auto-flush mode.
*
* Referential integrity is currently not always ensured.
*
* @package Doctrine
* @subpackage Connection
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.org
* @since 1.0
* @version $Revision: 7684 $
* @author Konsta Vesterinen <kvesteri@cc.hut.fi>
* @author Roman Borschel <roman@code-factory.org>
*/
class Doctrine_Connection_UnitOfWork extends Doctrine_Connection_Module
{
/**
* Saves the given record and all associated records.
* (The save() operation is always cascaded in 0.10/1.0).
*
* @param Doctrine_Record $record
* @return void
*/
public function saveGraph(Doctrine_Record $record, $replace = false)
{
$record->assignInheritanceValues();
$conn = $this->getConnection();
$conn->connect();
$state = $record->state();
if ($state === Doctrine_Record::STATE_LOCKED || $state === Doctrine_Record::STATE_TLOCKED) {
return false;
}
$record->state($record->exists() ? Doctrine_Record::STATE_LOCKED : Doctrine_Record::STATE_TLOCKED);
try {
$conn->beginInternalTransaction();
$record->state($state);
$event = $record->invokeSaveHooks('pre', 'save');
$state = $record->state();
$isValid = true;
if ( ! $event->skipOperation) {
$this->saveRelatedLocalKeys($record);
switch ($state) {
case Doctrine_Record::STATE_TDIRTY:
case Doctrine_Record::STATE_TCLEAN:
if ($replace) {
$isValid = $this->replace($record);
} else {
$isValid = $this->insert($record);
}
break;
case Doctrine_Record::STATE_DIRTY:
case Doctrine_Record::STATE_PROXY:
if ($replace) {
$isValid = $this->replace($record);
} else {
$isValid = $this->update($record);
}
break;
case Doctrine_Record::STATE_CLEAN:
// do nothing
break;
}
$aliasesUnlinkInDb = array();
if ($isValid) {
// NOTE: what about referential integrity issues?
foreach ($record->getPendingDeletes() as $pendingDelete) {
$pendingDelete->delete();
}
foreach ($record->getPendingUnlinks() as $alias => $ids) {
if ($ids === false) {
$record->unlinkInDb($alias, array());
$aliasesUnlinkInDb[] = $alias;
} else if ($ids) {
$record->unlinkInDb($alias, array_keys($ids));
$aliasesUnlinkInDb[] = $alias;
}
}
$record->resetPendingUnlinks();
$record->invokeSaveHooks('post', 'save', $event);
} else {
$conn->transaction->addInvalid($record);
}
$state = $record->state();
$record->state($record->exists() ? Doctrine_Record::STATE_LOCKED : Doctrine_Record::STATE_TLOCKED);
if ($isValid) {
$saveLater = $this->saveRelatedForeignKeys($record);
foreach ($saveLater as $fk) {
$alias = $fk->getAlias();
if ($record->hasReference($alias)) {
$obj = $record->$alias;
// check that the related object is not an instance of Doctrine_Null
if ($obj && ! ($obj instanceof Doctrine_Null)) {
$processDiff = !in_array($alias, $aliasesUnlinkInDb);
$obj->save($conn, $processDiff);
}
}
}
// save the MANY-TO-MANY associations
$this->saveAssociations($record);
}
}
$record->state($state);
$conn->commit();
} catch (Exception $e) {
// Make sure we roll back our internal transaction
//$record->state($state);
$conn->rollback();
throw $e;
}
$record->clearInvokedSaveHooks();
return true;
}
/**
* Deletes the given record and all the related records that participate
* in an application-level delete cascade.
*
* this event can be listened by the onPreDelete and onDelete listeners
*
* @return boolean true on success, false on failure
*/
public function delete(Doctrine_Record $record)
{
$deletions = array();
$this->_collectDeletions($record, $deletions);
return $this->_executeDeletions($deletions);
}
/**
* Collects all records that need to be deleted by applying defined
* application-level delete cascades.
*
* @param array $deletions Map of the records to delete. Keys=Oids Values=Records.
*/
private function _collectDeletions(Doctrine_Record $record, array &$deletions)
{
if ( ! $record->exists()) {
return;
}
$deletions[$record->getOid()] = $record;
$this->_cascadeDelete($record, $deletions);
}
/**
* Executes the deletions for all collected records during a delete operation
* (usually triggered through $record->delete()).
*
* @param array $deletions Map of the records to delete. Keys=Oids Values=Records.
*/
private function _executeDeletions(array $deletions)
{
// collect class names
$classNames = array();
foreach ($deletions as $record) {
$classNames[] = $record->getTable()->getComponentName();
}
$classNames = array_unique($classNames);
// order deletes
$executionOrder = $this->buildFlushTree($classNames);
// execute
try {
$this->conn->beginInternalTransaction();
for ($i = count($executionOrder) - 1; $i >= 0; $i--) {
$className = $executionOrder[$i];
$table = $this->conn->getTable($className);
// collect identifiers
$identifierMaps = array();
$deletedRecords = array();
foreach ($deletions as $oid => $record) {
if ($record->getTable()->getComponentName() == $className) {
$veto = $this->_preDelete($record);
if ( ! $veto) {
$identifierMaps[] = $record->identifier();
$deletedRecords[] = $record;
unset($deletions[$oid]);
}
}
}
if (count($deletedRecords) < 1) {
continue;
}
// extract query parameters (only the identifier values are of interest)
$params = array();
$columnNames = array();
foreach ($identifierMaps as $idMap) {
while (list($fieldName, $value) = each($idMap)) {
$params[] = $value;
$columnNames[] = $table->getColumnName($fieldName);
}
}
$columnNames = array_unique($columnNames);
// delete
$tableName = $table->getTableName();
$sql = "DELETE FROM " . $this->conn->quoteIdentifier($tableName) . " WHERE ";
if ($table->isIdentifierComposite()) {
$sql .= $this->_buildSqlCompositeKeyCondition($columnNames, count($identifierMaps));
$this->conn->exec($sql, $params);
} else {
$sql .= $this->_buildSqlSingleKeyCondition($columnNames, count($params));
$this->conn->exec($sql, $params);
}
// adjust state, remove from identity map and inform postDelete listeners
foreach ($deletedRecords as $record) {
// currently just for bc!
$this->_deleteCTIParents($table, $record);
//--
$record->state(Doctrine_Record::STATE_TCLEAN);
$record->getTable()->removeRecord($record);
$this->_postDelete($record);
}
}
// trigger postDelete for records skipped during the deletion (veto!)
foreach ($deletions as $skippedRecord) {
$this->_postDelete($skippedRecord);
}
$this->conn->commit();
return true;
} catch (Exception $e) {
$this->conn->rollback();
throw $e;
}
}
/**
* Builds the SQL condition to target multiple records who have a single-column
* primary key.
*
* @param Doctrine_Table $table The table from which the records are going to be deleted.
* @param integer $numRecords The number of records that are going to be deleted.
* @return string The SQL condition "pk = ? OR pk = ? OR pk = ? ..."
*/
private function _buildSqlSingleKeyCondition($columnNames, $numRecords)
{
$idColumn = $this->conn->quoteIdentifier($columnNames[0]);
return implode(' OR ', array_fill(0, $numRecords, "$idColumn = ?"));
}
/**
* Builds the SQL condition to target multiple records who have a composite primary key.
*
* @param Doctrine_Table $table The table from which the records are going to be deleted.
* @param integer $numRecords The number of records that are going to be deleted.
* @return string The SQL condition "(pk1 = ? AND pk2 = ?) OR (pk1 = ? AND pk2 = ?) ..."
*/
private function _buildSqlCompositeKeyCondition($columnNames, $numRecords)
{
$singleCondition = "";
foreach ($columnNames as $columnName) {
$columnName = $this->conn->quoteIdentifier($columnName);
if ($singleCondition === "") {
$singleCondition .= "($columnName = ?";
} else {
$singleCondition .= " AND $columnName = ?";
}
}
$singleCondition .= ")";
$fullCondition = implode(' OR ', array_fill(0, $numRecords, $singleCondition));
return $fullCondition;
}
/**
* Cascades an ongoing delete operation to related objects. Applies only on relations
* that have 'delete' in their cascade options.
* This is an application-level cascade. Related objects that participate in the
* cascade and are not yet loaded are fetched from the database.
* Exception: many-valued relations are always (re-)fetched from the database to
* make sure we have all of them.
*
* @param Doctrine_Record The record for which the delete operation will be cascaded.
* @throws PDOException If something went wrong at database level
* @return void
*/
protected function _cascadeDelete(Doctrine_Record $record, array &$deletions)
{
foreach ($record->getTable()->getRelations() as $relation) {
if ($relation->isCascadeDelete()) {
$fieldName = $relation->getAlias();
// if it's a xToOne relation and the related object is already loaded
// we don't need to refresh.
if ( ! ($relation->getType() == Doctrine_Relation::ONE && isset($record->$fieldName))) {
$record->refreshRelated($relation->getAlias());
}
$relatedObjects = $record->get($relation->getAlias());
if ($relatedObjects instanceof Doctrine_Record && $relatedObjects->exists()
&& ! isset($deletions[$relatedObjects->getOid()])) {
$this->_collectDeletions($relatedObjects, $deletions);
} else if ($relatedObjects instanceof Doctrine_Collection && count($relatedObjects) > 0) {
// cascade the delete to the other objects
foreach ($relatedObjects as $object) {
if ( ! isset($deletions[$object->getOid()])) {
$this->_collectDeletions($object, $deletions);
}
}
}
}
}
}
/**
* saveRelatedForeignKeys
* saves all related (through ForeignKey) records to $record
*
* @throws PDOException if something went wrong at database level
* @param Doctrine_Record $record
*/
public function saveRelatedForeignKeys(Doctrine_Record $record)
{
$saveLater = array();
foreach ($record->getReferences() as $k => $v) {
$rel = $record->getTable()->getRelation($k);
if ($rel instanceof Doctrine_Relation_ForeignKey) {
$saveLater[$k] = $rel;
}
}
return $saveLater;
}
/**
* saveRelatedLocalKeys
* saves all related (through LocalKey) records to $record
*
* @throws PDOException if something went wrong at database level
* @param Doctrine_Record $record
*/
public function saveRelatedLocalKeys(Doctrine_Record $record)
{
$state = $record->state();
$record->state($record->exists() ? Doctrine_Record::STATE_LOCKED : Doctrine_Record::STATE_TLOCKED);
foreach ($record->getReferences() as $k => $v) {
$rel = $record->getTable()->getRelation($k);
$local = $rel->getLocal();
$foreign = $rel->getForeign();
if ($rel instanceof Doctrine_Relation_LocalKey) {
// ONE-TO-ONE relationship
$obj = $record->get($rel->getAlias());
// Protection against infinite function recursion before attempting to save
if ($obj instanceof Doctrine_Record && $obj->isModified()) {
$obj->save($this->conn);
$id = array_values($obj->identifier());
if ( ! empty($id)) {
foreach ((array) $rel->getLocal() as $k => $columnName) {
$field = $record->getTable()->getFieldName($columnName);
if (isset($id[$k]) && $id[$k] && $record->getTable()->hasField($field)) {
$record->set($field, $id[$k]);
}
}
}
}
}
}
$record->state($state);
}
/**
* saveAssociations
*
* this method takes a diff of one-to-many / many-to-many original and
* current collections and applies the changes
*
* for example if original many-to-many related collection has records with
* primary keys 1,2 and 3 and the new collection has records with primary keys
* 3, 4 and 5, this method would first destroy the associations to 1 and 2 and then
* save new associations to 4 and 5
*
* @throws Doctrine_Connection_Exception if something went wrong at database level
* @param Doctrine_Record $record
* @return void
*/
public function saveAssociations(Doctrine_Record $record)
{
foreach ($record->getReferences() as $k => $v) {
$rel = $record->getTable()->getRelation($k);
if ($rel instanceof Doctrine_Relation_Association) {
if ($this->conn->getAttribute(Doctrine_Core::ATTR_CASCADE_SAVES) || $v->isModified()) {
$v->save($this->conn, false);
}
$assocTable = $rel->getAssociationTable();
foreach ($v->getDeleteDiff() as $r) {
$query = 'DELETE FROM ' . $assocTable->getTableName()
. ' WHERE ' . $rel->getForeignRefColumnName() . ' = ?'
. ' AND ' . $rel->getLocalRefColumnName() . ' = ?';
$this->conn->execute($query, array($r->getIncremented(), $record->getIncremented()));
}
foreach ($v->getInsertDiff() as $r) {
$assocRecord = $assocTable->create();
$assocRecord->set($assocTable->getFieldName($rel->getForeign()), $r);
$assocRecord->set($assocTable->getFieldName($rel->getLocal()), $record);
$this->saveGraph($assocRecord);
}
// take snapshot of collection state, so that we know when its modified again
$v->takeSnapshot();
}
}
}
/**
* Invokes preDelete event listeners.
*
* @return boolean Whether a listener has used it's veto (don't delete!).
*/
private function _preDelete(Doctrine_Record $record)
{
$event = new Doctrine_Event($record, Doctrine_Event::RECORD_DELETE);
$record->preDelete($event);
$record->getTable()->getRecordListener()->preDelete($event);
return $event->skipOperation;
}
/**
* Invokes postDelete event listeners.
*/
private function _postDelete(Doctrine_Record $record)
{
$event = new Doctrine_Event($record, Doctrine_Event::RECORD_DELETE);
$record->postDelete($event);
$record->getTable()->getRecordListener()->postDelete($event);
}
/**
* saveAll
* persists all the pending records from all tables
*
* @throws PDOException if something went wrong at database level
* @return void
*/
public function saveAll()
{
// get the flush tree
$tree = $this->buildFlushTree($this->conn->getTables());
// save all records
foreach ($tree as $name) {
$table = $this->conn->getTable($name);
foreach ($table->getRepository() as $record) {
$this->saveGraph($record);
}
}
}
/**
* updates given record
*
* @param Doctrine_Record $record record to be updated
* @return boolean whether or not the update was successful
*/
public function update(Doctrine_Record $record)
{
$event = $record->invokeSaveHooks('pre', 'update');;
if ($record->isValid(false, false)) {
$table = $record->getTable();
if ( ! $event->skipOperation) {
$identifier = $record->identifier();
if ($table->getOption('joinedParents')) {
// currrently just for bc!
$this->_updateCTIRecord($table, $record);
//--
} else {
$array = $record->getPrepared();
$this->conn->update($table, $array, $identifier);
}
$record->assignIdentifier(true);
}
$record->invokeSaveHooks('post', 'update', $event);
return true;
}
return false;
}
/**
* Inserts a record into database.
*
* This method inserts a transient record in the database, and adds it
* to the identity map of its correspondent table. It proxies to @see
* processSingleInsert(), trigger insert hooks and validation of data
* if required.
*
* @param Doctrine_Record $record
* @return boolean false if record is not valid
*/
public function insert(Doctrine_Record $record)
{
$event = $record->invokeSaveHooks('pre', 'insert');
if ($record->isValid(false, false)) {
$table = $record->getTable();
if ( ! $event->skipOperation) {
if ($table->getOption('joinedParents')) {
// just for bc!
$this->_insertCTIRecord($table, $record);
//--
} else {
$this->processSingleInsert($record);
}
}
$table->addRecord($record);
$record->invokeSaveHooks('post', 'insert', $event);
return true;
}
return false;
}
/**
* Replaces a record into database.
*
* @param Doctrine_Record $record
* @return boolean false if record is not valid
*/
public function replace(Doctrine_Record $record)
{
if ($record->exists()) {
return $this->update($record);
} else {
if ($record->isValid()) {
$this->_assignSequence($record);
$saveEvent = $record->invokeSaveHooks('pre', 'save');
$insertEvent = $record->invokeSaveHooks('pre', 'insert');
$table = $record->getTable();
$identifier = (array) $table->getIdentifier();
$data = $record->getPrepared();
foreach ($data as $key => $value) {
if ($value instanceof Doctrine_Expression) {
$data[$key] = $value->getSql();
}
}
$result = $this->conn->replace($table, $data, $identifier);
$record->invokeSaveHooks('post', 'insert', $insertEvent);
$record->invokeSaveHooks('post', 'save', $saveEvent);
$this->_assignIdentifier($record);
return true;
} else {
return false;
}
}
}
/**
* Inserts a transient record in its table.
*
* This method inserts the data of a single record in its assigned table,
* assigning to it the autoincrement primary key (if any is defined).
*
* @param Doctrine_Record $record
* @return void
*/
public function processSingleInsert(Doctrine_Record $record)
{
$fields = $record->getPrepared();
$table = $record->getTable();
// Populate fields with a blank array so that a blank records can be inserted
if (empty($fields)) {
foreach ($table->getFieldNames() as $field) {
$fields[$field] = null;
}
}
$this->_assignSequence($record, $fields);
$this->conn->insert($table, $fields);
$this->_assignIdentifier($record);
}
/**
* buildFlushTree
* builds a flush tree that is used in transactions
*
* The returned array has all the initialized components in
* 'correct' order. Basically this means that the records of those
* components can be saved safely in the order specified by the returned array.
*
* @param array $tables an array of Doctrine_Table objects or component names
* @return array an array of component names in flushing order
*/
public function buildFlushTree(array $tables)
{
// determine classes to order. only necessary because the $tables param
// can contain strings or table objects...
$classesToOrder = array();
foreach ($tables as $table) {
if ( ! ($table instanceof Doctrine_Table)) {
$table = $this->conn->getTable($table, false);
}
$classesToOrder[] = $table->getComponentName();
}
$classesToOrder = array_unique($classesToOrder);
if (count($classesToOrder) < 2) {
return $classesToOrder;
}
// build the correct order
$flushList = array();
foreach ($classesToOrder as $class) {
$table = $this->conn->getTable($class, false);
$currentClass = $table->getComponentName();
$index = array_search($currentClass, $flushList);
if ($index === false) {
//echo "adding $currentClass to flushlist";
$flushList[] = $currentClass;
$index = max(array_keys($flushList));
}
$rels = $table->getRelations();
// move all foreignkey relations to the beginning
foreach ($rels as $key => $rel) {
if ($rel instanceof Doctrine_Relation_ForeignKey) {
unset($rels[$key]);
array_unshift($rels, $rel);
}
}
foreach ($rels as $rel) {
$relatedClassName = $rel->getTable()->getComponentName();
if ( ! in_array($relatedClassName, $classesToOrder)) {
continue;
}
$relatedCompIndex = array_search($relatedClassName, $flushList);
$type = $rel->getType();
// skip self-referenced relations
if ($relatedClassName === $currentClass) {
continue;
}
if ($rel instanceof Doctrine_Relation_ForeignKey) {
// the related component needs to come after this component in
// the list (since it holds the fk)
if ($relatedCompIndex !== false) {
// the component is already in the list
if ($relatedCompIndex >= $index) {
// it's already in the right place
continue;
}
unset($flushList[$index]);
// the related comp has the fk. so put "this" comp immediately
// before it in the list
array_splice($flushList, $relatedCompIndex, 0, $currentClass);
$index = $relatedCompIndex;
} else {
$flushList[] = $relatedClassName;
}
} else if ($rel instanceof Doctrine_Relation_LocalKey) {
// the related component needs to come before the current component
// in the list (since this component holds the fk).
if ($relatedCompIndex !== false) {
// already in flush list
if ($relatedCompIndex <= $index) {
// it's in the right place
continue;
}
unset($flushList[$relatedCompIndex]);
// "this" comp has the fk. so put the related comp before it
// in the list
array_splice($flushList, $index, 0, $relatedClassName);
} else {
array_unshift($flushList, $relatedClassName);
$index++;
}
} else if ($rel instanceof Doctrine_Relation_Association) {
// the association class needs to come after both classes
// that are connected through it in the list (since it holds
// both fks)
$assocTable = $rel->getAssociationFactory();
$assocClassName = $assocTable->getComponentName();
if ($relatedCompIndex !== false) {
unset($flushList[$relatedCompIndex]);
}
array_splice($flushList, $index, 0, $relatedClassName);
$index++;
$index3 = array_search($assocClassName, $flushList);
if ($index3 !== false) {
if ($index3 >= $index) {
continue;
}
unset($flushList[$index3]);
array_splice($flushList, $index - 1, 0, $assocClassName);
$index = $relatedCompIndex;
} else {
$flushList[] = $assocClassName;
}
}
}
}
return array_values($flushList);
}
/* The following is all the Class Table Inheritance specific code. Support dropped
for 0.10/1.0. */
/**
* Class Table Inheritance code.
* Support dropped for 0.10/1.0.
*
* Note: This is flawed. We also need to delete from subclass tables.
*/
private function _deleteCTIParents(Doctrine_Table $table, $record)
{
if ($table->getOption('joinedParents')) {
foreach (array_reverse($table->getOption('joinedParents')) as $parent) {
$parentTable = $table->getConnection()->getTable($parent);
$this->conn->delete($parentTable, $record->identifier());
}
}
}
/**
* Class Table Inheritance code.
* Support dropped for 0.10/1.0.
*/
private function _insertCTIRecord(Doctrine_Table $table, Doctrine_Record $record)
{
$dataSet = $this->_formatDataSet($record);
$component = $table->getComponentName();
$classes = $table->getOption('joinedParents');
$classes[] = $component;
foreach ($classes as $k => $parent) {
if ($k === 0) {
$rootRecord = new $parent();
$rootRecord->merge($dataSet[$parent]);
$this->processSingleInsert($rootRecord);
$record->assignIdentifier($rootRecord->identifier());
} else {
foreach ((array) $rootRecord->identifier() as $id => $value) {
$dataSet[$parent][$id] = $value;
}
$this->conn->insert($this->conn->getTable($parent), $dataSet[$parent]);
}
}
}
/**
* Class Table Inheritance code.
* Support dropped for 0.10/1.0.
*/
private function _updateCTIRecord(Doctrine_Table $table, Doctrine_Record $record)
{
$identifier = $record->identifier();
$dataSet = $this->_formatDataSet($record);
$component = $table->getComponentName();
$classes = $table->getOption('joinedParents');
$classes[] = $component;
foreach ($record as $field => $value) {
if ($value instanceof Doctrine_Record) {
if ( ! $value->exists()) {
$value->save();
}
$record->set($field, $value->getIncremented());
}
}
foreach ($classes as $class) {
$parentTable = $this->conn->getTable($class);
if ( ! array_key_exists($class, $dataSet)) {
continue;
}
$this->conn->update($this->conn->getTable($class), $dataSet[$class], $identifier);
}
}
/**
* Class Table Inheritance code.
* Support dropped for 0.10/1.0.
*/
private function _formatDataSet(Doctrine_Record $record)
{
$table = $record->getTable();
$dataSet = array();
$component = $table->getComponentName();
$array = $record->getPrepared();
foreach ($table->getColumns() as $columnName => $definition) {
if ( ! isset($dataSet[$component])) {
$dataSet[$component] = array();
}
if ( isset($definition['owner']) && ! isset($dataSet[$definition['owner']])) {
$dataSet[$definition['owner']] = array();
}
$fieldName = $table->getFieldName($columnName);
if (isset($definition['primary']) && $definition['primary']) {
continue;
}
if ( ! array_key_exists($fieldName, $array)) {
continue;
}
if (isset($definition['owner'])) {
$dataSet[$definition['owner']][$fieldName] = $array[$fieldName];
} else {
$dataSet[$component][$fieldName] = $array[$fieldName];
}
}
return $dataSet;
}
protected function _assignSequence(Doctrine_Record $record, &$fields = null)
{
$table = $record->getTable();
$seq = $table->sequenceName;
if ( ! empty($seq)) {
$id = $this->conn->sequence->nextId($seq);
$seqName = $table->getIdentifier();
if ($fields) {
$fields[$seqName] = $id;
}
$record->assignIdentifier($id);
return $id;
}
}
protected function _assignIdentifier(Doctrine_Record $record)
{
$table = $record->getTable();
$identifier = $table->getIdentifier();
$seq = $table->sequenceName;
if (empty($seq) && !is_array($identifier) &&
$table->getIdentifierType() != Doctrine_Core::IDENTIFIER_NATURAL) {
$id = false;
if ($record->$identifier == null) {
if (($driver = strtolower($this->conn->getDriverName())) == 'pgsql') {
$seq = $table->getTableName() . '_' . $table->getColumnName($identifier);
} elseif ($driver == 'oracle' || $driver == 'mssql') {
$seq = $table->getTableName();
}
$id = $this->conn->sequence->lastInsertId($seq);
} else {
$id = $record->$identifier;
}
if ( ! $id) {
throw new Doctrine_Connection_Exception("Couldn't get last insert identifier.");
}
$record->assignIdentifier($id);
} else {
$record->assignIdentifier(true);
}
}
}