Class Doctrine\ORM\EntityManager

`implements`	`EntityManagerInterface`


					
	public

__construct(Connection $conn, Configuration $config, ?EventManager $eventManager = null)

Creates a new EntityManager that operates on the given database connection and uses the given Configuration and…

Creates a new EntityManager that operates on the given database connection and uses the given Configuration and EventManager implementations.

#


					
	public

getConnection()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::getConnection()

#


					
	public

getMetadataFactory(): ClassMetadataFactory

Gets the metadata factory used to gather the metadata of classes.

Implements

Doctrine\Persistence\ObjectManager::getMetadataFactory()

#


					
	public

getExpressionBuilder()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::getExpressionBuilder()

#


					
	public

beginTransaction()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::beginTransaction()

#


					
	public

getCache()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::getCache()

#


					
	public

transactional($func)

{@inheritDoc}

Parameters

$func

The function to execute transactionally.

Returns

The non-empty value returned from the closure or true instead.

Implements

Doctrine\ORM\EntityManagerInterface::transactional()

#


					
	public

wrapInTransaction(callable $func)

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::wrapInTransaction()

#


					
	public

commit()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::commit()

#


					
	public

rollback()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::rollback()

#


					
	public

getClassMetadata($className)

Returns the ORM metadata descriptor for a class.

The class name must be the fully-qualified class name without a leading backslash (as it is returned by get_class($obj)) or an aliased class name.

Examples: MyProject\Domain\User sales:PriceRequest

Internal note: Performance-sensitive method.

{@inheritDoc}

Implements

Doctrine\Persistence\ObjectManager::getClassMetadata()

#


					
	public

createQuery($dql = '')

{@inheritDoc}

Parameters

$dql

The DQL string.

Implements

Doctrine\ORM\EntityManagerInterface::createQuery()

#


					
	public

createNamedQuery($name)

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::createNamedQuery()

#


					
	public

createNativeQuery($sql, ResultSetMapping $rsm)

{@inheritDoc}

Parameters

$rsm

The ResultSetMapping to use.

Implements

Doctrine\ORM\EntityManagerInterface::createNativeQuery()

#


					
	public

createNamedNativeQuery($name)

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::createNamedNativeQuery()

#


					
	public

createQueryBuilder()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::createQueryBuilder()

#


					
	public

flush(object|mixed[]|null $entity = null): void

Flushes all changes to objects that have been queued up to now to the database. This effectively synchronizes the in…

Flushes all changes to objects that have been queued up to now to the database. This effectively synchronizes the in-memory state of managed objects with the database.

If an entity is explicitly passed to this method only this entity and the cascade-persist semantics + scheduled inserts/removals are synchronized.

Throws

`Doctrine\ORM\OptimisticLockException`	If a version check on an entity that makes use of optimistic locking fails.
`Doctrine\ORM\Exception\ORMException`

Implements

Doctrine\Persistence\ObjectManager::flush()

#


					
	public

find<T>(
	class-string<T> $className,
	mixed $id,
	LockMode::*|null $lockMode = null,
	int|null $lockVersion = null,
): object|null

Finds an Entity by its identifier.

Parameters

`$id`	The identity of the entity to find.
`$lockVersion`	The version of the entity to find when using optimistic locking.

Returns

The entity instance or NULL if the entity can not be found.

Throws

`Doctrine\ORM\OptimisticLockException`
`Doctrine\ORM\ORMInvalidArgumentException`
`Doctrine\ORM\TransactionRequiredException`
`Doctrine\ORM\Exception\ORMException`

Implements

Doctrine\Persistence\ObjectManager::find()

#


					
	public

getReference($entityName, $id)

{@inheritDoc}

Parameters

$id

The entity identifier.

Returns

The entity reference.

Implements

Doctrine\ORM\EntityManagerInterface::getReference()

#


					
	public

getPartialReference($entityName, $identifier)

{@inheritDoc}

Parameters

$identifier

The entity identifier.

Returns

The (partial) entity reference

Implements

Doctrine\ORM\EntityManagerInterface::getPartialReference()

#


					
	public

clear(string|null $entityName = null): void

