Doctrine2 ifadeleri silmek için filtreleri uygular

Question

Doktrin filtrelerini kullanıyorum ve son zamanlarda filtrelerin ifadeleri silmek için uygulanmadığını fark ettim. Dokümanları ve Google'ı incelemeyi denedim, ancak gizem çözümsüz kalıyor. Örneğin

Öyle gibi her seçme sorgusu şirkete kullanıcıyı bağlayan filtresi vardır: kullanıcı t0 GELEN

$userRepo->find(12); 

ve

SEÇ dan değiştirilir .... NEREDE t0.id =

içine 12

SEÇ .... kullanıcı t0 WHERE t0.id = 12 AND (t0.company_id = '6')

serin, tek ihtiyacım budur.

Beni rahatsız eden şey, silme ifadelerinin dokunulmamış gibi görünmesidir. Varsayılan doktrin mimarisi mi yoksa yapılandırmamın yanlış mı olduğunu bilen var mı?

filtre Doktrini Depoları bir silme (id) sahip değil gibi

use Doctrine\ORM\Mapping\ClassMetaData; 
use Doctrine\ORM\Query\Filter\SQLFilter; 
use Doctrine\Common\Annotations\Reader; 

class CompanyAware extends SQLFilter 
{ 
    /** 
    * @var Reader 
    */ 
    protected $reader; 

    /** 
    * @param ClassMetaData $targetEntity 
    * @param string $targetTableAlias 
    * 
    * @return string 
    */ 
    public function addFilterConstraint(ClassMetadata $targetEntity, $targetTableAlias) 
    { 
     $query = ''; 
     $ann = 'Mrok\\PortalBundle\\Annotation\\CompanyAware'; 
     $isAware = $this->reader->getClassAnnotation($targetEntity->getReflectionClass(), $ann); 

     if ($isAware) { 
      $id = $this->getParameter('id'); 
      $query = sprintf('%s.company_id = %s', $targetTableAlias, $id); 
     } 

     return $query; 
    } 

    public function setAnnotationReader(Reader $reader) 
    { 
     $this->reader = $reader; 
    } 
} 

Answer 1

veya deleteBy (ölçüt) yerleşik bir, senin de $ em-> kaldırmak kastediyoruz varsayalım olarak ($ işletme); veya DQL. Kod'a bakın (aşağıya bakın) Ne kaldırılsın ya da çağırın. SQL'i çalıştırmadan önce filtreleri uygulayın. Belgeler, filtrelerin DQL'ye uygulanması gerektiğini gösterir.

http://doctrine-orm.readthedocs.org/en/latest/reference/filters.html

/** 
* Deletes a managed entity. 
* 
* The entity to delete must be managed and have a persistent identifier. 
* The deletion happens instantaneously. 
* 
* Subclasses may override this method to customize the semantics of entity deletion. 
* 
* @param object $entity The entity to delete. 
* 
* @return void 
*/ 
public function delete($entity) 
{ 
    $class  = $this->class; 
    $em   = $this->em; 

    $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity); 
    $tableName = $this->quoteStrategy->getTableName($class, $this->platform); 
    $idColumns = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform); 
    $id   = array_combine($idColumns, $identifier); 
    $types  = array_map(function ($identifier) use ($class, $em) { 

     if (isset($class->fieldMappings[$identifier])) { 
      return $class->fieldMappings[$identifier]['type']; 
     } 

     $targetMapping = $em->getClassMetadata($class->associationMappings[$identifier]['targetEntity']); 

     if (isset($targetMapping->fieldMappings[$targetMapping->identifier[0]])) { 
      return $targetMapping->fieldMappings[$targetMapping->identifier[0]]['type']; 
     } 

     if (isset($targetMapping->associationMappings[$targetMapping->identifier[0]])) { 
      return $targetMapping->associationMappings[$targetMapping->identifier[0]]['type']; 
     } 

     throw ORMException::unrecognizedField($targetMapping->identifier[0]); 

    }, $class->identifier); 

    $this->deleteJoinTableRecords($identifier); 
    $this->conn->delete($tableName, $id, $types); 
} 

/** 
* @todo Add check for platform if it supports foreign keys/cascading. 
* 
* @param array $identifier 
* 
* @return void 
*/ 
protected function deleteJoinTableRecords($identifier) 
{ 
    foreach ($this->class->associationMappings as $mapping) { 
     if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY) { 
      continue; 
     } 

     // @Todo this only covers scenarios with no inheritance or of the same level. Is there something 
     // like self-referential relationship between different levels of an inheritance hierarchy? I hope not! 
     $selfReferential = ($mapping['targetEntity'] == $mapping['sourceEntity']); 
     $class   = $this->class; 
     $association  = $mapping; 
     $otherColumns = array(); 
     $otherKeys  = array(); 
     $keys   = array(); 

     if (! $mapping['isOwningSide']) { 
      $class  = $this->em->getClassMetadata($mapping['targetEntity']); 
      $association = $class->associationMappings[$mapping['mappedBy']]; 
     } 

     $joinColumns = $mapping['isOwningSide'] 
      ? $association['joinTable']['joinColumns'] 
      : $association['joinTable']['inverseJoinColumns']; 


     if ($selfReferential) { 
      $otherColumns = (! $mapping['isOwningSide']) 
       ? $association['joinTable']['joinColumns'] 
       : $association['joinTable']['inverseJoinColumns']; 
     } 

     foreach ($joinColumns as $joinColumn) { 
      $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform); 
     } 

     foreach ($otherColumns as $joinColumn) { 
      $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform); 
     } 

     if (isset($mapping['isOnDeleteCascade'])) { 
      continue; 
     } 

     $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform); 

     $this->conn->delete($joinTableName, array_combine($keys, $identifier)); 

     if ($selfReferential) { 
      $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier)); 
     } 
    } 
}