public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/_files');
$config->setProxyNamespace('DoctrineExtensions\\LargeCollections\\Proxies');
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
#$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
$this->em = \Doctrine\ORM\EntityManager::create($conn, $config);
$schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em);
$schemaTool->createSchema(array($this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Article'), $this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Tag'), $this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Comment')));
$article = new Article();
$tag1 = new Tag();
$tag2 = new Tag();
$comment1 = new Comment();
$comment2 = new Comment();
$article->addComment($comment1);
$article->addComment($comment2);
$article->addTag($tag1);
$article->addTag($tag2);
$this->em->persist($article);
$this->em->persist($tag1);
$this->em->persist($tag2);
$this->em->persist($comment1);
$this->em->persist($comment2);
$this->em->flush();
$this->articleId = $article->id();
$this->em->clear();
}
/**
* @group DDC-1439
*/
public function testInvalidToOneJoinColumnSchema()
{
$class1 = $this->em->getClassMetadata(__NAMESPACE__ . '\\InvalidEntity1');
$class2 = $this->em->getClassMetadata(__NAMESPACE__ . '\\InvalidEntity2');
$ce = $this->validator->validateClass($class2);
$this->assertEquals(array("The referenced column name 'id' does not have a corresponding field with this column name on the class 'Doctrine\\Tests\\ORM\\Tools\\InvalidEntity1'.", "The join columns of the association 'assoc' have to match to ALL identifier columns of the source entity 'Doctrine\\Tests\\ORM\\Tools\\InvalidEntity2', however 'key3, key4' are missing."), $ce);
}
public function testconfiguration()
{
$config = new Configuration();
$config->setCurrentUser($this->ZfcUserMock);
$prefix = "prefix";
$config->setTablePrefix($prefix);
$suffix = "suffix";
$config->setTableSuffix($suffix);
$fieldName = "fieldName";
$config->setRevisionFieldName($fieldName);
$revisionIdFieldType = "string";
$config->setRevisionIdFieldType($revisionIdFieldType);
$tableName = "tableName";
$config->setRevisionTableName($tableName);
$revisionTypeFieldName = "string";
$config->setRevisionTypeFieldName($revisionTypeFieldName);
$ipaddress = $config->getIpAddress();
$config->setAuditedEntityClasses(array('ZF2EntityAuditTest\\Entity\\Article', 'ZF2EntityAuditTest\\Entity\\Writer'));
$config->setNote("default note");
$this->auditManager = new Manager($config);
$this->auditManager->registerEvents($this->em->getEventManager());
/// creating the tables
$this->schemaTool = $this->getSchemaTool();
$this->schemaTool->createSchema(array($this->em->getClassMetadata('ZF2EntityAuditTest\\Entity\\Article'), $this->em->getClassMetadata('ZF2EntityAuditTest\\Entity\\Writer')));
$this->assertInstanceOf("ZfcUser\\Entity\\User", $this->ZfcUserMock);
$this->assertEquals($prefix, $config->getTablePrefix());
$this->assertEquals($suffix, $config->getTableSuffix());
$this->assertEquals($fieldName, $config->getRevisionFieldName());
$this->assertEquals($tableName, $config->getRevisionTableName());
$this->assertEquals($revisionIdFieldType, $config->getRevisionIdFieldType());
$this->assertEquals($revisionTypeFieldName, $config->getRevisionIdFieldType());
$this->assertEquals($ipaddress, "1.1.1.9");
}
public function createSchema()
{
$metas = [];
foreach (Deployment::instance()->models as $model) {
$metas[] = $this->entityManager->getClassMetadata($model);
}
$this->schemaTool->createSchema($metas);
}
/**
* Replaces name of tables in DBAL queries
*
* @param EntityManager $em
* @param string $entityName
* @param string $sql
*
* @return string
*/
public static function prepareDBALQuery($em, $entityName, $sql)
{
$productMetadata = $em->getClassMetadata($entityName);
$categoryMapping = $productMetadata->getAssociationMapping('categories');
$familyMapping = $productMetadata->getAssociationMapping('family');
$valueMapping = $productMetadata->getAssociationMapping('values');
$valueMetadata = $em->getClassMetadata($valueMapping['targetEntity']);
$attributeMapping = $valueMetadata->getAssociationMapping('attribute');
$attributeMetadata = $em->getClassMetadata($attributeMapping['targetEntity']);
$familyMetadata = $em->getClassMetadata($familyMapping['targetEntity']);
$attributeFamMapping = $familyMetadata->getAssociationMapping('attributes');
return strtr($sql, ['%category_join_table%' => $categoryMapping['joinTable']['name'], '%product_table%' => $productMetadata->getTableName(), '%product_value_table%' => $valueMetadata->getTableName(), '%attribute_table%' => $attributeMetadata->getTableName(), '%family_table%' => $familyMetadata->getTableName(), '%family_attribute_table%' => $attributeFamMapping['joinTable']['name']]);
}
protected function setUp()
{
parent::setUp();
$this->em = $this->createTestEntityManager();
$schemaTool = new SchemaTool($this->em);
$classes = array($this->em->getClassMetadata(self::SINGLE_IDENT_CLASS), $this->em->getClassMetadata(self::COMPOSITE_IDENT_CLASS));
try {
$schemaTool->dropSchema($classes);
} catch (\Exception $e) {
}
try {
$schemaTool->createSchema($classes);
} catch (\Exception $e) {
}
}
protected function setUp()
{
parent::setUp();
$this->em = $this->createTestEntityManager();
$schemaTool = new SchemaTool($this->em);
$classes = array($this->em->getClassMetadata('Symfony\\Bundle\\DoctrineBundle\\Tests\\Form\\ValueTransformer\\Tag'));
try {
$schemaTool->dropSchema($classes);
} catch (\Exception $e) {
}
try {
$schemaTool->createSchema($classes);
} catch (\Exception $e) {
}
}
protected function setUp()
{
parent::setUp();
$this->em = $this->createTestEntityManager();
$schemaTool = new SchemaTool($this->em);
$classes = array($this->em->getClassMetadata(__NAMESPACE__ . '\\Article'));
try {
$schemaTool->dropSchema($classes);
} catch (\Exception $e) {
}
try {
$schemaTool->createSchema($classes);
} catch (\Exception $e) {
}
}
/**
* Walks down an InstanceOfExpression AST node, thereby generating the appropriate SQL.
*
* @param InstanceOfExpression
* @return string The SQL.
*/
public function walkInstanceOfExpression($instanceOfExpr)
{
$sql = '';
$dqlAlias = $instanceOfExpr->identificationVariable;
$discrClass = $class = $this->_queryComponents[$dqlAlias]['metadata'];
$fieldName = null;
if ($class->discriminatorColumn) {
$discrClass = $this->_em->getClassMetadata($class->rootEntityName);
}
if ($this->_useSqlTableAliases) {
$sql .= $this->getSQLTableAlias($discrClass->table['name'], $dqlAlias) . '.';
}
$sql .= $class->discriminatorColumn['name'] . ($instanceOfExpr->not ? ' <> ' : ' = ');
if ($instanceOfExpr->value instanceof AST\InputParameter) {
// We need to modify the parameter value to be its correspondent mapped value
$dqlParamKey = $instanceOfExpr->value->name;
$paramValue = $this->_query->getParameter($dqlParamKey);
if (!$paramValue instanceof \Doctrine\ORM\Mapping\ClassMetadata) {
throw QueryException::invalidParameterType('ClassMetadata', get_class($paramValue));
}
$entityClassName = $paramValue->name;
} else {
// Get name from ClassMetadata to resolve aliases.
$entityClassName = $this->_em->getClassMetadata($instanceOfExpr->value)->name;
}
if ($entityClassName == $class->name) {
$sql .= $this->_conn->quote($class->discriminatorValue);
} else {
$discrMap = array_flip($class->discriminatorMap);
$sql .= $this->_conn->quote($discrMap[$entityClassName]);
}
return $sql;
}
/**
* Walks down an InstanceOfExpression AST node, thereby generating the appropriate SQL.
*
* @param InstanceOfExpression
* @return string The SQL.
*/
public function walkInstanceOfExpression($instanceOfExpr)
{
$sql = '';
$dqlAlias = $instanceOfExpr->identificationVariable;
$discrClass = $class = $this->queryComponents[$dqlAlias]['metadata'];
if ($class->discriminatorColumn) {
$discrClass = $this->em->getClassMetadata($class->rootEntityName);
}
if ($this->useSqlTableAliases) {
$sql .= $this->getSQLTableAlias($discrClass->getTableName(), $dqlAlias) . '.';
}
$sql .= $class->discriminatorColumn['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
$sqlParameterList = array();
foreach ($instanceOfExpr->value as $parameter) {
if ($parameter instanceof AST\InputParameter) {
$sqlParameterList[] = $this->walkInputParameter($parameter);
} else {
// Get name from ClassMetadata to resolve aliases.
$entityClassName = $this->em->getClassMetadata($parameter)->name;
if ($entityClassName == $class->name) {
$sqlParameterList[] = $this->conn->quote($class->discriminatorValue);
} else {
$discrMap = array_flip($class->discriminatorMap);
if (!isset($discrMap[$entityClassName])) {
throw QueryException::instanceOfUnrelatedClass($entityClassName, $class->rootEntityName);
}
$sqlParameterList[] = $this->conn->quote($discrMap[$entityClassName]);
}
}
}
$sql .= '(' . implode(', ', $sqlParameterList) . ')';
return $sql;
}
public function getConnection()
{
$classMetadata = array();
$this->em = $this->createEntityManager();
$conn = $this->em->getConnection();
$pdo = $conn->getWrappedConnection();
$schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em);
if (count($this->classes) > 0) {
foreach ($this->classes as $class) {
$classMetadata[] = $this->em->getClassMetadata($class);
}
} else {
throw new \Doctrine\ORM\ORMException("No associated classes not yet implemented.");
}
$schemaTool->createSchema($classMetadata);
return $this->createDefaultDBConnection($pdo, $conn->getDatabase());
}
public function setUp()
{
$this->Bootstrap = new Bootstrap();
$this->em = $this->Bootstrap->getServiceManager()->get("doctrine.entitymanager.orm_default");
/// echo sql logger
//$this->em->getConfiguration()->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());;
/// let's create the default user
$this->ZfcUserMock = $this->createUser();
$auditConfig = new Configuration();
$auditConfig->setCurrentUser($this->ZfcUserMock);
$auditConfig->setAuditedEntityClasses(array('ZF2EntityAuditTest\\Entity\\Article', 'ZF2EntityAuditTest\\Entity\\Writer'));
$auditConfig->setNote("default note");
$this->auditManager = new Manager($auditConfig);
$this->auditManager->registerEvents($this->em->getEventManager());
/// creating the tables
$this->schemaTool = $this->getSchemaTool();
$this->schemaTool->createSchema(array($this->em->getClassMetadata('ZF2EntityAuditTest\\Entity\\Article'), $this->em->getClassMetadata('ZF2EntityAuditTest\\Entity\\Writer')));
}
/**
* TODO: refactor this
*
* @param integer $ownerId
* @param string $type
* @param integer $parentId
* @param integer $placeholder
* @param array $sort
* @param null|array $data
*
* @throws \Exception
*
* @return BlockInterface
*/
public function createBlock($ownerId, $type, $parentId, $placeholder, $sort, $data = null)
{
$owner = $this->find($ownerId);
$version = $this->getNewVersion($owner);
$className = $this->em->getClassMetadata($type)->getName();
$block = new $className();
$parent = $this->find($parentId ?: $ownerId);
$block->setRootVersion($version);
$block->setPosition($placeholder);
$block->setSort(0);
// < default, gets recalculated later for entire level
$block->setSortParent(-1);
// < need to be calculated when putting in the tree
// Set owner
$block->setOwner($owner);
$owner->addOwning($block);
$owner->setRootVersion($version);
// This should replaced with a more hardened function
if ($data) {
foreach ($data as $attribute => $value) {
$method = "set{$attribute}";
$block->{$method}($value);
}
}
$block->setParent($parent);
$parent->setRootVersion($version);
// Save now, rest will be in changeset. All we do is a create a stub entry anyway.
$this->save($block);
if (count($sort) > 1) {
// Replace the zero value in the posted sort array
// with the newly created id to perform sorting
$id = $block->getId();
$sort = array_map(function ($v) use($id) {
return $v == "" || $v == "0" ? $id : $v;
}, $sort);
array_walk($sort, function (&$id) {
$id = (int) $id;
});
$contained = $this->findById($sort, $version);
if ($contained) {
$contained = $this->setSortsByDirective($contained, $sort);
foreach ($contained as $node) {
if ($node->getOwner()->getId() == $block->getOwner()->getId()) {
$node->setRootVersion($version);
$this->save($node);
}
}
}
} else {
}
return $block;
}
/**
* Dump the contents of the identity map into a stream.
*
* @param EntityManager $em
* @return void
*/
public function dumpIdentityMap(EntityManager $em)
{
$uow = $em->getUnitOfWork();
$identityMap = $uow->getIdentityMap();
$fh = fopen($this->file, "x+");
if (count($identityMap) == 0) {
fwrite($fh, "Flush Operation [" . $this->context . "] - Empty identity map.\n");
return;
}
fwrite($fh, "Flush Operation [" . $this->context . "] - Dumping identity map:\n");
foreach ($identityMap as $className => $map) {
fwrite($fh, "Class: " . $className . "\n");
foreach ($map as $idHash => $entity) {
fwrite($fh, " Entity: " . $this->getIdString($entity, $uow) . " " . spl_object_hash($entity) . "\n");
fwrite($fh, " Associations:\n");
$cm = $em->getClassMetadata($className);
foreach ($cm->associationMappings as $field => $assoc) {
fwrite($fh, " " . $field . " ");
$value = $cm->reflFields[$field]->getValue($entity);
if ($assoc['type'] & ClassMetadata::TO_ONE) {
if ($value === null) {
fwrite($fh, " NULL\n");
} else {
if ($value instanceof Proxy && !$value->__isInitialized__) {
fwrite($fh, "[PROXY] ");
}
fwrite($fh, $this->getIdString($value, $uow) . " " . spl_object_hash($value) . "\n");
}
} else {
$initialized = !$value instanceof PersistentCollection || $value->isInitialized();
if ($value === null) {
fwrite($fh, " NULL\n");
} else {
if ($initialized) {
fwrite($fh, "[INITIALIZED] " . $this->getType($value) . " " . count($value) . " elements\n");
foreach ($value as $obj) {
fwrite($fh, " " . $this->getIdString($obj, $uow) . " " . spl_object_hash($obj) . "\n");
}
} else {
fwrite($fh, "[PROXY] " . $this->getType($value) . " unknown element size\n");
foreach ($value->unwrap() as $obj) {
fwrite($fh, " " . $this->getIdString($obj, $uow) . " " . spl_object_hash($obj) . "\n");
}
}
}
}
}
}
}
fclose($fh);
}
public function setUp()
{
$reader = new \Doctrine\Common\Annotations\AnnotationReader();
$driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver($reader);
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(sys_get_temp_dir());
$config->setProxyNamespace('SimpleThings\\EntityAudit\\Tests\\Proxies');
$config->setMetadataDriverImpl($driver);
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
$auditConfig = new AuditConfiguration();
$auditConfig->setCurrentUsername("beberlei");
$auditConfig->setAuditedEntityClasses(array('SimpleThings\\EntityAudit\\Tests\\ArticleAudit', 'SimpleThings\\EntityAudit\\Tests\\UserAudit'));
$this->auditManager = new AuditManager($auditConfig);
$this->auditManager->registerEvents($evm = new EventManager());
#$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
$this->em = \Doctrine\ORM\EntityManager::create($conn, $config, $evm);
$schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em);
$schemaTool->createSchema(array($this->em->getClassMetadata('SimpleThings\\EntityAudit\\Tests\\ArticleAudit'), $this->em->getClassMetadata('SimpleThings\\EntityAudit\\Tests\\UserAudit')));
}
/**
* Walks down an InstanceOfExpression AST node, thereby generating the appropriate SQL.
*
* @param InstanceOfExpression
* @return string The SQL.
*/
public function walkInstanceOfExpression($instanceOfExpr)
{
$sql = '';
$dqlAlias = $instanceOfExpr->identificationVariable;
$discrClass = $class = $this->queryComponents[$dqlAlias]['metadata'];
if ($class->discriminatorColumn) {
$discrClass = $this->em->getClassMetadata($class->rootEntityName);
}
if ($this->useSqlTableAliases) {
$sql .= $this->getSQLTableAlias($discrClass->getTableName(), $dqlAlias) . '.';
}
$sql .= $class->discriminatorColumn['name'] . ($instanceOfExpr->not ? ' NOT IN ' : ' IN ');
$sqlParameterList = array();
foreach ($instanceOfExpr->value as $parameter) {
if ($parameter instanceof AST\InputParameter) {
// We need to modify the parameter value to be its correspondent mapped value
$dqlParamKey = $parameter->name;
$dqlParam = $this->query->getParameter($dqlParamKey);
$paramValue = $this->query->processParameterValue($dqlParam->getValue());
if (!$paramValue instanceof \Doctrine\ORM\Mapping\ClassMetadata) {
throw QueryException::invalidParameterType('ClassMetadata', get_class($paramValue));
}
$entityClassName = $paramValue->name;
} else {
// Get name from ClassMetadata to resolve aliases.
$entityClassName = $this->em->getClassMetadata($parameter)->name;
}
if ($entityClassName == $class->name) {
$sqlParameterList[] = $this->conn->quote($class->discriminatorValue);
} else {
$discrMap = array_flip($class->discriminatorMap);
if (!isset($discrMap[$entityClassName])) {
throw QueryException::instanceOfUnrelatedClass($entityClassName, $class->rootEntityName);
}
$sqlParameterList[] = $this->conn->quote($discrMap[$entityClassName]);
}
}
$sql .= '(' . implode(', ', $sqlParameterList) . ')';
return $sql;
}
/**
* @group DDC-3322
*/
public function testInvalidOrderByAssociationInverseSide()
{
$class = $this->em->getClassMetadata(__NAMESPACE__ . '\\DDC3322Three');
$ce = $this->validator->validateClass($class);
$this->assertEquals(array("The association Doctrine\\Tests\\ORM\\Tools\\DDC3322Three#invalidAssoc is ordered by a field oneToOneInverse " . "on Doctrine\\Tests\\ORM\\Tools\\DDC3322ValidEntity1 that is the inverse side of an association."), $ce);
}
/**
* {@inheritdoc}
*
* @param object $sourceEntity the entity source of this association
* @param object $targetEntity the entity to load data in
* @param EntityManager $em
* @param array $joinColumnValues Values of the join columns of $sourceEntity.
*/
public function load($sourceEntity, $targetEntity, $em, array $joinColumnValues = array())
{
$targetClass = $em->getClassMetadata($this->targetEntityName);
if ($this->isOwningSide) {
$inverseField = isset($targetClass->inverseMappings[$this->sourceEntityName][$this->sourceFieldName]) ? $targetClass->inverseMappings[$this->sourceEntityName][$this->sourceFieldName]->sourceFieldName : false;
// Mark inverse side as fetched in the hints, otherwise the UoW would
// try to load it in a separate query (remember: to-one inverse sides can not be lazy).
$hints = array();
if ($inverseField) {
$hints['fetched'][$targetClass->name][$inverseField] = true;
if ($targetClass->subClasses) {
foreach ($targetClass->subClasses as $targetSubclassName) {
$hints['fetched'][$targetSubclassName][$inverseField] = true;
}
}
}
/* cascade read-only status
if ($em->getUnitOfWork()->isReadOnly($sourceEntity)) {
$hints[Query::HINT_READ_ONLY] = true;
}
*/
$targetEntity = $em->getUnitOfWork()->getEntityPersister($this->targetEntityName)->load($joinColumnValues, $targetEntity, $this, $hints);
if ($targetEntity !== null && $inverseField && !$targetClass->isCollectionValuedAssociation($inverseField)) {
$targetClass->reflFields[$inverseField]->setValue($targetEntity, $sourceEntity);
}
} else {
$conditions = array();
$sourceClass = $em->getClassMetadata($this->sourceEntityName);
$owningAssoc = $targetClass->getAssociationMapping($this->mappedBy);
// TRICKY: since the association is specular source and target are flipped
foreach ($owningAssoc->targetToSourceKeyColumns as $sourceKeyColumn => $targetKeyColumn) {
if (isset($sourceClass->fieldNames[$sourceKeyColumn])) {
$conditions[$targetKeyColumn] = $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
} else {
throw MappingException::joinColumnMustPointToMappedField($sourceClass->name, $sourceKeyColumn);
}
}
$targetEntity = $em->getUnitOfWork()->getEntityPersister($this->targetEntityName)->load($conditions, $targetEntity, $this);
if ($targetEntity !== null) {
$targetClass->setFieldValue($targetEntity, $this->mappedBy, $sourceEntity);
}
}
return $targetEntity;
}
/**
* Walks down a CollectionMemberExpression AST node, thereby generating the appropriate SQL.
*
* @param CollectionMemberExpression
* @return string The SQL.
*/
public function walkCollectionMemberExpression($collMemberExpr)
{
$sql = $collMemberExpr->not ? 'NOT ' : '';
$sql .= 'EXISTS (SELECT 1 FROM ';
$entityExpr = $collMemberExpr->entityExpression;
$collPathExpr = $collMemberExpr->collectionValuedPathExpression;
$parts = $collPathExpr->parts;
$fieldName = array_pop($parts);
$dqlAlias = $collPathExpr->identificationVariable . (!empty($parts) ? '.' . implode('.', $parts) : '');
$class = $this->_queryComponents[$dqlAlias]['metadata'];
if ($entityExpr instanceof AST\InputParameter) {
$dqlParamKey = $entityExpr->name;
$entity = $this->_query->getParameter($dqlParamKey);
} else {
//TODO
throw new \BadMethodCallException("Not implemented");
}
$assoc = $class->associationMappings[$fieldName];
if ($assoc->isOneToMany()) {
$targetClass = $this->_em->getClassMetadata($assoc->targetEntityName);
$targetTableAlias = $this->getSqlTableAlias($targetClass->primaryTable['name']);
$sourceTableAlias = $this->getSqlTableAlias($class->primaryTable['name'], $dqlAlias);
$sql .= $targetClass->getQuotedTableName($this->_platform) . ' ' . $targetTableAlias . ' WHERE ';
$owningAssoc = $targetClass->associationMappings[$assoc->mappedBy];
$first = true;
foreach ($owningAssoc->targetToSourceKeyColumns as $targetColumn => $sourceColumn) {
if ($first) {
$first = false;
} else {
$sql .= ' AND ';
}
$sql .= $sourceTableAlias . '.' . $class->getQuotedColumnName($class->fieldNames[$targetColumn], $this->_platform) . ' = ' . $targetTableAlias . '.' . $sourceColumn;
}
$sql .= ' AND ';
$first = true;
foreach ($targetClass->identifier as $idField) {
if ($first) {
$first = false;
} else {
$sql .= ' AND ';
}
$this->_parserResult->addParameterMapping($dqlParamKey, $this->_sqlParamIndex++);
$sql .= $targetTableAlias . '.' . $targetClass->getQuotedColumnName($idField, $this->_platform) . ' = ?';
}
} else {
// many-to-many
$targetClass = $this->_em->getClassMetadata($assoc->targetEntityName);
$owningAssoc = $assoc->isOwningSide ? $assoc : $targetClass->associationMappings[$assoc->mappedBy];
$joinTable = $assoc->isOwningSide ? $assoc->joinTable : $owningAssoc->joinTable;
// SQL table aliases
$joinTableAlias = $this->getSqlTableAlias($joinTable['name']);
$targetTableAlias = $this->getSqlTableAlias($targetClass->primaryTable['name']);
$sourceTableAlias = $this->getSqlTableAlias($class->primaryTable['name'], $dqlAlias);
// join to target table
$sql .= $assoc->getQuotedJoinTableName($this->_platform) . ' ' . $joinTableAlias . ' INNER JOIN ' . $targetClass->getQuotedTableName($this->_platform) . ' ' . $targetTableAlias . ' ON ';
// join conditions
$joinColumns = $assoc->isOwningSide ? $joinTable['joinColumns'] : $joinTable['inverseJoinColumns'];
$referencedColumnClass = $assoc->isOwningSide ? $class : $targetClass;
$first = true;
foreach ($joinColumns as $joinColumn) {
if ($first) {
$first = false;
} else {
$sql .= ' AND ';
}
$sql .= $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $sourceTableAlias . '.' . $referencedColumnClass->getQuotedColumnName($referencedColumnClass->fieldNames[$joinColumn['referencedColumnName']], $this->_platform);
}
$sql .= ' WHERE ';
$joinColumns = $assoc->isOwningSide ? $joinTable['inverseJoinColumns'] : $joinTable['joinColumns'];
$first = true;
foreach ($joinColumns as $joinColumn) {
if ($first) {
$first = false;
} else {
$sql .= ' AND ';
}
$sql .= $joinTableAlias . '.' . $joinColumn['name'] . ' = ' . $targetTableAlias . '.' . $referencedColumnClass->getQuotedColumnName($referencedColumnClass->fieldNames[$joinColumn['referencedColumnName']], $this->_platform);
}
$sql .= ' AND ';
$first = true;
foreach ($targetClass->identifier as $idField) {
if ($first) {
$first = false;
} else {
$sql .= ' AND ';
}
$this->_parserResult->addParameterMapping($dqlParamKey, $this->_sqlParamIndex++);
$sql .= $targetTableAlias . '.' . $targetClass->getQuotedColumnName($idField, $this->_platform) . ' = ?';
}
}
return $sql . ')';
}
/**
* Allows changing the name to insert data to given the EntityManager
*
* @param EntityManager $em
* @return void
*/
protected function changeTableName($em)
{
$cm = $em->getClassMetadata('AppBundle:Movie');
$cm->setTableName('movies');
}
/**
* @group DDC-1649
*/
public function testInvalidTripleAssociationAsKeyMapping()
{
$classThree = $this->em->getClassMetadata(__NAMESPACE__ . '\\DDC1649Three');
$ce = $this->validator->validateClass($classThree);
$this->assertEquals(array("Cannot map association 'Doctrine\\Tests\\ORM\\Tools\\DDC1649Three#two as identifier, because the target entity 'Doctrine\\Tests\\ORM\\Tools\\DDC1649Two' also maps an association as identifier.", "The referenced column name 'id' has to be a primary key column on the target entity class 'Doctrine\\Tests\\ORM\\Tools\\DDC1649Two'."), $ce);
}
/**
* {@inheritdoc}
*
* @param object $owningEntity
* @param object $targetEntity
* @param EntityManager $em
*/
public function load($owningEntity, $targetEntity, $em)
{
$sourceClass = $em->getClassMetadata($this->sourceEntityName);
$targetClass = $em->getClassMetadata($this->targetEntityName);
$conditions = array();
if ($this->isOwningSide) {
foreach ($this->sourceToTargetKeyColumns as $sourceKeyColumn => $targetKeyColumn) {
$conditions[$targetKeyColumn] = $sourceClass->getReflectionProperty($sourceClass->getFieldName($sourceKeyColumn))->getValue($owningEntity);
}
if ($targetClass->hasInverseAssociation($this->sourceFieldName)) {
$targetClass->setFieldValue($targetEntity, $targetClass->inverseMappings[$this->_sourceFieldName]->getSourceFieldName(), $owningEntity);
}
} else {
$owningAssoc = $em->getClassMetadata($this->targetEntityName)->getAssociationMapping($this->mappedByFieldName);
foreach ($owningAssoc->getTargetToSourceKeyColumns() as $targetKeyColumn => $sourceKeyColumn) {
$conditions[$sourceKeyColumn] = $sourceClass->getReflectionProperty($sourceClass->getFieldName($targetKeyColumn))->getValue($owningEntity);
}
$targetClass->setFieldValue($targetEntity, $this->mappedByFieldName, $owningEntity);
}
$em->getUnitOfWork()->getEntityPersister($this->targetEntityName)->load($conditions, $targetEntity);
}
