vendor/doctrine/orm/lib/Doctrine/ORM/Cache/Persister/Entity/AbstractEntityPersister.php

   1 <?php
   2
   3 /*
   4  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   5  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   6  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   7  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   8  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   9  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  10  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  11  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  12  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  13  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  14  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  15  *
  16  * This software consists of voluntary contributions made by many individuals
  17  * and is licensed under the MIT license. For more information, see
  18  * <http://www.doctrine-project.org>.
  19  */
  20
  21 namespace Doctrine\ORM\Cache\Persister\Entity;
  22
  23 use Doctrine\ORM\Cache;
  24 use Doctrine\ORM\Cache\Region;
  25 use Doctrine\ORM\Cache\EntityCacheKey;
  26 use Doctrine\ORM\Cache\CollectionCacheKey;
  27 use Doctrine\ORM\Cache\TimestampCacheKey;
  28 use Doctrine\ORM\Cache\QueryCacheKey;
  29 use Doctrine\ORM\Cache\Persister\CachedPersister;
  30 use Doctrine\ORM\Cache\CacheException;
  31 use Doctrine\ORM\Mapping\ClassMetadata;
  32 use Doctrine\ORM\PersistentCollection;
  33 use Doctrine\ORM\EntityManagerInterface;
  34 use Doctrine\ORM\Persisters\Entity\EntityPersister;
  35
  36 use Doctrine\Common\Util\ClassUtils;
  37 use Doctrine\Common\Collections\Criteria;
  38
  39 /**
  40  * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
  41  * @since 2.5
  42  */
  43 abstract class AbstractEntityPersister implements CachedEntityPersister
  44 {
  45      /**
  46      * @var \Doctrine\ORM\UnitOfWork
  47      */
  48     protected $uow;
  49
  50     /**
  51      * @var \Doctrine\ORM\Mapping\ClassMetadataFactory
  52      */
  53     protected $metadataFactory;
  54
  55     /**
  56      * @var \Doctrine\ORM\Persisters\Entity\EntityPersister
  57      */
  58     protected $persister;
  59
  60     /**
  61      * @var \Doctrine\ORM\Mapping\ClassMetadata
  62      */
  63     protected $class;
  64
  65      /**
  66      * @var array
  67      */
  68     protected $queuedCache = array();
  69
  70     /**
  71      * @var \Doctrine\ORM\Cache\Region
  72      */
  73     protected $region;
  74
  75     /**
  76      * @var \Doctrine\ORM\Cache\TimestampRegion
  77      */
  78     protected $timestampRegion;
  79
  80     /**
  81      * @var \Doctrine\ORM\Cache\TimestampCacheKey
  82      */
  83     protected $timestampKey;
  84
  85     /**
  86      * @var \Doctrine\ORM\Cache\EntityHydrator
  87      */
  88     protected $hydrator;
  89
  90     /**
  91      * @var \Doctrine\ORM\Cache
  92      */
  93     protected $cache;
  94
  95     /**
  96      * @var \Doctrine\ORM\Cache\Logging\CacheLogger
  97      */
  98     protected $cacheLogger;
  99
 100     /**
 101      * @var string
 102      */
 103     protected $regionName;
 104
 105     /**
 106      * Associations configured as FETCH_EAGER, as well as all inverse one-to-one associations.
 107      *
 108      * @var array
 109      */
 110     protected $joinedAssociations;
 111
 112     /**
 113      * @param \Doctrine\ORM\Persisters\Entity\EntityPersister $persister The entity persister to cache.
 114      * @param \Doctrine\ORM\Cache\Region                      $region    The entity cache region.
 115      * @param \Doctrine\ORM\EntityManagerInterface            $em        The entity manager.
 116      * @param \Doctrine\ORM\Mapping\ClassMetadata             $class     The entity metadata.
 117      */
 118     public function __construct(EntityPersister $persister, Region $region, EntityManagerInterface $em, ClassMetadata $class)
 119     {
 120         $configuration  = $em->getConfiguration();
 121         $cacheConfig    = $configuration->getSecondLevelCacheConfiguration();
 122         $cacheFactory   = $cacheConfig->getCacheFactory();
 123
 124         $this->class            = $class;
 125         $this->region           = $region;
 126         $this->persister        = $persister;
 127         $this->cache            = $em->getCache();
 128         $this->regionName       = $region->getName();
 129         $this->uow              = $em->getUnitOfWork();
 130         $this->metadataFactory  = $em->getMetadataFactory();
 131         $this->cacheLogger      = $cacheConfig->getCacheLogger();
 132         $this->timestampRegion  = $cacheFactory->getTimestampRegion();
 133         $this->hydrator         = $cacheFactory->buildEntityHydrator($em, $class);
 134         $this->timestampKey     = new TimestampCacheKey($this->class->rootEntityName);
 135     }
 136
 137     /**
 138      * {@inheritdoc}
 139      */
 140     public function addInsert($entity)
 141     {
 142         $this->persister->addInsert($entity);
 143     }
 144
 145     /**
 146      * {@inheritdoc}
 147      */
 148     public function getInserts()
 149     {
 150         return $this->persister->getInserts();
 151     }
 152
 153     /**
 154      * {@inheritdoc}
 155      */
 156     public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, array $orderBy = null)
 157     {
 158         return $this->persister->getSelectSQL($criteria, $assoc, $lockMode, $limit, $offset, $orderBy);
 159     }
 160
 161     /**
 162      * {@inheritDoc}
 163      */
 164     public function getCountSQL($criteria = array())
 165     {
 166         return $this->persister->getCountSQL($criteria);
 167     }
 168
 169     /**
 170      * {@inheritdoc}
 171      */
 172     public function getInsertSQL()
 173     {
 174         return $this->persister->getInsertSQL();
 175     }
 176
 177     /**
 178      * {@inheritdoc}
 179      */
 180     public function getResultSetMapping()
 181     {
 182         return $this->persister->getResultSetMapping();
 183     }
 184
 185     /**
 186      * {@inheritdoc}
 187      */
 188     public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
 189     {
 190         return $this->persister->getSelectConditionStatementSQL($field, $value, $assoc, $comparison);
 191     }
 192
 193     /**
 194      * {@inheritdoc}
 195      */
 196     public function exists($entity, Criteria $extraConditions = null)
 197     {
 198         if (null === $extraConditions) {
 199             $key = new EntityCacheKey($this->class->rootEntityName, $this->class->getIdentifierValues($entity));
 200
 201             if ($this->region->contains($key)) {
 202                 return true;
 203             }
 204         }
 205
 206         return $this->persister->exists($entity, $extraConditions);
 207     }
 208
 209     /**
 210      * {@inheritdoc}
 211      */
 212     public function getCacheRegion()
 213     {
 214         return $this->region;
 215     }
 216
 217     /**
 218      * @return \Doctrine\ORM\Cache\EntityHydrator
 219      */
 220     public function getEntityHydrator()
 221     {
 222         return $this->hydrator;
 223     }
 224
 225     /**
 226      * {@inheritdoc}
 227      */
 228     public function storeEntityCache($entity, EntityCacheKey $key)
 229     {
 230         $class      = $this->class;
 231         $className  = ClassUtils::getClass($entity);
 232
 233         if ($className !== $this->class->name) {
 234             $class = $this->metadataFactory->getMetadataFor($className);
 235         }
 236
 237         if ($class->containsForeignIdentifier) {
 238             foreach ($class->associationMappings as $name => $assoc) {
 239                 if (!empty($assoc['id']) && !isset($assoc['cache'])) {
 240                     throw CacheException::nonCacheableEntityAssociation($class->name, $name);
 241                 }
 242             }
 243         }
 244
 245         $entry  = $this->hydrator->buildCacheEntry($class, $key, $entity);
 246         $cached = $this->region->put($key, $entry);
 247
 248         if ($this->cacheLogger && $cached) {
 249             $this->cacheLogger->entityCachePut($this->regionName, $key);
 250         }
 251
 252         return $cached;
 253     }
 254
 255     /**
 256      * @param object $entity
 257      */
 258     private function storeJoinedAssociations($entity)
 259     {
 260         if ($this->joinedAssociations === null) {
 261             $associations = array();
 262
 263             foreach ($this->class->associationMappings as $name => $assoc) {
 264                 if (isset($assoc['cache']) &&
 265                     ($assoc['type'] & ClassMetadata::TO_ONE) &&
 266                     ($assoc['fetch'] === ClassMetadata::FETCH_EAGER || ! $assoc['isOwningSide'])) {
 267
 268                     $associations[] = $name;
 269                 }
 270             }
 271
 272             $this->joinedAssociations = $associations;
 273         }
 274
 275         foreach ($this->joinedAssociations as $name) {
 276             $assoc       = $this->class->associationMappings[$name];
 277             $assocEntity = $this->class->getFieldValue($entity, $name);
 278
 279             if ($assocEntity === null) {
 280                 continue;
 281             }
 282
 283             $assocId        = $this->uow->getEntityIdentifier($assocEntity);
 284             $assocKey       = new EntityCacheKey($assoc['targetEntity'], $assocId);
 285             $assocPersister = $this->uow->getEntityPersister($assoc['targetEntity']);
 286
 287             $assocPersister->storeEntityCache($assocEntity, $assocKey);
 288         }
 289     }
 290
 291     /**
 292      * Generates a string of currently query
 293      *
 294      * @param array $query
 295      * @param string $criteria
 296      * @param array $orderBy
 297      * @param integer $limit
 298      * @param integer $offset
 299      *
 300      * @return string
 301      */
 302     protected function getHash($query, $criteria, array $orderBy = null, $limit = null, $offset = null)
 303     {
 304         list($params) = ($criteria instanceof Criteria)
 305             ? $this->persister->expandCriteriaParameters($criteria)
 306             : $this->persister->expandParameters($criteria);
 307
 308         return sha1($query . serialize($params) . serialize($orderBy) . $limit . $offset);
 309     }
 310
 311     /**
 312      * {@inheritdoc}
 313      */
 314     public function expandParameters($criteria)
 315     {
 316         return $this->persister->expandParameters($criteria);
 317     }
 318
 319     /**
 320      * {@inheritdoc}
 321      */
 322     public function expandCriteriaParameters(Criteria $criteria)
 323     {
 324         return $this->persister->expandCriteriaParameters($criteria);
 325     }
 326
 327     /**
 328      * {@inheritdoc}
 329      */
 330     public function getClassMetadata()
 331     {
 332         return $this->persister->getClassMetadata();
 333     }
 334
 335     /**
 336      * {@inheritdoc}
 337      */
 338     public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
 339     {
 340         return $this->persister->getManyToManyCollection($assoc, $sourceEntity, $offset, $limit);
 341     }
 342
 343     /**
 344      * {@inheritdoc}
 345      */
 346     public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
 347     {
 348         return $this->persister->getOneToManyCollection($assoc, $sourceEntity, $offset, $limit);
 349     }
 350
 351     /**
 352      * {@inheritdoc}
 353      */
 354     public function getOwningTable($fieldName)
 355     {
 356         return $this->persister->getOwningTable($fieldName);
 357     }
 358
 359     /**
 360      * {@inheritdoc}
 361      */
 362     public function executeInserts()
 363     {
 364         $this->queuedCache['insert'] = $this->persister->getInserts();
 365
 366         return $this->persister->executeInserts();
 367     }
 368
 369     /**
 370      * {@inheritdoc}
 371      */
 372     public function load(array $criteria, $entity = null, $assoc = null, array $hints = array(), $lockMode = null, $limit = null, array $orderBy = null)
 373     {
 374         if ($entity !== null || $assoc !== null || ! empty($hints) || $lockMode !== null) {
 375             return $this->persister->load($criteria, $entity, $assoc, $hints, $lockMode, $limit, $orderBy);
 376         }
 377
 378         //handle only EntityRepository#findOneBy
 379         $query      = $this->persister->getSelectSQL($criteria, null, null, $limit, null, $orderBy);
 380         $hash       = $this->getHash($query, $criteria, null, null, null);
 381         $rsm        = $this->getResultSetMapping();
 382         $queryKey   = new QueryCacheKey($hash, 0, Cache::MODE_NORMAL, $this->timestampKey);
 383         $queryCache = $this->cache->getQueryCache($this->regionName);
 384         $result     = $queryCache->get($queryKey, $rsm);
 385
 386         if ($result !== null) {
 387             if ($this->cacheLogger) {
 388                 $this->cacheLogger->queryCacheHit($this->regionName, $queryKey);
 389             }
 390
 391             return $result[0];
 392         }
 393
 394         if (($result = $this->persister->load($criteria, $entity, $assoc, $hints, $lockMode, $limit, $orderBy)) === null) {
 395             return null;
 396         }
 397
 398         $cached = $queryCache->put($queryKey, $rsm, array($result));
 399
 400         if ($this->cacheLogger) {
 401             if ($result) {
 402                 $this->cacheLogger->queryCacheMiss($this->regionName, $queryKey);
 403             }
 404
 405             if ($cached) {
 406                 $this->cacheLogger->queryCachePut($this->regionName, $queryKey);
 407             }
 408         }
 409
 410         return $result;
 411     }
 412
 413     /**
 414      * {@inheritdoc}
 415      */
 416     public function loadAll(array $criteria = array(), array $orderBy = null, $limit = null, $offset = null)
 417     {
 418         $query      = $this->persister->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
 419         $hash       = $this->getHash($query, $criteria, null, null, null);
 420         $rsm        = $this->getResultSetMapping();
 421         $queryKey   = new QueryCacheKey($hash, 0, Cache::MODE_NORMAL, $this->timestampKey);
 422         $queryCache = $this->cache->getQueryCache($this->regionName);
 423         $result     = $queryCache->get($queryKey, $rsm);
 424
 425         if ($result !== null) {
 426             if ($this->cacheLogger) {
 427                 $this->cacheLogger->queryCacheHit($this->regionName, $queryKey);
 428             }
 429
 430             return $result;
 431         }
 432
 433         $result = $this->persister->loadAll($criteria, $orderBy, $limit, $offset);
 434         $cached = $queryCache->put($queryKey, $rsm, $result);
 435
 436         if ($this->cacheLogger) {
 437             if ($result) {
 438                 $this->cacheLogger->queryCacheMiss($this->regionName, $queryKey);
 439             }
 440
 441             if ($cached) {
 442                 $this->cacheLogger->queryCachePut($this->regionName, $queryKey);
 443             }
 444         }
 445
 446         return $result;
 447     }
 448
 449     /**
 450      * {@inheritdoc}
 451      */
 452     public function loadById(array $identifier, $entity = null)
 453     {
 454         $cacheKey   = new EntityCacheKey($this->class->rootEntityName, $identifier);
 455         $cacheEntry = $this->region->get($cacheKey);
 456         $class      = $this->class;
 457
 458         if ($cacheEntry !== null) {
 459             if ($cacheEntry->class !== $this->class->name) {
 460                 $class = $this->metadataFactory->getMetadataFor($cacheEntry->class);
 461             }
 462
 463             if (($entity = $this->hydrator->loadCacheEntry($class, $cacheKey, $cacheEntry, $entity)) !== null) {
 464                 if ($this->cacheLogger) {
 465                     $this->cacheLogger->entityCacheHit($this->regionName, $cacheKey);
 466                 }
 467
 468                 return $entity;
 469             }
 470         }
 471
 472         $entity = $this->persister->loadById($identifier, $entity);
 473
 474         if ($entity === null) {
 475             return null;
 476         }
 477
 478         $class      = $this->class;
 479         $className  = ClassUtils::getClass($entity);
 480
 481         if ($className !== $this->class->name) {
 482             $class = $this->metadataFactory->getMetadataFor($className);
 483         }
 484
 485         $cacheEntry = $this->hydrator->buildCacheEntry($class, $cacheKey, $entity);
 486         $cached     = $this->region->put($cacheKey, $cacheEntry);
 487
 488         if ($cached && ($this->joinedAssociations === null || count($this->joinedAssociations) > 0)) {
 489             $this->storeJoinedAssociations($entity);
 490         }
 491
 492         if ($this->cacheLogger) {
 493             if ($cached) {
 494                 $this->cacheLogger->entityCachePut($this->regionName, $cacheKey);
 495             }
 496
 497             $this->cacheLogger->entityCacheMiss($this->regionName, $cacheKey);
 498         }
 499
 500         return $entity;
 501     }
 502
 503     /**
 504      * {@inheritDoc}
 505      */
 506     public function count($criteria = array())
 507     {
 508         return $this->persister->count($criteria);
 509     }
 510
 511     /**
 512      * {@inheritdoc}
 513      */
 514     public function loadCriteria(Criteria $criteria)
 515     {
 516         $orderBy     = $criteria->getOrderings();
 517         $limit       = $criteria->getMaxResults();
 518         $offset      = $criteria->getFirstResult();
 519         $query       = $this->persister->getSelectSQL($criteria);
 520         $hash        = $this->getHash($query, $criteria, $orderBy, $limit, $offset);
 521         $rsm         = $this->getResultSetMapping();
 522         $queryKey    = new QueryCacheKey($hash, 0, Cache::MODE_NORMAL, $this->timestampKey);
 523         $queryCache  = $this->cache->getQueryCache($this->regionName);
 524         $cacheResult = $queryCache->get($queryKey, $rsm);
 525
 526         if ($cacheResult !== null) {
 527             if ($this->cacheLogger) {
 528                 $this->cacheLogger->queryCacheHit($this->regionName, $queryKey);
 529             }
 530
 531             return $cacheResult;
 532         }
 533
 534         $result = $this->persister->loadCriteria($criteria);
 535         $cached = $queryCache->put($queryKey, $rsm, $result);
 536
 537         if ($this->cacheLogger) {
 538             if ($result) {
 539                 $this->cacheLogger->queryCacheMiss($this->regionName, $queryKey);
 540             }
 541
 542             if ($cached) {
 543                 $this->cacheLogger->queryCachePut($this->regionName, $queryKey);
 544             }
 545         }
 546
 547         return $result;
 548     }
 549
 550     /**
 551      * {@inheritdoc}
 552      */
 553     public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $coll)
 554     {
 555         $persister = $this->uow->getCollectionPersister($assoc);
 556         $hasCache  = ($persister instanceof CachedPersister);
 557         $key       = null;
 558
 559         if ($hasCache) {
 560             $ownerId = $this->uow->getEntityIdentifier($coll->getOwner());
 561             $key     = new CollectionCacheKey($assoc['sourceEntity'], $assoc['fieldName'], $ownerId);
 562             $list    = $persister->loadCollectionCache($coll, $key);
 563
 564             if ($list !== null) {
 565                 if ($this->cacheLogger) {
 566                     $this->cacheLogger->collectionCacheHit($persister->getCacheRegion()->getName(), $key);
 567                 }
 568
 569                 return $list;
 570             }
 571         }
 572
 573         $list = $this->persister->loadManyToManyCollection($assoc, $sourceEntity, $coll);
 574
 575         if ($hasCache) {
 576             $persister->storeCollectionCache($key, $list);
 577
 578             if ($this->cacheLogger) {
 579                 $this->cacheLogger->collectionCacheMiss($persister->getCacheRegion()->getName(), $key);
 580             }
 581         }
 582
 583         return $list;
 584     }
 585
 586     /**
 587      * {@inheritdoc}
 588      */
 589     public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $coll)
 590     {
 591         $persister = $this->uow->getCollectionPersister($assoc);
 592         $hasCache  = ($persister instanceof CachedPersister);
 593
 594         if ($hasCache) {
 595             $ownerId = $this->uow->getEntityIdentifier($coll->getOwner());
 596             $key     = new CollectionCacheKey($assoc['sourceEntity'], $assoc['fieldName'], $ownerId);
 597             $list    = $persister->loadCollectionCache($coll, $key);
 598
 599             if ($list !== null) {
 600                 if ($this->cacheLogger) {
 601                     $this->cacheLogger->collectionCacheHit($persister->getCacheRegion()->getName(), $key);
 602                 }
 603
 604                 return $list;
 605             }
 606         }
 607
 608         $list = $this->persister->loadOneToManyCollection($assoc, $sourceEntity, $coll);
 609
 610         if ($hasCache) {
 611             $persister->storeCollectionCache($key, $list);
 612
 613             if ($this->cacheLogger) {
 614                 $this->cacheLogger->collectionCacheMiss($persister->getCacheRegion()->getName(), $key);
 615             }
 616         }
 617
 618         return $list;
 619     }
 620
 621     /**
 622      * {@inheritdoc}
 623      */
 624     public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = array())
 625     {
 626         return $this->persister->loadOneToOneEntity($assoc, $sourceEntity, $identifier);
 627     }
 628
 629     /**
 630      * {@inheritdoc}
 631      */
 632     public function lock(array $criteria, $lockMode)
 633     {
 634         $this->persister->lock($criteria, $lockMode);
 635     }
 636
 637     /**
 638      * {@inheritdoc}
 639      */
 640     public function refresh(array $id, $entity, $lockMode = null)
 641     {
 642         $this->persister->refresh($id, $entity, $lockMode);
 643     }
 644
 645 }