Mouf\Database\TDBM\TDBMService::save()

Complexity

Conditions	22
Paths	8

Size

Total Lines	197
Code Lines	73

Duplication

Lines	0
Ratio	0 %

Importance

Changes	7
Bugs	0	Features	0

<?php
	public function save(AbstractTDBMObject $object) {
		$status = $object->_getStatus();

		// Let's attach this object if it is in detached state.
		if ($status === TDBMObjectStateEnum::STATE_DETACHED) {
			$object->_attach($this);
			$status = $object->_getStatus();
		}

		if ($status === TDBMObjectStateEnum::STATE_NEW) {
			$dbRows = $object->_getDbRows();

			$unindexedPrimaryKeys = array();

			foreach ($dbRows as $dbRow) {

				$tableName = $dbRow->_getDbTableName();

				$schema = $this->tdbmSchemaAnalyzer->getSchema();
				$tableDescriptor = $schema->getTable($tableName);

				$primaryKeyColumns = $this->getPrimaryKeyColumns($tableName);

				if (empty($unindexedPrimaryKeys)) {
					$primaryKeys = $this->getPrimaryKeysForObjectFromDbRow($dbRow);
				} else {
					// First insert, the children must have the same primary key as the parent.
					$primaryKeys = $this->_getPrimaryKeysFromIndexedPrimaryKeys($tableName, $unindexedPrimaryKeys);
					$dbRow->_setPrimaryKeys($primaryKeys);
				}

				$references = $dbRow->_getReferences();

				// Let's save all references in NEW or DETACHED state (we need their primary key)
				foreach ($references as $fkName => $reference) {
                    $refStatus = $reference->_getStatus();
					if ($refStatus === TDBMObjectStateEnum::STATE_NEW || $refStatus === TDBMObjectStateEnum::STATE_DETACHED) {
						$this->save($reference);
					}
				}

				$dbRowData = $dbRow->_getDbRow();

				// Let's see if the columns for primary key have been set before inserting.
				// We assume that if one of the value of the PK has been set, the PK is set.
				$isPkSet = !empty($primaryKeys);


				/*if (!$isPkSet) {
                    // if there is no autoincrement and no pk set, let's go in error.
                    $isAutoIncrement = true;

                    foreach ($primaryKeyColumns as $pkColumnName) {
                        $pkColumn = $tableDescriptor->getColumn($pkColumnName);
                        if (!$pkColumn->getAutoincrement()) {
                            $isAutoIncrement = false;
                        }
                    }

                    if (!$isAutoIncrement) {
                        $msg = "Error! You did not set the primary key(s) for the new object of type '$tableName'. The primary key is not set to 'autoincrement' so you must either set the primary key in the object or modify the DB model to create an primary key with auto-increment.";
                        throw new TDBMException($msg);
                    }

                }*/

				$types = [];

				foreach ($dbRowData as $columnName => $value) {
					$columnDescriptor = $tableDescriptor->getColumn($columnName);
					$types[] = $columnDescriptor->getType();
				}

				$this->connection->insert($tableName, $dbRowData, $types);

				if (!$isPkSet && count($primaryKeyColumns) == 1) {
					$id = $this->connection->lastInsertId();
					$primaryKeys[$primaryKeyColumns[0]] = $id;
				}

				// TODO: change this to some private magic accessor in future
				$dbRow->_setPrimaryKeys($primaryKeys);
				$unindexedPrimaryKeys = array_values($primaryKeys);




				/*
                 * When attached, on "save", we check if the column updated is part of a primary key
                 * If this is part of a primary key, we call the _update_id method that updates the id in the list of known objects.
                 * This method should first verify that the id is not already used (and is not auto-incremented)
                 *
                 * In the object, the key is stored in an array of  (column => value), that can be directly used to update the record.
                 *
                 *
                 */


				/*try {

42% of this comment could be valid code. Did you maybe forget this after debugging?

                    $this->db_connection->exec($sql);
                } catch (TDBMException $e) {
                    $this->db_onerror = true;

                    // Strange..... if we do not have the line below, bad inserts are not catched.
                    // It seems that destructors are called before the registered shutdown function (PHP >=5.0.5)
                    //if ($this->tdbmService->isProgramExiting())
                    //	trigger_error("program exiting");
                    trigger_error($e->getMessage(), E_USER_ERROR);

                    if (!$this->tdbmService->isProgramExiting())
                        throw $e;
                    else
                    {
                        trigger_error($e->getMessage(), E_USER_ERROR);
                    }
                }*/

				// Let's remove this object from the $new_objects static table.
				$this->removeFromToSaveObjectList($dbRow);

				// TODO: change this behaviour to something more sensible performance-wise
				// Maybe a setting to trigger this globally?
				//$this->status = TDBMObjectStateEnum::STATE_NOT_LOADED;

40% of this comment could be valid code. Did you maybe forget this after debugging?

				//$this->db_modified_state = false;

50% of this comment could be valid code. Did you maybe forget this after debugging?

				//$dbRow = array();

63% of this comment could be valid code. Did you maybe forget this after debugging?

				// Let's add this object to the list of objects in cache.
				$this->_addToCache($dbRow);
			}




			$object->_setStatus(TDBMObjectStateEnum::STATE_LOADED);
		} elseif ($status === TDBMObjectStateEnum::STATE_DIRTY) {
			$dbRows = $object->_getDbRows();

			foreach ($dbRows as $dbRow) {
				$references = $dbRow->_getReferences();

				// Let's save all references in NEW state (we need their primary key)
				foreach ($references as $fkName => $reference) {
					if ($reference->_getStatus() === TDBMObjectStateEnum::STATE_NEW) {
						$this->save($reference);
					}
				}

				// Let's first get the primary keys
				$tableName = $dbRow->_getDbTableName();
				$dbRowData = $dbRow->_getDbRow();

				$schema = $this->tdbmSchemaAnalyzer->getSchema();
				$tableDescriptor = $schema->getTable($tableName);

				$primaryKeys = $dbRow->_getPrimaryKeys();

				$types = [];

				foreach ($dbRowData as $columnName => $value) {
					$columnDescriptor = $tableDescriptor->getColumn($columnName);
					$types[] = $columnDescriptor->getType();
				}
				foreach ($primaryKeys as $columnName => $value) {
					$columnDescriptor = $tableDescriptor->getColumn($columnName);
					$types[] = $columnDescriptor->getType();
				}

				$this->connection->update($tableName, $dbRowData, $primaryKeys, $types);

				// Let's check if the primary key has been updated...
				$needsUpdatePk = false;
				foreach ($primaryKeys as $column => $value) {
					if (!isset($dbRowData[$column]) || $dbRowData[$column] != $value) {
						$needsUpdatePk = true;
						break;
					}
				}
				if ($needsUpdatePk) {
					$this->objectStorage->remove($tableName, $this->getObjectHash($primaryKeys));
					$newPrimaryKeys = $this->getPrimaryKeysForObjectFromDbRow($dbRow);
					$dbRow->_setPrimaryKeys($newPrimaryKeys);
					$this->objectStorage->set($tableName, $this->getObjectHash($primaryKeys), $dbRow);
				}

				// Let's remove this object from the list of objects to save.
				$this->removeFromToSaveObjectList($dbRow);
			}

			$object->_setStatus(TDBMObjectStateEnum::STATE_LOADED);

		} elseif ($status === TDBMObjectStateEnum::STATE_DELETED) {
			throw new TDBMInvalidOperationException("This object has been deleted. It cannot be saved.");
		}

        // Finally, let's save all the many to many relationships to this bean.
        $this->persistManyToManyRelationships($object);
	}