Base contract for ORM queries. Base class for Query and NativeQuery.
This annotation is used to override association mapping of property for an entity relationship.
This annotation is used to override association mappings of relationship properties.
This annotation is used to override the mapping of a entity property.
This annotation is used to override the mapping of a entity property.
Caching to an entity or a collection.
The EntityListeners annotation specifies the callback listener classes to be used for an entity or mapped superclass.
Id
Provides an API for querying/managing the second level cache regions.
Association cache entry
Configuration container for second-level cache.
Cache entry interface
Contract for building second level cache regions components.
Defines entity / collection / query key to be stored in the cache region.
Collection cache entry
Defines entity collection roles to be stored in the cache region.
Hydrator cache entry for collections
Defines contract for concurrently managed data region.
Provides an API for querying/managing the second level cache regions.
Default hydrator cache for collections
Default hydrator cache for entities
Default query cache implementation.
Entity cache entry
Defines entity classes roles to be stored in the cache region.
Hydrator cache entry for entities
Exception for cache.
Lock exception for cache.
Interface for logging.
Provide basic second level cache statistics.
Defines a region that supports multi-get reading.
Interface for persister that support second level cache.
Interface for second level cache collection persisters.
Interface for second level cache entity persisters.
Specific non-strict read/write cached entity persister
Specific read-only region entity persister
Specific read-write entity persister
Defines the contract for caches capable of storing query results.
Query cache entry
A cache key that identifies a particular query.
Cache query validator interface.
Defines a contract for accessing a particular named region.
A cache region that enables the retrieval of multiple elements with one call
The simplest cache region compatible with all doctrine-cache drivers.
Very naive concurrent region, based on file locks.
Tracks the timestamps of the most recent updates to particular keys.
Cache regions configuration
Timestamp cache entry
A key that identifies a timestamped space.
Defines the contract for a cache region which will specifically be used to store entity "update timestamps".
Configuration container for all configuration options of Doctrine.
Configuration container for class metadata options of Doctrine.
Base class for EntityManager decorators
The EntityManager is the central access point to ORM functionality.
Makes a Persistent Object aware of its own object-manager.
EntityManager interface
Exception thrown when a Proxy fails to retrieve an Entity result.
An EntityRepository serves as a repository for entities with generic as well as business specific methods for retrieving entities.
Lifecycle Events are triggered by the UnitOfWork during lifecycle transitions of entities.
A method invoker based on entity lifecycle.
Class that holds event arguments for a loadMetadata event.
Class that holds event arguments for a onClassMetadataNotFound event.
Provides event arguments for the onClear event.
Provides event arguments for the preFlush event.
Provides event arguments for the postFlush event.
Provides event arguments for the preFlush event.
Class that holds event arguments for a preInsert/preUpdate event.
Container for all ORM events.
Base exception class for all ORM exceptions.
This interface should be implemented by all exceptions in the Repository namespace.
CommitOrderCalculator implements topological sorting, which is an ordering algorithm for directed graphs (DG) and/or directed acyclic graphs (DAG) by using a depth-first searching (DFS) to traverse the graph built in memory.
Class, which can handle completion of hydration cycle and produce some of tasks.
Base class for all hydrators. A hydrator is a class that provides some form of transformation of an SQL result set into another structure.
The ArrayHydrator produces a nested array "graph" that is often (not always) interchangeable with the corresponding object graph for read-only access.
Represents a result structure that can be iterated over, hydrating row-by-row during the iteration. An IterableResult is obtained by AbstractHydrator#iterate().
The ObjectHydrator constructs an object graph out of an SQL result set.
Hydrator that produces flat, rectangular results of scalar data.
Hydrator that hydrates a single scalar value from the result set.
A lazy collection that allow a fast count when using criteria object Once count gets executed once without collection being initialized, result is cached and returned on subsequent calls until collection gets loaded, then returning the number of loaded results.
The ClassMetadataFactory is used to create ClassMetadata objects that contain all the metadata mapping information of a class which describes how a class should be mapped to a relational database.
Class AssociationMetadata
Class CacheUsage
Class ChangeTrackingPolicy
A ClassMetadata instance holds all the object-relational mapping metadata of an entity and its associations.
The ClassMetadataFactory is used to create ClassMetadata objects that contain all the metadata mapping information of a class which describes how a class should be mapped to a relational database.
A ComponentMetadata instance holds object-relational property mapping.
The default DefaultEntityListener
The AnnotationDriver reads the mapping metadata from docblock annotations.
The AnnotationDriver reads the mapping metadata from docblock annotations.
Class EmbeddableClassMetadataBinder
Class ComponentMetadataBinder
The DatabaseDriver reverse engineers the mapping metadata from a database.
The DriverChain allows you to add multiple other mapping drivers for certain namespaces.
Base driver for file-based metadata drivers.
Contract for metadata drivers.
XmlDriver that additionally looks for mapping information in a global file.
XmlDriver is a metadata driver that enables mapping through XML files.
A resolver is used to instantiate an entity listener.
AbstractClassMetadataFactory is the base of ClassMetadata object creation that contain all the metadata mapping information of a class which describes how a class should be mapped to a relational database.
Class ClassMetadataBuildingContext
This factory is used to generate metadata classes.
Interface ClassMetadataResolver
The default NamingStrategy
A set of rules for determining the physical column and table names
RuntimeClassMetadataFactory is the ClassMetadata object creation factory that runs at execution time, consuming pre-exising entity classes.
StaticClassMetadataFactory is the ClassMetadata object creation factory that sits behind the front-door, allowing to generate entity classes in case they do not exist yet.
Naming strategy implementing the underscore naming convention.
A MappingException indicates that something is wrong with the mapping setup.
Acts as a proxy to a nested Property structure, making it look like just a single scalar property.
Represents a native SQL query.
Exception thrown when an ORM query unexpectedly does not return any results.
Exception thrown when an ORM query unexpectedly returns more than one result.
Contains exception messages for all invalid lifecycle state exceptions inside UnitOfWork
An OptimisticLockException is thrown when a version check on an object that uses optimistic locking through a version field fails.
A PersistentCollection represents a collection of elements that have persistent state.
PersistentObject base class that implements getter/setter methods for all mapped fields and associations by overriding __call.
Base class for all collection persisters.
Define the behavior that should be implemented by all collection persisters.
Persister for many-to-many collections.
Persister for one-to-many collections.
Base class for entity persisters that implement a certain inheritance mapping strategy.
A BasicEntityPersister maps an entity to a single table in a relational database.
A swappable persister context to use as a container for the current generated query/resultSetMapping/type binding information.
Entity persister interface Define the behavior that should be implemented by all entity persisters.
The joined subclass persister maps a single entity instance to several tables in the database as it is defined by the Class Table Inheritance strategy.
Persister for entities that participate in a hierarchy mapped with the SINGLE_TABLE strategy.
Visit Expressions and generate SQL WHERE conditions from them.
Extract the values from a criteria/expression
Static factory for proxy objects.
A Query object represents a DQL query.
This class is responsible for building DQL query strings via an object oriented PHP interface.
Base exception class for AST exceptions.
Description of AggregateExpression.
ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
ArithmeticTerm ::= ArithmeticFactor {("" | "/") ArithmeticFactor}
CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression ) | StringExpression ComparisonOperator (StringExpression | QuantifiedExpression) | BooleanExpression ("=" | "<>" | "!=") (BooleanExpression | QuantifiedExpression) | EnumExpression ("=" | "<>" | "!=") (EnumExpression | QuantifiedExpression) | DatetimeExpression ComparisonOperator (DatetimeExpression | QuantifiedExpression) | EntityExpression ("=" | "<>") (EntityExpression | QuantifiedExpression)
ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
ConditionalFactor ::= ["NOT"] ConditionalPrimary
ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName [["AS"] AliasIdentificationVariable]
DeleteStatement = DeleteClause [WhereClause]
EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}
"ABS" "(" SimpleArithmeticExpression ")"
"AVG" "(" ["DISTINCT"] StringPrimary ")"
"BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
"BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
"CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary }* ")"
"COUNT" "(" ["DISTINCT"] StringPrimary ")"
"CURRENT_DATE"
"CURRENT_TIME"
"CURRENT_TIMESTAMP"
"DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
"DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
"DATE_SUB(date1, interval, unit)"
Abstract Function Node.
"IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
"LENGTH" "(" StringPrimary ")"
"LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")"
"LOWER" "(" StringPrimary ")"
"MAX" "(" ["DISTINCT"] StringPrimary ")"
"MIN" "(" ["DISTINCT"] StringPrimary ")"
"MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")"
"SIZE" "(" CollectionValuedPathExpression ")"
"SQRT" "(" SimpleArithmeticExpression ")"
"SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")"
"SUM" "(" ["DISTINCT"] StringPrimary ")"
"TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")"
"UPPER" "(" StringPrimary ")"
GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {JoinVariableDeclaration}*
InExpression ::= StateFieldPathExpression ["NOT"] "IN" "(" (Literal {"," Literal}* | Subselect) ")"
IndexBy ::= "INDEX" "BY" SimpleStateFieldPathExpression
Description of InputParameter.
InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")") InstanceOfParameter ::= AbstractSchemaName | InputParameter
Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN" JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [("ON" | "WITH") ConditionalExpression]
JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable
JoinAssociationPathExpression ::= IdentificationVariable "." (SingleValuedAssociationField | CollectionValuedAssociationField)
JoinClassPathExpression ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
JoinVariableDeclaration ::= Join [IndexBy]
LikeExpression ::= StringExpression ["NOT"] "LIKE" string ["ESCAPE" char]
NewObjectExpression ::= "NEW" IdentificationVariable "(" NewObjectArg {"," NewObjectArg}* ")"
Abstract class of an AST node.
NullComparisonExpression ::= (SingleValuedPathExpression | InputParameter) "IS" ["NOT"] "NULL"
NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
OrderByItem ::= (ResultVariable | StateFieldPathExpression) ["ASC" | "DESC"]
ParenthesisExpression ::= "(" ArithmeticPrimary ")"
AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression StateFieldPathExpression ::= SimpleStateFieldPathExpression | SimpleStateFieldAssociationPathExpression SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField StateField ::= {EmbeddedClassStateField "."}* SimpleStateField SimpleStateFieldPathExpression ::= IdentificationVariable "." StateField
QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
SelectClause = "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
SelectExpression ::= IdentificationVariable ["." "*"] | StateFieldPathExpression | (AggregateExpression | "(" Subselect ")") [["AS"] ["HIDDEN"] FieldAliasIdentificationVariable]
SelectStatement = SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
SimpleSelectExpression ::= StateFieldPathExpression | IdentificationVariable | (AggregateExpression [["AS"] FieldAliasIdentificationVariable])
SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
SubselectIdentificationVariableDeclaration ::= AssociationPathExpression ["AS"] AliasIdentificationVariable
UpdateClause ::= "UPDATE" AbstractSchemaName [["AS"] AliasIdentificationVariable] "SET" UpdateItem {"," UpdateItem}*
UpdateItem ::= [IdentificationVariable "."] {StateField | SingleValuedAssociationField} "=" NewValue NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary | EnumPrimary | SimpleEntityExpression | "NULL"
UpdateStatement = UpdateClause [WhereClause]
WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
WhereClause ::= "WHERE" ConditionalExpression
Base class for SQL statement executors.
Executes the SQL statements for bulk DQL DELETE statements on classes in Class Table Inheritance (JOINED).
Executes the SQL statements for bulk DQL UPDATE statements on classes in Class Table Inheritance (JOINED).
Executor that executes the SQL statement for simple DQL SELECT statements.
Executor that executes the SQL statements for DQL DELETE/UPDATE statements on classes that are mapped to a single table.
This class is used to generate DQL expressions via a set of PHP static functions.
Expression class for building DQL and parts.
Abstract base Expr class for building DQL parts.
Expression class for DQL comparison expressions.
Expression class for building DQL and parts.
Expression class for DQL from.
Expression class for generating DQL functions.
Expression class for building DQL Group By parts.
Expression class for DQL join.
Expression class for generating DQL functions.
Expression class for DQL math statements.
Expression class for building DQL Order By parts.
Orx
Expression class for building DQL OR clauses.
Expression class for building DQL select statements.
Collection class for all the query filters.
The base class that user defined filters should extend.
Scans a DQL query for tokens.
Defines a Query Parameter.
Provides an enclosed support for parameter inferring.
An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
Encapsulates the resulting components from a DQL query parsing process that can be serialized.
A parse tree printer for Doctrine Query Language parser.
Description of QueryException.
Converts Collection expressions to Query expressions.
A ResultSetMapping describes how a result set of an SQL query maps to a Doctrine result.
A ResultSetMappingBuilder uses the EntityManager to automatically populate entity fields.
The SqlWalker is a TreeWalker that walks over a DQL AST and constructs the corresponding SQL.
Interface for walkers of DQL ASTs (abstract syntax trees).
An adapter implementation of the TreeWalker interface. The methods in this class are empty. ´╗┐This class exists as convenience for creating tree walkers.
Represents a chain of tree walkers that modify an AST and finally emit output.
Very simple reflection service abstraction.
PHP Runtime Reflection Service.
PHP Runtime Reflection Service.
This factory is used to create default repository objects for entities at runtime.
Interface for entity repository factory.
Id generator that obtains IDs from special "identity" columns. These are columns that automatically get a database-generated, auto-incremented identifier on INSERT.
Id generator that obtains IDs from special "identity" columns. These are columns that automatically get a database-generated, auto-incremented identifier on INSERT.
Represents an ID generator that uses a database sequence.
Id generator that uses a single-row database table and a hi/lo algorithm.
Represents an ID generator that uses the database UUID expression
Mechanism to programmatically attach entity listeners.
Command to clear a collection cache region.
Command to clear a entity cache region.
Command to clear the metadata cache of the various cache drivers.
Command to clear the query cache of the various cache drivers.
Command to clear a query cache region.
Command to clear the result cache of the various cache drivers.
Command to ensure that Doctrine is properly configured for a production environment.
Command to (re)generate the proxy classes used by doctrine.
Show information about mapped entities.
Show information about mapped entities.
Command to execute DQL queries in a given EntityManager.
Base class for CreateCommand, DropCommand and UpdateCommand.
Command to create the database schema for a set of classes based on their mappings.
Command to drop the database schema for a set of classes based on their mappings.
Command to generate the SQL needed to update the database schema to match the current mapping information.
Command to validate that the current mapping is valid.
Handles running the Console Tools inside Symfony Console context.
Doctrine CLI Connection Helper.
Used by CLI Tools to restrict entity-based commands to given patterns.
Use this logger to dump the identity map during the onFlush event. This is useful for debugging weird UnitOfWork behavior with complex operations.
The DisconnectedClassMetadataFactory is used to create ClassMetadata objects that do not require the entity class actually exist. This allows us to load some mapping information and use it to do things like generate code from the mapping information.
Event Args used for the Events::postGenerateSchema event.
Event Args used for the Events::postGenerateSchemaTable event.
Wraps the query in order to accurately count the root objects.
Replaces the selectClause of the AST with a COUNT statement.
Wraps the query in order to select root entity IDs for pagination.
Replaces the selectClause of the AST with a SELECT DISTINCT root.id equivalent.
The paginator can handle various complex scenarios with DQL.
RowNumberOverFunction
Replaces the whereClause of the AST with a WHERE id IN (:foo_1, :foo_2) equivalent.
ResolveTargetEntityListener
The SchemaTool is a tool to create/drop/update database schemas based on ClassMetadata class descriptors.
Performs strict validation of the mapping schema
Convenience class for setting up Doctrine from different installations and configurations.
Tools related Exceptions.
Is thrown when a transaction is required for the current operation, but there is none open.
Exception for a unexpected query result.
The UnitOfWork is responsible for tracking changes to objects during an "object-level" transaction and for writing out changes to the database in the correct order.
The IdentifierFlattener utility now houses some of the identifier manipulation logic from unit of work, so that it can be re-used elsewhere.
The PersisterHelper contains logic to infer binding types which is used in several persisters.
This class provides utility method to retrieve class names, and to convert proxy class names to original class names