Clears the EntityManager. All entities that are currently managed by this EntityManager become detached.

Parameters

$entityName

if given, only entities of this type will get detached

Throws

`Doctrine\ORM\ORMInvalidArgumentException`	If a non-null non-string value is given.
`Doctrine\Persistence\Mapping\MappingException`	If a $entityName is given, but that entity is not found in the mappings.

Implements

Doctrine\Persistence\ObjectManager::clear()

#


					
	public

close()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::close()

#


					
	public

persist(object $entity): void

Tells the EntityManager to make an instance managed and persistent.

The entity will be entered into the database at or before transaction commit or as a result of the flush operation.

NOTE: The persist operation always considers entities that are not yet known to this EntityManager as NEW. Do not pass detached entities to the persist operation.

Parameters

$entity

The instance to make managed and persistent.

Throws

`Doctrine\ORM\ORMInvalidArgumentException`
`Doctrine\ORM\Exception\ORMException`

Implements

Doctrine\Persistence\ObjectManager::persist()

#


					
	public

remove(object $entity): void

Removes an entity instance.

A removed entity will be removed from the database at or before transaction commit or as a result of the flush operation.

Parameters

$entity

The entity instance to remove.

Throws

`Doctrine\ORM\ORMInvalidArgumentException`
`Doctrine\ORM\Exception\ORMException`

Implements

Doctrine\Persistence\ObjectManager::remove()

#


					
	public

refresh(object $entity, LockMode::*|null $lockMode = null): void

Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been…

Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been persisted.

Parameters

$entity

The entity to refresh

Throws

`Doctrine\ORM\ORMInvalidArgumentException`
`Doctrine\ORM\Exception\ORMException`
`Doctrine\ORM\TransactionRequiredException`

Implements

Doctrine\Persistence\ObjectManager::refresh()

#


					
	public

detach(object $entity): void

Detaches an entity from the EntityManager, causing a managed entity to become detached. Unflushed changes made to the…

Detaches an entity from the EntityManager, causing a managed entity to become detached. Unflushed changes made to the entity if any (including removal of the entity), will not be synchronized to the database. Entities which previously referenced the detached entity will continue to reference it.

Parameters

$entity

The entity to detach.

Throws

Doctrine\ORM\ORMInvalidArgumentException

Implements

Doctrine\Persistence\ObjectManager::detach()

#


					
	public

merge(object $entity): object

Merges the state of a detached entity into the persistence context of this EntityManager and returns the managed copy…

Merges the state of a detached entity into the persistence context of this EntityManager and returns the managed copy of the entity. The entity passed to merge will not become associated/managed with this EntityManager.

Deprecated

2.7 This method is being removed from the ORM and won't have any replacement

Parameters

$entity

The detached entity to merge into the persistence context.

Returns

The managed copy of the entity.

Throws

`Doctrine\ORM\ORMInvalidArgumentException`
`Doctrine\ORM\Exception\ORMException`

#


					
	public

copy($entity, $deep = false)

{@inheritDoc}

Parameters

`$entity`	The entity to copy.
`$deep`	FALSE for a shallow copy, TRUE for a deep copy.

Returns

The new entity.

Implements

Doctrine\ORM\EntityManagerInterface::copy()

#


					
	public

lock($entity, $lockMode, $lockVersion = null)

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::lock()

#


					
	public

getRepository<T is object>(class-string<T> $entityName): ObjectRepository|EntityRepository

Gets the repository for an entity class.

Returns

The repository class.

Implements

Doctrine\Persistence\ObjectManager::getRepository()

#


					
	public

contains(object $entity): bool

Determines whether an entity instance is managed in this EntityManager.

Returns

TRUE if this EntityManager currently manages the given entity, FALSE otherwise.

Implements

Doctrine\Persistence\ObjectManager::contains()

#


					
	public

getEventManager()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::getEventManager()

#


					
	public

getConfiguration()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::getConfiguration()

#


					
	private

errorIfClosed(): void

Throws an exception if the EntityManager is closed or currently not active.

Throws

Doctrine\ORM\Exception\EntityManagerClosed

If the EntityManager is closed.

