Kdyby\Doctrine\Tools\NonLockingUniqueInserter

Complexity

Total Complexity

38

Size/Duplication

Total Lines	262
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	prepareInsert()	0	23	3
C	persist()	0	38	7
B	doInsert()	0	31	3
B	isUniqueConstraintViolation()	0	12	8
A	getFieldsWithValues()	0	15	4
D	getAssociationsWithValues()	0	45	10
A	getDiscriminatorColumn()	0	16	2

<?php

/**
 * This file is part of the Kdyby (http://www.kdyby.org)
 *
 * Copyright (c) 2008 Filip Procházka (filip@prochazka.su)
 *
 * For the full copyright and license information, please view the file license.txt that was distributed with this source code.
 */

namespace Kdyby\Doctrine\Tools;

use Doctrine;
use Doctrine\DBAL\DBALException;
use Doctrine\DBAL\Platforms\MySqlPlatform;
use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
use Doctrine\DBAL\Platforms\SqlitePlatform;
use Doctrine\DBAL\Statement;
use Doctrine\DBAL\Types\Type;
use Kdyby;
use Kdyby\Doctrine\Connection;
use Kdyby\Doctrine\EntityManager;
use Kdyby\Doctrine\Mapping\ClassMetadata;
use Nette;



/**
 * @author Filip Procházka <filip@prochazka.su>
 * @author Martin Štekl <martin.stekl@gmail.com>
 */
class NonLockingUniqueInserter extends Nette\Object
{

	/**
	 * @var \Kdyby\Doctrine\EntityManager
	 */
	private $em;

	/**
	 * @var \Kdyby\Doctrine\Connection
	 */
	private $db;

	/**
	 * @var \Doctrine\DBAL\Platforms\AbstractPlatform
	 */
	private $platform;

	/**
	 * @var \Doctrine\ORM\Mapping\QuoteStrategy
	 */
	private $quotes;

	/**
	 * @var \Doctrine\ORM\UnitOfWork
	 */
	private $uow;



	/**
	 * @param EntityManager $em
	 */
	public function __construct(EntityManager $em)
	{
		$this->em = $em;
		$this->db = $em->getConnection();
		$this->platform = $this->db->getDatabasePlatform();
		$this->quotes = $em->getConfiguration()->getQuoteStrategy();
		$this->uow = $this->em->getUnitOfWork();
	}



	/**
	 * When entity have columns for required associations, this will fail.
	 * Calls $em->flush().
	 *
	 * Warning: You must NOT use the passed entity further in your application.
	 * Use the returned one instead!
	 *
	 * @todo fix error codes! PDO is returning database-specific codes
	 *
	 * @param object $entity
	 * @throws \Doctrine\DBAL\DBALException
	 * @throws \Exception
	 * @return bool|object
	 */
	public function persist($entity)
	{
		$this->db->beginTransaction();

		try {
			$persisted = $this->doInsert($entity);
			$this->db->commit();

			return $persisted;

		} catch (Doctrine\DBAL\Exception\UniqueConstraintViolationException $e) {

The class Doctrine\DBAL\Exception\UniqueConstraintViolationException does not exist. Did you forget a USE statement, or did you not list all dependencies?

			$this->db->rollback();

			return FALSE;

		} catch (Kdyby\Doctrine\DuplicateEntryException $e) {
			$this->db->rollback();

			return FALSE;

		} catch (DBALException $e) {

The class Doctrine\DBAL\DBALException does not exist. Did you forget a USE statement, or did you not list all dependencies?

			$this->db->rollback();

			if ($this->isUniqueConstraintViolation($e)) {
				return FALSE;
			}

			throw $this->db->resolveException($e);

The method Kdyby\Doctrine\Connection::resolveException() has been deprecated.

		} catch (\Exception $e) {
			$this->db->rollback();
			throw $e;

		} catch (\Throwable $e) {

The class Throwable does not exist. Did you forget a USE statement, or did you not list all dependencies?

			$this->db->rollback();
			throw $e;
		}
	}



	private function doInsert($entity)
	{
		// get entity metadata
		$meta = $this->em->getClassMetadata(get_class($entity));

		// fields that have to be inserted
		$fields = $this->getFieldsWithValues($meta, $entity);
		// associations that have to be inserted
		$associations = $this->getAssociationsWithValues($meta, $entity);
		// discriminator column
		$discriminator = $this->getDiscriminatorColumn($meta);

		// prepare statement && execute
		$this->prepareInsert($meta, array_merge($fields, $associations, $discriminator))->execute();

		// assign ID to entity
		if ($idGen = $meta->idGenerator) {
			if ($idGen->isPostInsertGenerator()) {
				$id = $idGen->generate($this->em, $entity);
				$identifierFields = $meta->getIdentifierFieldNames();
				$meta->setFieldValue($entity, reset($identifierFields), $id);
			}
		}

		// entity is now safely inserted to database, merge now
		$merged = $this->em->merge($entity);
		$this->em->flush([$merged]);

		// when you merge entity, you get a new reference
		return $merged;
	}



