Base contract for ORM queries. Base class for Query and NativeQuery.
Provides an API for querying/managing the second level cache regions.
Association cache entry
Configuration container for second-level cache.
Cache entry interface
Exception for cache.
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
Cache Lock
Lock exception for cache.
Interface for logging.
Cache logger chain
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.
Base class for EntityManager decorators
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.
Special generator for application-assigned identifiers (doesn't really generate anything).
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
The CommitOrderCalculator is used by the UnitOfWork to sort out the correct order in which changes to entities need to be persisted.
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.
ANSI compliant quote strategy, this strategy does not apply any quote.
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.
Builder Object for ClassMetadata
Embedded Builder
Builder for entity listeners.
Field Builder
ManyToMany Association Builder
OneToMany Association Builder
Caching to an entity or a collection.
{@inheritDoc}
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 ClassMetadata instance holds all the object-relational mapping metadata of an entity and its associations.
References name of a column in the SELECT clause of a SQL query.
The default DefaultEntityListener
The default NamingStrategy
A set of rules for determining the physical column, alias and table quotes
The AnnotationDriver reads the mapping metadata from docblock annotations.
The DatabaseDriver reverse engineers the mapping metadata from a database.
DriverChain deprecated
{@inheritDoc}
PHPDriver deprecated
{@inheritDoc}
XmlDriver that additionally looks for mapping information in a global file.
YamlDriver that additionally looks for mapping information in a global file.
StaticPHPDriver deprecated
{@inheritDoc}
XmlDriver is a metadata driver that enables mapping through XML files.
The YamlDriver reads the mapping metadata from yaml schema files.
A resolver is used to instantiate an entity listener.
The EntityListeners annotation specifies the callback listener classes to be used for an entity or mapped superclass.
References an entity in the SELECT clause of a SQL query.
Is used to map the columns specified in the SELECT list of the query to the properties or fields of the entity class.
Id
A MappingException indicates that something is wrong with the mapping setup.
Is used to specify an array of native SQL named queries.
Is used to specify a native SQL named query.
A set of rules for determining the physical column and table names
A set of rules for determining the column, alias and table quotes.
Acts as a proxy to a nested Property structure, making it look like just a single scalar property.
Utility class to retrieve all reflection instance properties of a given class, including private inherited properties and transient properties.
The SqlResultSetMapping annotation is used to specify the mapping of the result of a native SQL query.
Is used to specify an array of mappings.
Naming strategy implementing the underscore naming convention.
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.
Base exception class for all ORM exceptions.
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.
Base class for all collection persisters.
Collection persister interface 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
Pessimistic Lock Exception
Autoloader deprecated
Interface for proxy classes.
This factory is used to create proxy objects for entities at runtime.
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}
Description of BetweenExpression.
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 ")"
"BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
"BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
"CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary }* ")"
"CURRENT_DATE"
"CURRENT_TIME"
"CURRENT_TIMESTAMP"
"DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
"DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
"DATE_ADD(date1, interval, unit)"
Abstract Function Node.
"IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
"LENGTH" "(" StringPrimary ")"
"LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")"
"LOWER" "(" StringPrimary ")"
"MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")"
"SIZE" "(" CollectionValuedPathExpression ")"
"SQRT" "(" SimpleArithmeticExpression ")"
"SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")"
"TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")"
"UPPER" "(" StringPrimary ")"
GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
Description of GroupByClause.
Description of HavingClause.
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.
This factory is used to create default repository objects for entities at runtime.
Interface for entity repository factory.
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 convert a Doctrine 1 schema to a Doctrine 2 mapping file.
Command to convert your mapping information between the various formats.
Command to ensure that Doctrine is properly configured for a production environment.
Command to generate entity classes and method stubs from your mapping information.
Command to (re)generate the proxy classes used by doctrine.
Command to generate repository classes for mapping information.
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.
Class to help with converting Doctrine 1 schema files to Doctrine 2 mapping files
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 ClassMetadataInfo 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.
Generic class used to generate PHP5 entity classes from ClassMetadataInfo instances.
Class to generate entity repository classes
Event Args used for the Events::postGenerateSchema event.
Event Args used for the Events::postGenerateSchemaTable event.
Class used for converting your mapping information between the supported formats: yaml, xml, and php/annotation.
Abstract base class which is to be used for the Exporter drivers which can be found in \Doctrine\ORM\Tools\Export\Driver.
ClassMetadata exporter for PHP classes with annotations.
ClassMetadata exporter for PHP code.
ClassMetadata exporter for Doctrine XML mapping files.
ClassMetadata exporter for Doctrine YAML mapping files.
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.
Class to store and retrieve the version of Doctrine