#


					
	public

isOpen()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::isOpen()

#


					
	public

getUnitOfWork()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::getUnitOfWork()

#


					
	public

getHydrator($hydrationMode)

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::getHydrator()

#


					
	public

newHydrator($hydrationMode)

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::newHydrator()

#


					
	public

getProxyFactory()

{@inheritDoc}

Implements

Doctrine\ORM\EntityManagerInterface::getProxyFactory()

#


					
	public

initializeObject($obj)

{@inheritDoc}

Implements

Doctrine\Persistence\ObjectManager::initializeObject()

#


					
	public

isUninitializedObject($obj): bool

{@inheritDoc}

#


					
	public
					static

create(
	array<string, mixed>|Connection $connection,
	Configuration $config,
	EventManager|null $eventManager = null,
): EntityManager

Factory method to create EntityManager instances.

Deprecated

Use {@see DriverManager::getConnection()} to bootstrap the connection and call the constructor.

Parameters

`$config`	The Configuration instance to use.
`$eventManager`	The EventManager instance to use.

Returns

The created EntityManager.

Throws

`InvalidArgumentException`
`Doctrine\ORM\Exception\ORMException`

#


					
	protected
					static

createConnection(
	array<string, mixed>|Connection $connection,
	Configuration $config,
	EventManager|null $eventManager = null,
): Connection

Factory method to create Connection instances.

Deprecated

Use {@see DriverManager::getConnection()} to bootstrap the connection.

Parameters

`$config`	The Configuration instance to use.
`$eventManager`	The EventManager instance to use.

Throws

`InvalidArgumentException`
`Doctrine\ORM\Exception\ORMException`

#


					
	public

getFilters()

{@inheritDoc}

Returns

The active filter collection.

Implements

Doctrine\ORM\EntityManagerInterface::getFilters()

#


					
	public

isFiltersStateClean()

{@inheritDoc}

Returns

True, if the filter collection is clean.

Implements

Doctrine\ORM\EntityManagerInterface::isFiltersStateClean()

#


					
	public

hasFilters()

{@inheritDoc}

Returns

True, if the EM has a filter collection.

Implements

Doctrine\ORM\EntityManagerInterface::hasFilters()

#


					
	private

checkLockRequirements(LockMode::* $lockMode, ClassMetadata $class): void

Throws

`Doctrine\ORM\OptimisticLockException`
`Doctrine\ORM\TransactionRequiredException`

#


					
	private

configureMetadataCache(): void

#


					
	private

configureLegacyMetadataCache(): void

#

Properties
`private`	`Configuration`	`$config`	#
`private`	`Connection`	`$conn`	#
`private`	`ClassMetadataFactory`	`$metadataFactory`	#
`private`	`UnitOfWork`	`$unitOfWork`	#
`private`	`EventManager`	`$eventManager`	#
`private`	`ProxyFactory`	`$proxyFactory`	#
`private`	`RepositoryFactory`	`$repositoryFactory`	#
`private`	`Expr\|null`	`$expressionBuilder`	#
`private`	`bool`	`$closed = false`	#
`private`	`FilterCollection\|null`	`$filterCollection`	#
`private`	`Cache\|null`	`$cache`	#

Namespaces

Classes

Interfaces

Exceptions

Class Doctrine\ORM\EntityManager

Implements

Implements

Implements

Implements

Implements

Parameters

Returns

Implements

Implements

Implements

Implements

Implements

Parameters

Implements

Implements

Parameters

Implements

Implements

Implements

Throws

Implements

Parameters

Returns

Throws

Implements

Parameters

Returns

Implements

Parameters

Returns

Implements

Parameters

Throws

Implements

Implements

Parameters

Throws

Implements

Parameters

Throws

Implements

Parameters

Throws

Implements

Parameters

Throws

Implements

Deprecated

Parameters

Returns

Throws

Parameters

Returns

Implements

Implements

Returns

Implements

Returns

Implements

Implements

Implements

Throws

Implements

Implements

Implements

Implements

Implements

Implements

Deprecated

Parameters

Returns

Throws

Deprecated

Parameters

Throws