	private function prepareInsert(ClassMetadata $meta, array $data)
	{
		// construct sql
		$columns = [];
		foreach ($data as $column) {
			$columns[] = $column['quotedColumn'];
		}

		$insertSql = 'INSERT INTO ' . $this->quotes->getTableName($meta, $this->platform)
			. ' (' . implode(', ', $columns) . ')'
			. ' VALUES (' . implode(', ', array_fill(0, count($columns), '?')) . ')';

		// create statement
		$statement = new Statement($insertSql, $this->db);

		// bind values
		$paramIndex = 1;
		foreach ($data as $column) {
			$statement->bindValue($paramIndex++, $column['value'], $column['type']);
		}

		return $statement;
	}



	/**
	 * @param \Exception|\PDOException $e
	 * @return bool
	 */
	private function isUniqueConstraintViolation($e)
	{
		if (!$e instanceof \PDOException && !(($e = $e->getPrevious()) instanceof \PDOException)) {
			return FALSE;
		}
		/** @var \PDOException $e */

		return
			($this->platform instanceof MySqlPlatform && $e->errorInfo[1] === Connection::MYSQL_ERR_UNIQUE) ||

The constant Kdyby\Doctrine\Connection::MYSQL_ERR_UNIQUE has been deprecated.

The class Doctrine\DBAL\Platforms\MySqlPlatform does not exist. Did you forget a USE statement, or did you not list all dependencies?

			($this->platform instanceof SqlitePlatform && $e->errorInfo[1] === Connection::SQLITE_ERR_UNIQUE) ||

The constant Kdyby\Doctrine\Connection::SQLITE_ERR_UNIQUE has been deprecated.

The class Doctrine\DBAL\Platforms\SqlitePlatform does not exist. Did you forget a USE statement, or did you not list all dependencies?

			($this->platform instanceof PostgreSqlPlatform && $e->errorInfo[1] === Connection::POSTGRE_ERR_UNIQUE);

The constant Kdyby\Doctrine\Connection::POSTGRE_ERR_UNIQUE has been deprecated.

The class Doctrine\DBAL\Platforms\PostgreSqlPlatform does not exist. Did you forget a USE statement, or did you not list all dependencies?

	}



	private function getFieldsWithValues(ClassMetadata $meta, $entity)
	{
		$fields = [];
		foreach ($meta->getFieldNames() as $fieldName) {
			$mapping = $meta->getFieldMapping($fieldName);
			if (!empty($mapping['id']) && $meta->usesIdGenerator()) { // autogenerated id
				continue;
			}
			$fields[$fieldName]['value'] = $meta->getFieldValue($entity, $fieldName);
			$fields[$fieldName]['quotedColumn'] = $this->quotes->getColumnName($fieldName, $meta, $this->platform);
			$fields[$fieldName]['type'] = Type::getType($mapping['type']);
		}

		return $fields;
	}



	private function getAssociationsWithValues(ClassMetadata $meta, $entity)
	{
		$associations = [];
		foreach ($meta->getAssociationNames() as $associationName) {
			$mapping = $meta->getAssociationMapping($associationName);
			if (!empty($mapping['id']) && $meta->usesIdGenerator()) { // autogenerated id
				continue;
			}
			if (!($mapping['type'] & ClassMetadata::TO_ONE)) { // is not to one relation
				continue;
			}
			if (empty($mapping['isOwningSide'])) { // is not owning side
				continue;
			}

			foreach ($mapping['joinColumns'] as $joinColumn) {
				$targetColumn = $joinColumn['referencedColumnName'];
				$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
				$newVal = $meta->getFieldValue($entity, $associationName);
				$newValId = $newVal !== NULL ? $this->uow->getEntityIdentifier($newVal) : [];

				switch (TRUE) {
					case $newVal === NULL:
						$value = NULL;
						break;

					case $targetClass->containsForeignIdentifier:
						$value = $newValId[$targetClass->getFieldForColumn($targetColumn)];
						break;

					default:
						$value = $newValId[$targetClass->fieldNames[$targetColumn]];
						break;
				}

				$sourceColumn = $joinColumn['name'];
				$quotedColumn = $this->quotes->getJoinColumnName($joinColumn, $meta, $this->platform);
				$associations[$sourceColumn]['value'] = $value;
				$associations[$sourceColumn]['quotedColumn'] = $quotedColumn;
				$associations[$sourceColumn]['type'] = $targetClass->getTypeOfColumn($targetColumn);
			}
		}

		return $associations;
	}



	private function getDiscriminatorColumn(ClassMetadata $meta)
	{
		if (!$meta->isInheritanceTypeSingleTable()) {
			return [];
		}

		$column = $meta->discriminatorColumn;

		return [
			$column['fieldName'] => [
				'value' => $meta->discriminatorValue,
				'quotedColumn' => $this->platform->quoteIdentifier($column['name']),
				'type' => Type::getType($column['type']),
			],
		];
	}

}