Get the entity mapper
| public getMapper ( ) : Bravo3\Orm\Mappers\MapperInterface | ||
| return | Bravo3\Orm\Mappers\MapperInterface | |
/**
* Will rebuild a table, repairing indices and re-serialising content
*
* The end result will be:
* - new inverse indices will be created
* - changes to serialisation will be updated on all entities
* - added/removed fields will be updated on all entities
*
* @param string $class_name
* @param int $batch_size
*/
public function rebuild($class_name, $batch_size = 100)
{
$this->maintenanceOperation(function () use($class_name, $batch_size) {
$metadata = $this->entity_manager->getMapper()->getEntityMetadata($class_name);
$this->logger->info("Rebuilding `" . $metadata->getTableName() . "`..");
$records = $this->entity_manager->indexedQuery(new IndexedQuery($class_name, ['@id' => '*']), false);
$this->logger->info(number_format($records->count()) . ' records to rebuild, ' . number_format($batch_size) . ' at a time');
$ts = microtime(true);
$this->rebuildRecords($records, $metadata, $batch_size);
$delta = microtime(true) - $ts;
$this->logger->info("Rebuild of `" . $metadata->getTableName() . "` completed in " . number_format($delta, 2) . " seconds");
});
}
/**
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testComplexSerialisation(EntityManager $em)
{
$serialiser = new JsonSerialiser();
$time = new \DateTime();
$product = new Product();
$product->setCreateTime($time);
$metadata = $em->getMapper()->getEntityMetadata($product);
$data = $serialiser->serialise($metadata, $product);
$new_product = new Product();
$serialiser->deserialise($metadata, $data, $new_product);
$this->assertEquals($time->format(self::DATE_FORMAT), $new_product->getCreateTime()->format(self::DATE_FORMAT));
}
/**
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testIndex(EntityManager $em)
{
$entity = new IndexedEntity();
$entity->setId1(100)->setId2('id2');
$entity->setAlpha('alpha')->setBravo('200')->setCharlie(true);
$metadata = $em->getMapper()->getEntityMetadata($entity);
$reader = new Reader($metadata, $entity);
$this->assertEquals('100.id2', $reader->getId());
$indices = $metadata->getIndices();
$this->assertCount(3, $indices);
$ab = $metadata->getIndexByName('ab');
$this->assertContains('alpha', $ab->getColumns());
$this->assertContains('bravo', $ab->getColumns());
$this->assertCount(2, $ab->getColumns());
$this->assertEquals('alpha.200', $reader->getIndexValue($ab));
$bc = $metadata->getIndexByName('bc');
$this->assertContains('bravo', $bc->getColumns());
$this->assertContains('getCharlie', $bc->getMethods());
$this->assertCount(1, $bc->getColumns());
$this->assertCount(1, $bc->getMethods());
$this->assertEquals('200.1', $reader->getIndexValue($bc));
$b = $metadata->getIndexByName('b');
$this->assertContains('bravo', $b->getColumns());
$this->assertCount(1, $b->getColumns());
$this->assertEquals('200', $reader->getIndexValue($b));
$em->persist($entity)->flush();
/** @var IndexedEntity $retrieved */
$retrieved = $em->retrieve(self::INDEXED_ENTITY, '100.id2');
$retrieved->setAlpha('omega')->setId1(101);
$em->persist($retrieved)->flush();
try {
$em->retrieveByIndex(self::INDEXED_ENTITY, 'ab', 'alpha.200');
$this->fail("Former index was found");
} catch (NotFoundException $e) {
}
/** @var IndexedEntity $retrieved_by_index */
$retrieved_by_index = $em->retrieveByIndex(self::INDEXED_ENTITY, 'ab', 'omega.200');
$this->assertEquals(101, $retrieved_by_index->getId1());
$this->assertEquals('id2', $retrieved_by_index->getId2());
$this->assertSame('omega', $retrieved_by_index->getAlpha());
$this->assertSame(200, $retrieved_by_index->getBravo());
$this->assertSame(true, $retrieved_by_index->getCharlie());
}
/**
* Hydrate a relationship
*
* @param Relationship $relative
* @return $this
*/
public function hydrateRelative(Relationship $relative)
{
$this->entity_manager->getDriver()->debugLog("Hydrating relative for " . $this->metadata->getTableName() . "[" . $this->getReader()->getId() . "]::" . $relative->getName());
$setter = $relative->getSetter();
$key = $this->entity_manager->getKeyScheme()->getRelationshipKey($relative, $this->entity_manager->getMapper()->getEntityMetadata($relative->getSource())->getTableName(), $this->entity_manager->getMapper()->getEntityMetadata($relative->getTarget())->getTableName(), $this->getReader()->getId());
if (RelationshipType::isMultiIndex($relative->getRelationshipType())) {
$items = [];
$ids = $this->entity_manager->getDriver()->getMultiValueIndex($key);
foreach ($ids as $id) {
$items[] = $this->entity_manager->retrieveEntityOrNew($relative->getTarget(), $id);
}
$this->proxy->{$setter}($items);
} else {
$id = $this->entity_manager->getDriver()->getSingleValueIndex($key);
if ($id) {
$this->proxy->{$setter}($this->entity_manager->retrieve($relative->getTarget(), $id));
}
}
return $this;
}
/**
* Get the mapper belonging to the entity manager
*
* @return MapperInterface
*/
protected function getMapper()
{
return $this->entity_manager->getMapper();
}
/**
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testRebuildIndex(EntityManager $em)
{
// Create an article with a slug
$article = new SluggedArticle();
$article->setId(8343)->setName('foo')->setSlug('bar');
$em->persist($article)->flush();
// Confirm slug works
/** @var SluggedArticle $article */
$article = $em->retrieveByIndex(SluggedArticle::class, 'slug', 'bar', false);
$this->assertEquals('foo', $article->getName());
$index = $em->getMapper()->getEntityMetadata($article)->getIndexByName('slug');
// Corrupt the slug, two steps required:
// 1. Set a new slug
$em->getDriver()->setSingleValueIndex($em->getKeyScheme()->getIndexKey($index, 'evil'), $article->getId());
// 2. Remove the correct slug
$em->getDriver()->clearSingleValueIndex($em->getKeyScheme()->getIndexKey($index, 'bar'));
$em->getDriver()->flush();
// Confirm old slug no longer works
try {
$em->retrieveByIndex(SluggedArticle::class, 'slug', 'bar', false);
$this->fail('Old index succeeded');
} catch (NotFoundException $e) {
}
// Confirm new slug does work
$article = $em->retrieveByIndex(SluggedArticle::class, 'slug', 'evil', false);
$this->assertEquals('foo', $article->getName());
// Run maintenance over the table, this should correct the slug
$maintenance = new Maintenance($em);
$maintenance->rebuild(SluggedArticle::class);
// Confirm correct slug works
$article = $em->retrieveByIndex(SluggedArticle::class, 'slug', 'bar', false);
$this->assertEquals('foo', $article->getName());
// The corrupted slug should still work, this is unideal, but there is no reference to it for the maintenance
// service to know to remove it
$article = $em->retrieveByIndex(SluggedArticle::class, 'slug', 'evil', false);
$this->assertEquals('foo', $article->getName());
}
/**
* @dataProvider entityManagerDataProvider
* @param EntityManager $em
*/
public function testDereferencing(EntityManager $em)
{
$mapper = $em->getMapper();
if ($mapper instanceof DereferencingMapperInterface) {
$class_name = $mapper->getClassFromTable('slugged_article');
$this->assertEquals(SluggedArticle::class, $class_name);
}
}
