Base contract for ORM queries. Base class for Query and NativeQuery.
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.
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.
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.
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
Builder for entity listeners.
Field Builder
ManyToMany Association Builder
OneToMany Association Builder
{@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.
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.
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.
Persister for collections of basic elements / value types.
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 many-to-many collections.
Persister for one-to-many collections.
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
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}*
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.
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 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.
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.
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.
Class to store and retrieve the version of Doctrine