Release 2.3.5

"Basic Mapping" documentation says:
"decimal: Type that maps a SQL DECIMAL to a PHP string."

.gitignore

@@ -8,4 +8,4 @@ lib/Doctrine/Common
 lib/Doctrine/DBAL
 /.settings/
 .buildpath
-.project
+.project

.gitmodules

@@ -12,4 +12,4 @@
 	url = git://github.com/symfony/Yaml.git
 [submodule "lib/vendor/doctrine-build-common"]
 	path = lib/vendor/doctrine-build-common
-	url = https://github.com/doctrine/doctrine-build-common.git
+	url = git://github.com/doctrine/doctrine-build-common.git

LICENSE

@@ -1,504 +1,19 @@
-		  GNU LESSER GENERAL PUBLIC LICENSE
-		       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard.  To achieve this, non-free programs must be
-allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
-		  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-  
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-		     
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
-
-
+Copyright (c) 2006-2012 Doctrine Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.markdown

@@ -1,7 +1,8 @@
 # Doctrine 2 ORM
 
 Master: [![Build Status](https://secure.travis-ci.org/doctrine/doctrine2.png?branch=master)](http://travis-ci.org/doctrine/doctrine2)
-2.1.x: [![Build Status](https://secure.travis-ci.org/doctrine/doctrine2.png?branch=2.1.x)](http://travis-ci.org/doctrine/doctrine2)
+2.2: [![Build Status](https://secure.travis-ci.org/doctrine/doctrine2.png?branch=2.2)](http://travis-ci.org/doctrine/doctrine2)
+2.1: [![Build Status](https://secure.travis-ci.org/doctrine/doctrine2.png?branch=2.1.x)](http://travis-ci.org/doctrine/doctrine2)
 
 Doctrine 2 is an object-relational mapper (ORM) for PHP 5.3.2+ that provides transparent persistence
 for PHP objects. It sits on top of a powerful database abstraction layer (DBAL). One of its key features
@@ -12,7 +13,7 @@ without requiring unnecessary code duplication.
 ## More resources:
 
 * [Website](http://www.doctrine-project.org)
-* [Documentation](http://www.doctrine-project.org/projects/orm/2.0/docs/reference/introduction/en)
+* [Documentation](http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/index.html)
 * [Issue Tracker](http://www.doctrine-project.org/jira/browse/DDC)
 * [Downloads](http://github.com/doctrine/doctrine2/downloads)
 

UPGRADE.md

@@ -0,0 +1,481 @@
+# Upgrade to 2.3
+
+## Auto Discriminator Map breaks userland implementations with Listener
+
+The new feature to detect discriminator maps automatically when none
+are provided breaks userland implementations doing this with a
+listener in ``loadClassMetadata`` event.
+
+## EntityManager#find() not calls EntityRepository#find() anymore
+
+Previous to 2.3, calling ``EntityManager#find()`` would be delegated to
+``EntityRepository#find()``.  This has lead to some unexpected behavior in the
+core of Doctrine when people have overwritten the find method in their
+repositories. That is why this behavior has been reversed in 2.3, and
+``EntityRepository#find()`` calls ``EntityManager#find()`` instead.
+
+## EntityGenerator add*() method generation
+
+When generating an add*() method for a collection the EntityGenerator will now not
+use the Type-Hint to get the singular for the collection name, but use the field-name
+and strip a trailing "s" character if there is one.
+
+## Merge copies non persisted properties too
+
+When merging an entity in UoW not only mapped properties are copied, but also others.
+
+## Query, QueryBuilder and NativeQuery parameters *BC break*
+
+From now on, parameters in queries is an ArrayCollection instead of a simple array.
+This affects heavily the usage of setParameters(), because it will not append anymore
+parameters to query, but will actually override the already defined ones.
+Whenever you are retrieving a parameter (ie. $query->getParameter(1)), you will
+receive an instance of Query\Parameter, which contains the methods "getName",
+"getValue" and "getType". Parameters are also only converted to when necessary, and
+not when they are set.
+
+Also, related functions were affected:
+
+* execute($parameters, $hydrationMode) the argument $parameters can be either an key=>value array or an ArrayCollection instance
+* iterate($parameters, $hydrationMode) the argument $parameters can be either an key=>value array or an ArrayCollection instance
+* setParameters($parameters) the argument $parameters can be either an key=>value array or an ArrayCollection instance
+* getParameters() now returns ArrayCollection instead of array
+* getParameter($key) now returns Parameter instance instead of parameter value
+
+## Query TreeWalker method renamed
+
+Internal changes were made to DQL and SQL generation. If you have implemented your own TreeWalker,
+you probably need to update it. The method walkJoinVariableDeclaration is now named walkJoin.
+
+## Metadata Drivers
+
+Metadata drivers have been rewritten to reuse code from Doctrine\Common. Anyone who is using the
+`Doctrine\ORM\Mapping\Driver\Driver` interface should instead refer to
+`Doctrine\Common\Persistence\Mapping\Driver\MappingDriver`. Same applies to
+`Doctrine\ORM\Mapping\Driver\AbstractFileDriver`: you should now refer to
+`Doctrine\Common\Persistence\Mapping\Driver\FileDriver`.
+
+Also, following mapping drivers have been deprecated, please use their replacements in Doctrine\Common as listed:
+
+ *  `Doctrine\ORM\Mapping\Driver\DriverChain`       => `Doctrine\Common\Persistence\Mapping\Driver\MappingDriverChain`
+ *  `Doctrine\ORM\Mapping\Driver\PHPDriver`         => `Doctrine\Common\Persistence\Mapping\Driver\PHPDriver`
+ *  `Doctrine\ORM\Mapping\Driver\StaticPHPDriver`   => `Doctrine\Common\Persistence\Mapping\Driver\StaticPHPDriver`
+
+# Upgrade to 2.2
+
+## ResultCache implementation rewritten
+
+The result cache is completely rewritten and now works on the database result level, not inside the ORM AbstractQuery
+anymore. This means that for result cached queries the hydration will now always be performed again, regardless of
+the hydration mode. Affected areas are:
+
+1. Fixes the problem that entities coming from the result cache were not registered in the UnitOfWork
+   leading to problems during EntityManager#flush. Calls to EntityManager#merge are not necessary anymore.
+2. Affects the array hydrator which now includes the overhead of hydration compared to caching the final result.
+
+The API is backwards compatible however most of the getter methods on the `AbstractQuery` object are now
+deprecated in favor of calling AbstractQuery#getQueryCacheProfile(). This method returns a `Doctrine\DBAL\Cache\QueryCacheProfile`
+instance with access to result cache driver, lifetime and cache key.
+
+
+## EntityManager#getPartialReference() creates read-only entity
+
+Entities returned from EntityManager#getPartialReference() are now marked as read-only if they
+haven't been in the identity map before. This means objects of this kind never lead to changes
+in the UnitOfWork.
+
+
+## Fields omitted in a partial DQL query or a native query are never updated
+
+Fields of an entity that are not returned from a partial DQL Query or native SQL query
+will never be updated through an UPDATE statement.
+
+
+## Removed support for onUpdate in @JoinColumn
+
+The onUpdate foreign key handling makes absolutely no sense in an ORM. Additionally Oracle doesn't even support it. Support for it is removed.
+
+
+## Changes in Annotation Handling
+
+There have been some changes to the annotation handling in Common 2.2 again, that affect how people with old configurations
+from 2.0 have to configure the annotation driver if they don't use `Configuration::newDefaultAnnotationDriver()`:
+
+    // Register the ORM Annotations in the AnnotationRegistry
+    AnnotationRegistry::registerFile('path/to/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
+
+    $reader = new \Doctrine\Common\Annotations\SimpleAnnotationReader();
+    $reader->addNamespace('Doctrine\ORM\Mapping');
+    $reader = new \Doctrine\Common\Annotations\CachedReader($reader, new ArrayCache());
+
+    $driver = new AnnotationDriver($reader, (array)$paths);
+
+    $config->setMetadataDriverImpl($driver);
+
+
+## Scalar mappings can now be ommitted from DQL result
+
+You are now allowed to mark scalar SELECT expressions as HIDDEN an they are not hydrated anymore.
+Example:
+
+SELECT u, SUM(a.id) AS HIDDEN numArticles FROM User u LEFT JOIN u.Articles a ORDER BY numArticles DESC HAVING numArticles > 10
+
+Your result will be a collection of Users, and not an array with key 0 as User object instance and "numArticles" as the number of articles per user
+
+
+## Map entities as scalars in DQL result
+
+When hydrating to array or even a mixed result in object hydrator, previously you had the 0 index holding you entity instance.
+You are now allowed to alias this, providing more flexibility for you code.
+Example:
+
+SELECT u AS user FROM User u
+
+Will now return a collection of arrays with index "user" pointing to the User object instance.
+
+
+## Performance optimizations
+
+Thousands of lines were completely reviewed and optimized for best performance.
+Removed redundancy and improved code readability made now internal Doctrine code easier to understand.
+Also, Doctrine 2.2 now is around 10-15% faster than 2.1.
+
+## EntityManager#find(null)
+
+Previously EntityManager#find(null) returned null. It now throws an exception.
+
+# Upgrade to 2.1
+
+## Interface for EntityRepository
+
+The EntityRepository now has an interface Doctrine\Common\Persistence\ObjectRepository. This means that your classes that override EntityRepository and extend find(), findOneBy() or findBy() must be adjusted to follow this interface.
+
+## AnnotationReader changes
+
+The annotation reader was heavily refactored between 2.0 and 2.1-RC1. In theory the operation of the new reader should be backwards compatible, but it has to be setup differently to work that way:
+
+    // new call to the AnnotationRegistry
+    \Doctrine\Common\Annotations\AnnotationRegistry::registerFile('/doctrine-src/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
+
+    $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+    $reader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\\');
+    // new code necessary starting here
+    $reader->setIgnoreNotImportedAnnotations(true);
+    $reader->setEnableParsePhpImports(false);
+    $reader = new \Doctrine\Common\Annotations\CachedReader(
+        new \Doctrine\Common\Annotations\IndexedReader($reader), new ArrayCache()
+    );
+
+This is already done inside the ``$config->newDefaultAnnotationDriver``, so everything should automatically work if you are using this method. You can verify if everything still works by executing a console command such as schema-validate that loads all metadata into memory.
+
+# Update from 2.0-BETA3 to 2.0-BETA4
+
+## XML Driver <change-tracking-policy /> element demoted to attribute
+
+We changed how the XML Driver allows to define the change-tracking-policy. The working case is now:
+
+    <entity change-tracking-policy="DEFERRED_IMPLICT" />
+
+# Update from 2.0-BETA2 to 2.0-BETA3
+
+## Serialization of Uninitialized Proxies
+
+As of Beta3 you can now serialize uninitialized proxies, an exception will only be thrown when
+trying to access methods on the unserialized proxy as long as it has not been re-attached to the
+EntityManager using `EntityManager#merge()`. See this example:
+
+    $proxy = $em->getReference('User', 1);
+
+    $serializedProxy = serialize($proxy);
+    $detachedProxy = unserialized($serializedProxy);
+
+    echo $em->contains($detachedProxy); // FALSE
+
+    try {
+        $detachedProxy->getId(); // uninitialized detached proxy
+    } catch(Exception $e) {
+
+    }
+    $attachedProxy = $em->merge($detachedProxy);
+    echo $attackedProxy->getId(); // works!
+
+## Changed SQL implementation of Postgres and Oracle DateTime types
+
+The DBAL Type "datetime" included the Timezone Offset in both Postgres and Oracle. As of this version they are now
+generated without Timezone (TIMESTAMP WITHOUT TIME ZONE instead of TIMESTAMP WITH TIME ZONE).
+See [this comment to Ticket DBAL-22](http://www.doctrine-project.org/jira/browse/DBAL-22?focusedCommentId=13396&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_13396)
+for more details as well as migration issues for PostgreSQL and Oracle.
+
+Both Postgres and Oracle will throw Exceptions during hydration of Objects with "DateTime" fields unless migration steps are taken!
+
+## Removed multi-dot/deep-path expressions in DQL
+
+The support for implicit joins in DQL through the multi-dot/Deep Path Expressions
+was dropped. For example:
+
+    SELECT u FROM User u WHERE u.group.name = ?1
+
+See the "u.group.id" here is using multi dots (deep expression) to walk
+through the graph of objects and properties. Internally the DQL parser
+would rewrite these queries to:
+
+    SELECT u FROM User u JOIN u.group g WHERE g.name = ?1
+
+This explicit notation will be the only supported notation as of now. The internal
+handling of multi-dots in the DQL Parser was very complex, error prone in edge cases
+and required special treatment for several features we added. Additionally
+it had edge cases that could not be solved without making the DQL Parser
+even much more complex. For this reason we will drop the support for the
+deep path expressions to increase maintainability and overall performance
+of the DQL parsing process. This will benefit any DQL query being parsed,
+even those not using deep path expressions.
+
+Note that the generated SQL of both notations is exactly the same! You
+don't loose anything through this.
+
+## Default Allocation Size for Sequences
+
+The default allocation size for sequences has been changed from 10 to 1. This step was made
+to not cause confusion with users and also because it is partly some kind of premature optimization.
+
+# Update from 2.0-BETA1 to 2.0-BETA2
+
+There are no backwards incompatible changes in this release.
+
+# Upgrade from 2.0-ALPHA4 to 2.0-BETA1
+
+## EntityRepository deprecates access to protected variables
+
+Instead of accessing protected variables for the EntityManager in
+a custom EntityRepository it is now required to use the getter methods
+for all the three instance variables:
+
+* `$this->_em` now accessible through `$this->getEntityManager()`
+* `$this->_class` now accessible through `$this->getClassMetadata()`
+* `$this->_entityName` now accessible through `$this->getEntityName()`
+
+Important: For Beta 2 the protected visibility of these three properties will be
+changed to private!
+
+## Console migrated to Symfony Console
+
+The Doctrine CLI has been replaced by Symfony Console Configuration
+
+Instead of having to specify:
+
+    [php]
+    $cliConfig = new CliConfiguration();
+    $cliConfig->setAttribute('em', $entityManager);
+
+You now have to configure the script like:
+
+    [php]
+    $helperSet = new \Symfony\Components\Console\Helper\HelperSet(array(
+        'db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($em->getConnection()),
+        'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em)
+    ));
+
+## Console: No need for Mapping Paths anymore
+
+In previous versions you had to specify the --from and --from-path options
+to show where your mapping paths are from the console. However this information
+is already known from the Mapping Driver configuration, so the requirement
+for this options were dropped.
+
+Instead for each console command all the entities are loaded and to
+restrict the operation to one or more sub-groups you can use the --filter flag.
+
+## AnnotationDriver is not a default mapping driver anymore
+
+In conjunction with the recent changes to Console we realized that the
+annotations driver being a default metadata driver lead to lots of glue
+code in the console components to detect where entities lie and how to load
+them for batch updates like SchemaTool and other commands. However the
+annotations driver being a default driver does not really help that much
+anyways.
+
+Therefore we decided to break backwards compability in this issue and drop
+the support for Annotations as Default Driver and require our users to
+specify the driver explicitly (which allows us to ask for the path to all
+entities).
+
+If you are using the annotations metadata driver as default driver, you
+have to add the following lines to your bootstrap code:
+
+    $driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__."/Entities"));
+    $config->setMetadataDriverImpl($driverImpl);
+
+You have to specify the path to your entities as either string of a single
+path or array of multiple paths
+to your entities. This information will be used by all console commands to
+access all entities.
+
+Xml and Yaml Drivers work as before!
+
+
+## New inversedBy attribute
+
+It is now *mandatory* that the owning side of a bidirectional association specifies the
+'inversedBy' attribute that points to the name of the field on the inverse side that completes
+the association. Example:
+
+    [php]
+    // BEFORE (ALPHA4 AND EARLIER)
+    class User
+    {
+        //...
+        /** @OneToOne(targetEntity="Address", mappedBy="user") */
+        private $address;
+        //...
+    }
+    class Address
+    {
+        //...
+        /** @OneToOne(targetEntity="User") */
+        private $user;
+        //...
+    }
+
+    // SINCE BETA1
+    // User class DOES NOT CHANGE
+    class Address
+    {
+        //...
+        /** @OneToOne(targetEntity="User", inversedBy="address") */
+        private $user;
+        //...
+    }
+
+Thus, the inversedBy attribute is the counterpart to the mappedBy attribute. This change
+was necessary to enable some simplifications and further performance improvements. We
+apologize for the inconvenience.
+
+## Default Property for Field Mappings
+
+The "default" option for database column defaults has been removed. If desired, database column defaults can
+be implemented by using the columnDefinition attribute of the @Column annotation (or the approriate XML and YAML equivalents).
+Prefer PHP default values, if possible.
+
+## Selecting Partial Objects
+
+Querying for partial objects now has a new syntax. The old syntax to query for partial objects
+now has a different meaning. This is best illustrated by an example. If you previously
+had a DQL query like this:
+
+    [sql]
+    SELECT u.id, u.name FROM User u
+
+Since BETA1, simple state field path expressions in the select clause are used to select
+object fields as plain scalar values (something that was not possible before).
+To achieve the same result as previously (that is, a partial object with only id and name populated)
+you need to use the following, explicit syntax:
+
+    [sql]
+    SELECT PARTIAL u.{id,name} FROM User u
+
+## XML Mapping Driver
+
+The 'inheritance-type' attribute changed to take last bit of ClassMetadata constant names, i.e.
+NONE, SINGLE_TABLE, INHERITANCE_TYPE_JOINED
+
+## YAML Mapping Driver
+
+The way to specify lifecycle callbacks in YAML Mapping driver was changed to allow for multiple callbacks
+per event. The Old syntax ways:
+
+    [yaml]
+    lifecycleCallbacks:
+      doStuffOnPrePersist: prePersist
+      doStuffOnPostPersist: postPersist
+
+The new syntax is:
+
+    [yaml]
+    lifecycleCallbacks:
+      prePersist: [ doStuffOnPrePersist, doOtherStuffOnPrePersistToo ]
+      postPersist: [ doStuffOnPostPersist ]
+
+## PreUpdate Event Listeners
+
+Event Listeners listening to the 'preUpdate' event can only affect the primitive values of entity changesets
+by using the API on the `PreUpdateEventArgs` instance passed to the preUpdate listener method. Any changes
+to the state of the entitys properties won't affect the database UPDATE statement anymore. This gives drastic
+performance benefits for the preUpdate event.
+
+## Collection API
+
+The Collection interface in the Common package has been updated with some missing methods
+that were present only on the default implementation, ArrayCollection. Custom collection
+implementations need to be updated to adhere to the updated interface.
+
+# Upgrade from 2.0-ALPHA3 to 2.0-ALPHA4
+
+## CLI Controller changes
+
+CLI main object changed its name and namespace. Renamed from Doctrine\ORM\Tools\Cli to Doctrine\Common\Cli\CliController.
+Doctrine\Common\Cli\CliController now only deals with namespaces. Ready to go, Core, Dbal and Orm are available and you can subscribe new tasks by retrieving the namespace and including new task. Example:
+
+    [php]
+    $cli->getNamespace('Core')->addTask('my-example', '\MyProject\Tools\Cli\Tasks\MyExampleTask');
+
+
+## CLI Tasks documentation
+
+Tasks have implemented a new way to build documentation. Although it is still possible to define the help manually by extending the basicHelp and extendedHelp, they are now optional.
+With new required method AbstractTask::buildDocumentation, its implementation defines the TaskDocumentation instance (accessible through AbstractTask::getDocumentation()), basicHelp and extendedHelp are now not necessary to be implemented.
+
+## Changes in Method Signatures
+
+    * A bunch of Methods on both Doctrine\DBAL\Platforms\AbstractPlatform and Doctrine\DBAL\Schema\AbstractSchemaManager
+      have changed quite significantly by adopting the new Schema instance objects.
+
+## Renamed Methods
+
+    * Doctrine\ORM\AbstractQuery::setExpireResultCache() -> expireResultCache()
+    * Doctrine\ORM\Query::setExpireQueryCache() -> expireQueryCache()
+
+## SchemaTool Changes
+
+    * "doctrine schema-tool --drop" now always drops the complete database instead of
+    only those tables defined by the current database model. The previous method had
+    problems when foreign keys of orphaned tables pointed to tables that were schedulded
+    for deletion.
+    * Use "doctrine schema-tool --update" to get a save incremental update for your
+    database schema without deleting any unused tables, sequences or foreign keys.
+    * Use "doctrine schema-tool --complete-update" to do a full incremental update of
+    your schema.
+# Upgrade from 2.0-ALPHA2 to 2.0-ALPHA3
+
+This section details the changes made to Doctrine 2.0-ALPHA3 to make it easier for you
+to upgrade your projects to use this version.
+
+## CLI Changes
+
+The $args variable used in the cli-config.php for configuring the Doctrine CLI has been renamed to $globalArguments.
+
+## Proxy class changes
+
+You are now required to make supply some minimalist configuration with regards to proxy objects. That involves 2 new configuration options. First, the directory where generated proxy classes should be placed needs to be specified. Secondly, you need to configure the namespace used for proxy classes. The following snippet shows an example:
+
+    [php]
+    // step 1: configure directory for proxy classes
+    // $config instanceof Doctrine\ORM\Configuration
+    $config->setProxyDir('/path/to/myproject/lib/MyProject/Generated/Proxies');
+    $config->setProxyNamespace('MyProject\Generated\Proxies');
+
+Note that proxy classes behave exactly like any other classes when it comes to class loading. Therefore you need to make sure the proxy classes can be loaded by some class loader. If you place the generated proxy classes in a namespace and directory under your projects class files, like in the example above, it would be sufficient to register the MyProject namespace on a class loader. Since the proxy classes are contained in that namespace and adhere to the standards for class loading, no additional work is required.
+Generating the proxy classes into a namespace within your class library is the recommended setup.
+
+Entities with initialized proxy objects can now be serialized and unserialized properly from within the same application.
+
+For more details refer to the Configuration section of the manual.
+
+## Removed allowPartialObjects configuration option
+
+The allowPartialObjects configuration option together with the `Configuration#getAllowPartialObjects` and `Configuration#setAllowPartialObjects` methods have been removed.
+The new behavior is as if the option were set to FALSE all the time, basically disallowing partial objects globally. However, you can still use the `Query::HINT_FORCE_PARTIAL_LOAD` query hint to force a query to return partial objects for optimization purposes.
+
+## Renamed Methods
+
+* Doctrine\ORM\Configuration#getCacheDir() to getProxyDir()
+* Doctrine\ORM\Configuration#setCacheDir($dir) to setProxyDir($dir)

UPGRADE_TO_2_0

@@ -1,240 +0,0 @@
-# Update from 2.0-BETA3 to 2.0-BETA4
-
-## XML Driver <change-tracking-policy /> element demoted to attribute
-
-We changed how the XML Driver allows to define the change-tracking-policy. The working case is now:
-
-    <entity change-tracking-policy="DEFERRED_IMPLICT" />
-
-# Update from 2.0-BETA2 to 2.0-BETA3
-
-## Serialization of Uninitialized Proxies
-
-As of Beta3 you can now serialize uninitialized proxies, an exception will only be thrown when
-trying to access methods on the unserialized proxy as long as it has not been re-attached to the
-EntityManager using `EntityManager#merge()`. See this example:
-
-    $proxy = $em->getReference('User', 1);
-
-    $serializedProxy = serialize($proxy);
-    $detachedProxy = unserialized($serializedProxy);
-
-    echo $em->contains($detachedProxy); // FALSE
-
-    try {
-        $detachedProxy->getId(); // uninitialized detached proxy
-    } catch(Exception $e) {
-
-    }
-    $attachedProxy = $em->merge($detachedProxy);
-    echo $attackedProxy->getId(); // works!
-
-## Changed SQL implementation of Postgres and Oracle DateTime types
-
-The DBAL Type "datetime" included the Timezone Offset in both Postgres and Oracle. As of this version they are now
-generated without Timezone (TIMESTAMP WITHOUT TIME ZONE instead of TIMESTAMP WITH TIME ZONE).
-See [this comment to Ticket DBAL-22](http://www.doctrine-project.org/jira/browse/DBAL-22?focusedCommentId=13396&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_13396)
-for more details as well as migration issues for PostgreSQL and Oracle.
-
-Both Postgres and Oracle will throw Exceptions during hydration of Objects with "DateTime" fields unless migration steps are taken!
-
-## Removed multi-dot/deep-path expressions in DQL
-
-The support for implicit joins in DQL through the multi-dot/Deep Path Expressions
-was dropped. For example:
-
-    SELECT u FROM User u WHERE u.group.name = ?1
-
-See the "u.group.id" here is using multi dots (deep expression) to walk
-through the graph of objects and properties. Internally the DQL parser
-would rewrite these queries to:
-
-    SELECT u FROM User u JOIN u.group g WHERE g.name = ?1
-
-This explicit notation will be the only supported notation as of now. The internal
-handling of multi-dots in the DQL Parser was very complex, error prone in edge cases
-and required special treatment for several features we added. Additionally
-it had edge cases that could not be solved without making the DQL Parser
-even much more complex. For this reason we will drop the support for the
-deep path expressions to increase maintainability and overall performance
-of the DQL parsing process. This will benefit any DQL query being parsed,
-even those not using deep path expressions.
-
-Note that the generated SQL of both notations is exactly the same! You
-don't loose anything through this.
-
-## Default Allocation Size for Sequences
-
-The default allocation size for sequences has been changed from 10 to 1. This step was made
-to not cause confusion with users and also because it is partly some kind of premature optimization.
-
-# Update from 2.0-BETA1 to 2.0-BETA2
-
-There are no backwards incompatible changes in this release.
-
-# Upgrade from 2.0-ALPHA4 to 2.0-BETA1
-
-## EntityRepository deprecates access to protected variables
-
-Instead of accessing protected variables for the EntityManager in
-a custom EntityRepository it is now required to use the getter methods
-for all the three instance variables:
-
-* `$this->_em` now accessible through `$this->getEntityManager()`
-* `$this->_class` now accessible through `$this->getClassMetadata()`
-* `$this->_entityName` now accessible through `$this->getEntityName()`
-
-Important: For Beta 2 the protected visibility of these three properties will be
-changed to private!
-
-## Console migrated to Symfony Console
-
-The Doctrine CLI has been replaced by Symfony Console Configuration
-
-Instead of having to specify:
-
-    [php]
-    $cliConfig = new CliConfiguration();
-    $cliConfig->setAttribute('em', $entityManager);
-
-You now have to configure the script like:
-
-    [php]
-    $helperSet = new \Symfony\Components\Console\Helper\HelperSet(array(
-        'db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($em->getConnection()),
-        'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em)
-    ));
-
-## Console: No need for Mapping Paths anymore
-
-In previous versions you had to specify the --from and --from-path options
-to show where your mapping paths are from the console. However this information
-is already known from the Mapping Driver configuration, so the requirement
-for this options were dropped.
-
-Instead for each console command all the entities are loaded and to
-restrict the operation to one or more sub-groups you can use the --filter flag.
-
-## AnnotationDriver is not a default mapping driver anymore
-
-In conjunction with the recent changes to Console we realized that the
-annotations driver being a default metadata driver lead to lots of glue
-code in the console components to detect where entities lie and how to load
-them for batch updates like SchemaTool and other commands. However the
-annotations driver being a default driver does not really help that much
-anyways.
-
-Therefore we decided to break backwards compability in this issue and drop
-the support for Annotations as Default Driver and require our users to
-specify the driver explicitly (which allows us to ask for the path to all
-entities).
-
-If you are using the annotations metadata driver as default driver, you
-have to add the following lines to your bootstrap code:
-
-    $driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__."/Entities"));
-    $config->setMetadataDriverImpl($driverImpl);
-
-You have to specify the path to your entities as either string of a single
-path or array of multiple paths
-to your entities. This information will be used by all console commands to
-access all entities.
-
-Xml and Yaml Drivers work as before!
-
-
-## New inversedBy attribute
-
-It is now *mandatory* that the owning side of a bidirectional association specifies the
-'inversedBy' attribute that points to the name of the field on the inverse side that completes
-the association. Example:
-
-    [php]
-    // BEFORE (ALPHA4 AND EARLIER)
-    class User
-    {
-        //...
-        /** @OneToOne(targetEntity="Address", mappedBy="user") */
-        private $address;
-        //...
-    }
-    class Address
-    {
-        //...
-        /** @OneToOne(targetEntity="User") */
-        private $user;
-        //...
-    }
-    
-    // SINCE BETA1
-    // User class DOES NOT CHANGE
-    class Address
-    {
-        //...
-        /** @OneToOne(targetEntity="User", inversedBy="address") */
-        private $user;
-        //...
-    }
-    
-Thus, the inversedBy attribute is the counterpart to the mappedBy attribute. This change
-was necessary to enable some simplifications and further performance improvements. We
-apologize for the inconvenience.
-
-## Default Property for Field Mappings
-
-The "default" option for database column defaults has been removed. If desired, database column defaults can
-be implemented by using the columnDefinition attribute of the @Column annotation (or the approriate XML and YAML equivalents).
-Prefer PHP default values, if possible.
-
-## Selecting Partial Objects
-
-Querying for partial objects now has a new syntax. The old syntax to query for partial objects
-now has a different meaning. This is best illustrated by an example. If you previously
-had a DQL query like this:
-
-    [sql]
-    SELECT u.id, u.name FROM User u
-    
-Since BETA1, simple state field path expressions in the select clause are used to select
-object fields as plain scalar values (something that was not possible before).
-To achieve the same result as previously (that is, a partial object with only id and name populated)
-you need to use the following, explicit syntax:
-
-    [sql]
-    SELECT PARTIAL u.{id,name} FROM User u
-
-## XML Mapping Driver
-
-The 'inheritance-type' attribute changed to take last bit of ClassMetadata constant names, i.e.
-NONE, SINGLE_TABLE, INHERITANCE_TYPE_JOINED
-
-## YAML Mapping Driver
-
-The way to specify lifecycle callbacks in YAML Mapping driver was changed to allow for multiple callbacks
-per event. The Old syntax ways:
-
-    [yaml]
-    lifecycleCallbacks:
-      doStuffOnPrePersist: prePersist
-      doStuffOnPostPersist: postPersist
-
-The new syntax is:
-
-    [yaml]
-    lifecycleCallbacks:
-      prePersist: [ doStuffOnPrePersist, doOtherStuffOnPrePersistToo ]
-      postPersist: [ doStuffOnPostPersist ]
-
-## PreUpdate Event Listeners
-
-Event Listeners listening to the 'preUpdate' event can only affect the primitive values of entity changesets
-by using the API on the `PreUpdateEventArgs` instance passed to the preUpdate listener method. Any changes
-to the state of the entitys properties won't affect the database UPDATE statement anymore. This gives drastic
-performance benefits for the preUpdate event.
-
-## Collection API
-
-The Collection interface in the Common package has been updated with some missing methods
-that were present only on the default implementation, ArrayCollection. Custom collection
-implementations need to be updated to adhere to the updated interface.
-

UPGRADE_TO_2_1

@@ -1,25 +0,0 @@
-This document details all the possible changes that you should investigate when updating
-your project from Doctrine 2.0.x to 2.1
-
-## Interface for EntityRepository
-
-The EntityRepository now has an interface Doctrine\Common\Persistence\ObjectRepository. This means that your classes that override EntityRepository and extend find(), findOneBy() or findBy() must be adjusted to follow this interface.
-
-## AnnotationReader changes
-
-The annotation reader was heavily refactored between 2.0 and 2.1-RC1. In theory the operation of the new reader should be backwards compatible, but it has to be setup differently to work that way:
-
-    // new call to the AnnotationRegistry
-    \Doctrine\Common\Annotations\AnnotationRegistry::registerFile('/doctrine-src/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
-
-    $reader = new \Doctrine\Common\Annotations\AnnotationReader();
-    $reader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\\');
-    // new code necessary starting here
-    $reader->setIgnoreNotImportedAnnotations(true);
-    $reader->setEnableParsePhpImports(false);
-    $reader = new \Doctrine\Common\Annotations\CachedReader(
-        new \Doctrine\Common\Annotations\IndexedReader($reader), new ArrayCache()
-    );
-
-This is already done inside the ``$config->newDefaultAnnotationDriver``, so everything should automatically work if you are using this method. You can verify if everything still works by executing a console command such as schema-validate that loads all metadata into memory.
-

UPGRADE_TO_2_2

@@ -1,81 +0,0 @@
-# ResultCache implementation rewritten
-
-The result cache is completely rewritten and now works on the database result level, not inside the ORM AbstractQuery
-anymore. This means that for result cached queries the hydration will now always be performed again, regardless of
-the hydration mode. Affected areas are:
-
-1. Fixes the problem that entities coming from the result cache were not registered in the UnitOfWork
-   leading to problems during EntityManager#flush. Calls to EntityManager#merge are not necessary anymore.
-2. Affects the array hydrator which now includes the overhead of hydration compared to caching the final result.
-
-The API is backwards compatible however most of the getter methods on the `AbstractQuery` object are now
-deprecated in favor of calling AbstractQuery#getQueryCacheProfile(). This method returns a `Doctrine\DBAL\Cache\QueryCacheProfile`
-instance with access to result cache driver, lifetime and cache key.
-
-
-# EntityManager#getPartialReference() creates read-only entity
-
-Entities returned from EntityManager#getPartialReference() are now marked as read-only if they
-haven't been in the identity map before. This means objects of this kind never lead to changes
-in the UnitOfWork.
-
-
-# Fields omitted in a partial DQL query or a native query are never updated
-
-Fields of an entity that are not returned from a partial DQL Query or native SQL query
-will never be updated through an UPDATE statement.
-
-
-# Removed support for onUpdate in @JoinColumn
-
-The onUpdate foreign key handling makes absolutely no sense in an ORM. Additionally Oracle doesn't even support it. Support for it is removed.
-
-
-# Changes in Annotation Handling
-
-There have been some changes to the annotation handling in Common 2.2 again, that affect how people with old configurations
-from 2.0 have to configure the annotation driver if they don't use `Configuration::newDefaultAnnotationDriver()`:
-
-    // Register the ORM Annotations in the AnnotationRegistry
-    AnnotationRegistry::registerFile('path/to/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
-
-    $reader = new \Doctrine\Common\Annotations\SimpleAnnotationReader();
-    $reader->addNamespace('Doctrine\ORM\Mapping');
-    $reader = new \Doctrine\Common\Annotations\CachedReader($reader, new ArrayCache());
-
-    $driver = new AnnotationDriver($reader, (array)$paths);
-
-    $config->setMetadataDriverImpl($driver);
-
-
-# Scalar mappings can now be ommitted from DQL result
-
-You are now allowed to mark scalar SELECT expressions as HIDDEN an they are not hydrated anymore.
-Example:
-
-SELECT u, SUM(a.id) AS HIDDEN numArticles FROM User u LEFT JOIN u.Articles a ORDER BY numArticles DESC HAVING numArticles > 10
-
-Your result will be a collection of Users, and not an array with key 0 as User object instance and "numArticles" as the number of articles per user
-
-
-# Map entities as scalars in DQL result
-
-When hydrating to array or even a mixed result in object hydrator, previously you had the 0 index holding you entity instance.
-You are now allowed to alias this, providing more flexibility for you code.
-Example:
-
-SELECT u AS user FROM User u
-
-Will now return a collection of arrays with index "user" pointing to the User object instance.
-
-
-# Performance optimizations
-
-Thousands of lines were completely reviewed and optimized for best performance.
-Removed redundancy and improved code readability made now internal Doctrine code easier to understand.
-Also, Doctrine 2.2 now is around 10-15% faster than 2.1.
-
-# EntityManager#find(null)
-
-Previously EntityManager#find(null) returned null. It now throws an exception.
-

UPGRADE_TO_ALPHA3

@@ -1,35 +0,0 @@
-# Upgrade from 2.0-ALPHA2 to 2.0-ALPHA3
-
-This section details the changes made to Doctrine 2.0-ALPHA3 to make it easier for you
-to upgrade your projects to use this version.  
-
-## CLI Changes
-
-The $args variable used in the cli-config.php for configuring the Doctrine CLI has been renamed to $globalArguments.
-
-## Proxy class changes
-
-You are now required to make supply some minimalist configuration with regards to proxy objects. That involves 2 new configuration options. First, the directory where generated proxy classes should be placed needs to be specified. Secondly, you need to configure the namespace used for proxy classes. The following snippet shows an example:
-
-    [php]
-    // step 1: configure directory for proxy classes
-    // $config instanceof Doctrine\ORM\Configuration
-    $config->setProxyDir('/path/to/myproject/lib/MyProject/Generated/Proxies');
-    $config->setProxyNamespace('MyProject\Generated\Proxies');
-
-Note that proxy classes behave exactly like any other classes when it comes to class loading. Therefore you need to make sure the proxy classes can be loaded by some class loader. If you place the generated proxy classes in a namespace and directory under your projects class files, like in the example above, it would be sufficient to register the MyProject namespace on a class loader. Since the proxy classes are contained in that namespace and adhere to the standards for class loading, no additional work is required.
-Generating the proxy classes into a namespace within your class library is the recommended setup.
-
-Entities with initialized proxy objects can now be serialized and unserialized properly from within the same application.
-
-For more details refer to the Configuration section of the manual.
-
-## Removed allowPartialObjects configuration option
-
-The allowPartialObjects configuration option together with the `Configuration#getAllowPartialObjects` and `Configuration#setAllowPartialObjects` methods have been removed.
-The new behavior is as if the option were set to FALSE all the time, basically disallowing partial objects globally. However, you can still use the `Query::HINT_FORCE_PARTIAL_LOAD` query hint to force a query to return partial objects for optimization purposes.
-
-## Renamed Methods
-
-* Doctrine\ORM\Configuration#getCacheDir() to getProxyDir()
-* Doctrine\ORM\Configuration#setCacheDir($dir) to setProxyDir($dir)

UPGRADE_TO_ALPHA4

@@ -1,36 +0,0 @@
-# Upgrade from 2.0-ALPHA3 to 2.0-ALPHA4
-
-## CLI Controller changes
-
-CLI main object changed its name and namespace. Renamed from Doctrine\ORM\Tools\Cli to Doctrine\Common\Cli\CliController.
-Doctrine\Common\Cli\CliController now only deals with namespaces. Ready to go, Core, Dbal and Orm are available and you can subscribe new tasks by retrieving the namespace and including new task. Example:
-
-    [php]
-    $cli->getNamespace('Core')->addTask('my-example', '\MyProject\Tools\Cli\Tasks\MyExampleTask');
-
-
-## CLI Tasks documentation
-
-Tasks have implemented a new way to build documentation. Although it is still possible to define the help manually by extending the basicHelp and extendedHelp, they are now optional.
-With new required method AbstractTask::buildDocumentation, its implementation defines the TaskDocumentation instance (accessible through AbstractTask::getDocumentation()), basicHelp and extendedHelp are now not necessary to be implemented.
-
-## Changes in Method Signatures
-
-    * A bunch of Methods on both Doctrine\DBAL\Platforms\AbstractPlatform and Doctrine\DBAL\Schema\AbstractSchemaManager
-      have changed quite significantly by adopting the new Schema instance objects.
-
-## Renamed Methods
-
-    * Doctrine\ORM\AbstractQuery::setExpireResultCache() -> expireResultCache()
-    * Doctrine\ORM\Query::setExpireQueryCache() -> expireQueryCache()
-
-## SchemaTool Changes
-
-    * "doctrine schema-tool --drop" now always drops the complete database instead of
-    only those tables defined by the current database model. The previous method had
-    problems when foreign keys of orphaned tables pointed to tables that were schedulded
-    for deletion.
-    * Use "doctrine schema-tool --update" to get a save incremental update for your
-    database schema without deleting any unused tables, sequences or foreign keys.
-    * Use "doctrine schema-tool --complete-update" to do a full incremental update of
-    your schema.

bin/doctrine

@@ -1,4 +1,4 @@
 #!/usr/bin/env php
 <?php
 
-include('doctrine.php');
+include('doctrine.php');

bin/doctrine-pear.php

@@ -0,0 +1,50 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+require_once 'Doctrine/Common/ClassLoader.php';
+
+$classLoader = new \Doctrine\Common\ClassLoader('Doctrine');
+$classLoader->register();
+
+$classLoader = new \Doctrine\Common\ClassLoader('Symfony');
+$classLoader->register();
+
+$configFile = getcwd() . DIRECTORY_SEPARATOR . 'cli-config.php';
+
+$helperSet = null;
+if (file_exists($configFile)) {
+    if ( ! is_readable($configFile)) {
+        trigger_error(
+            'Configuration file [' . $configFile . '] does not have read permission.', E_ERROR
+        );
+    }
+
+    require $configFile;
+
+    foreach ($GLOBALS as $helperSetCandidate) {
+        if ($helperSetCandidate instanceof \Symfony\Component\Console\Helper\HelperSet) {
+            $helperSet = $helperSetCandidate;
+            break;
+        }
+    }
+}
+
+$helperSet = ($helperSet) ?: new \Symfony\Component\Console\Helper\HelperSet();
+
+\Doctrine\ORM\Tools\Console\ConsoleRunner::run($helperSet);

bin/doctrine.php

@@ -17,14 +17,7 @@
  * <http://www.doctrine-project.org>.
  */
 
-require_once 'Doctrine/Common/ClassLoader.php';
-
-$classLoader = new \Doctrine\Common\ClassLoader('Doctrine');
-$classLoader->register();
-
-$classLoader = new \Doctrine\Common\ClassLoader('Symfony', 'Doctrine');
-$classLoader->register();
-
+(@include_once __DIR__ . '/../vendor/autoload.php') || @include_once __DIR__ . '/../../../autoload.php';
 $configFile = getcwd() . DIRECTORY_SEPARATOR . 'cli-config.php';
 
 $helperSet = null;

build.xml

@@ -19,7 +19,7 @@
     -->
     <fileset id="bin-scripts" dir="./bin">
         <include name="doctrine"/>
-        <include name="doctrine.php"/>
+        <include name="doctrine-pear.php"/>
         <include name="doctrine.bat"/>
     </fileset>
 
@@ -92,8 +92,8 @@
            <dependencies>
                <php minimum_version="5.3.0" />
                <pear minimum_version="1.6.0" recommended_version="1.6.1" />
-               <package name="DoctrineCommon" channel="pear.doctrine-project.org" minimum_version="${dependencies.common}" maximum_version="2.2.99" />
-               <package name="DoctrineDBAL" channel="pear.doctrine-project.org" minimum_version="${dependencies.dbal}" maximum_version="2.2.99" />
+               <package name="DoctrineCommon" channel="pear.doctrine-project.org" minimum_version="${dependencies.common}" />
+               <package name="DoctrineDBAL" channel="pear.doctrine-project.org" minimum_version="${dependencies.dbal}" />
                <package name="Console" channel="pear.symfony.com" minimum_version="2.0.0" />
                <package name="Yaml" channel="pear.symfony.com" minimum_version="2.0.0" />
            </dependencies>
@@ -104,7 +104,7 @@
            <ignore>Symfony/Component/Console/</ignore>
            <release>
                 <install as="doctrine" name="bin/doctrine" />
-                <install as="doctrine.php" name="bin/doctrine.php" />
+                <install as="doctrine.php" name="bin/doctrine-pear.php" />
                 <install as="doctrine.bat" name="bin/doctrine.bat" />
            </release>
            <replacement path="bin/doctrine" type="pear-config" from="@php_bin@" to="php_bin" />

composer.json

@@ -1,10 +1,10 @@
 {
     "name": "doctrine/orm",
-    "type": "library","version":"2.2.3",
+    "type": "library","version":"2.3.5",
     "description": "Object-Relational-Mapper for PHP",
     "keywords": ["orm", "database"],
     "homepage": "http://www.doctrine-project.org",
-    "license": "LGPL",
+    "license": "MIT",
     "authors": [
         {"name": "Guilherme Blanco", "email": "guilhermeblanco@gmail.com"},
         {"name": "Roman Borschel", "email": "roman@code-factory.org"},
@@ -14,10 +14,19 @@
     "require": {
         "php": ">=5.3.2",
         "ext-pdo": "*",
-        "doctrine/common": "2.2.*",
-        "doctrine/dbal": "2.2.*"
+        "doctrine/dbal": "2.3.*",
+        "symfony/console": "2.*"
+    },
+    "suggest": {
+        "symfony/yaml": "If you want to use YAML Metadata Mapping Driver"
     },
     "autoload": {
         "psr-0": { "Doctrine\\ORM": "lib/" }
+    },
+    "bin": ["bin/doctrine", "bin/doctrine.php"],
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.3.x-dev"
+        }
     }
 }

doctrine-mapping.xsd

@@ -84,20 +84,69 @@
     </xs:sequence>
   </xs:complexType>
 
+  <xs:complexType name="named-native-query">
+    <xs:attribute name="name" type="xs:string" use="required" />
+    <xs:attribute name="query" type="xs:string" use="required"/>
+    <xs:attribute name="result-class" type="xs:string" />
+    <xs:attribute name="result-set-mapping" type="xs:string" />
+  </xs:complexType>
+
+  <xs:complexType name="named-native-queries">
+    <xs:sequence>
+      <xs:element name="named-native-query" type="orm:named-native-query" minOccurs="1" maxOccurs="unbounded" />
+      <xs:any minOccurs="1" maxOccurs="unbounded" namespace="##other"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="column-result">
+    <xs:attribute name="name" type="xs:string" use="required" />
+  </xs:complexType>
+
+  <xs:complexType name="field-result">
+    <xs:attribute name="name" type="xs:string" use="required" />
+    <xs:attribute name="column" type="xs:string" />
+  </xs:complexType>
+
+  <xs:complexType name="entity-result">
+    <xs:sequence>
+      <xs:element name="field-result" type="orm:field-result" minOccurs="0" maxOccurs="unbounded" />
+    </xs:sequence>
+    <xs:attribute name="entity-class" type="xs:string" use="required" />
+  </xs:complexType>
+
+  <xs:complexType name="sql-result-set-mapping">
+    <xs:sequence>
+      <xs:element name="entity-result" type="orm:entity-result" minOccurs="0" maxOccurs="unbounded" />
+      <xs:element name="column-result" type="orm:column-result" minOccurs="0" maxOccurs="unbounded" />
+      <xs:any minOccurs="1" maxOccurs="unbounded" namespace="##other"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="sql-result-set-mappings">
+    <xs:sequence>
+      <xs:element name="sql-result-set-mapping" type="orm:sql-result-set-mapping" minOccurs="1" maxOccurs="unbounded" />
+      <xs:any minOccurs="1" maxOccurs="unbounded" namespace="##other"/>
+    </xs:sequence>
+  </xs:complexType>
+
   <xs:complexType name="entity">
     <xs:sequence>
+      <xs:element name="options" type="orm:options" minOccurs="0" />
       <xs:element name="indexes" type="orm:indexes" minOccurs="0"/>
       <xs:element name="unique-constraints" type="orm:unique-constraints" minOccurs="0"/>
       <xs:element name="discriminator-column" type="orm:discriminator-column" minOccurs="0"/>
       <xs:element name="discriminator-map" type="orm:discriminator-map" minOccurs="0"/>
       <xs:element name="lifecycle-callbacks" type="orm:lifecycle-callbacks" minOccurs="0" maxOccurs="1" />
       <xs:element name="named-queries" type="orm:named-queries" minOccurs="0" maxOccurs="1" />
+      <xs:element name="named-native-queries" type="orm:named-native-queries" minOccurs="0" maxOccurs="1" />
       <xs:element name="id" type="orm:id" minOccurs="0" maxOccurs="unbounded" />
       <xs:element name="field" type="orm:field" minOccurs="0" maxOccurs="unbounded"/>
       <xs:element name="one-to-one" type="orm:one-to-one" minOccurs="0" maxOccurs="unbounded"/>
       <xs:element name="one-to-many" type="orm:one-to-many" minOccurs="0" maxOccurs="unbounded" />
       <xs:element name="many-to-one" type="orm:many-to-one" minOccurs="0" maxOccurs="unbounded" />
       <xs:element name="many-to-many" type="orm:many-to-many" minOccurs="0" maxOccurs="unbounded" />
+      <xs:element name="association-overrides" type="orm:association-overrides" minOccurs="0" maxOccurs="unbounded" />
+      <xs:element name="attribute-overrides" type="orm:attribute-overrides" minOccurs="0" maxOccurs="unbounded" />
       <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
     </xs:sequence>
     <xs:attribute name="name" type="xs:string" use="required" />
@@ -110,6 +159,23 @@
     <xs:anyAttribute namespace="##other"/>
   </xs:complexType>
   
+  <xs:complexType name="option" mixed="true">
+    <xs:sequence minOccurs="0" maxOccurs="unbounded">
+      <xs:element name="option" type="orm:option"/>
+      <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
+    </xs:sequence>
+    <xs:attribute name="name" type="xs:NMTOKEN" use="required"/>
+    <xs:anyAttribute namespace="##other"/>
+  </xs:complexType>
+
+  <xs:complexType name="options">
+    <xs:sequence>
+      <xs:element name="option" type="orm:option" minOccurs="0" maxOccurs="unbounded"/>
+      <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
+    </xs:sequence>
+    <xs:anyAttribute namespace="##other"/>
+  </xs:complexType>
+
   <xs:complexType name="mapped-superclass" >
     <xs:complexContent>
       <xs:extension base="orm:entity">
@@ -143,6 +209,8 @@
       <xs:enumeration value="SEQUENCE"/> 
       <xs:enumeration value="IDENTITY"/> 
       <xs:enumeration value="AUTO"/> 
+      <xs:enumeration value="UUID"/> 
+      <xs:enumeration value="CUSTOM" />
     </xs:restriction> 
   </xs:simpleType>
   
@@ -158,12 +226,13 @@
     <xs:restriction base="xs:token"> 
       <xs:enumeration value="EAGER"/> 
       <xs:enumeration value="LAZY"/>
-      <xs:enumeration value="EXTRALAZY"/>
+      <xs:enumeration value="EXTRA_LAZY"/>
     </xs:restriction> 
   </xs:simpleType>
 
   <xs:complexType name="field">
     <xs:sequence>
+      <xs:element name="options" type="orm:options" minOccurs="0" />
       <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
     </xs:sequence>
     <xs:attribute name="name" type="xs:NMTOKEN" use="required" />
@@ -184,9 +253,10 @@
       <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
     </xs:sequence>
     <xs:attribute name="name" type="xs:NMTOKEN" use="required" />
-    <xs:attribute name="type" type="xs:NMTOKEN" use="required" />
+    <xs:attribute name="type" type="xs:NMTOKEN"/>
     <xs:attribute name="field-name" type="xs:NMTOKEN" />
     <xs:attribute name="length" type="xs:NMTOKEN" />
+    <xs:attribute name="column-definition" type="xs:string" />
     <xs:anyAttribute namespace="##other"/>
   </xs:complexType>
   
@@ -253,12 +323,15 @@
     <xs:sequence>
       <xs:element name="generator" type="orm:generator" minOccurs="0" />
       <xs:element name="sequence-generator" type="orm:sequence-generator" minOccurs="0" maxOccurs="1" />
+      <xs:element name="custom-id-generator" type="orm:custom-id-generator" minOccurs="0" maxOccurs="1" />
       <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
     </xs:sequence>
     <xs:attribute name="name" type="xs:NMTOKEN" use="required" />
     <xs:attribute name="type" type="xs:NMTOKEN" />
     <xs:attribute name="column" type="xs:NMTOKEN" />
+    <xs:attribute name="length" type="xs:NMTOKEN" />
     <xs:attribute name="association-key" type="xs:boolean" default="false" />
+    <xs:attribute name="column-definition" type="xs:string" />
     <xs:anyAttribute namespace="##other"/>
   </xs:complexType>
 
@@ -272,6 +345,13 @@
     <xs:anyAttribute namespace="##other"/>
   </xs:complexType>
 
+  <xs:complexType name="custom-id-generator">
+    <xs:sequence>
+      <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
+    </xs:sequence>
+    <xs:attribute name="class" type="xs:NMTOKEN" use="required" />
+  </xs:complexType>
+
   <xs:complexType name="inverse-join-columns">
     <xs:sequence>
       <xs:element name="join-column" type="orm:join-column" minOccurs="1" maxOccurs="unbounded" />
@@ -406,4 +486,35 @@
     <xs:anyAttribute namespace="##other"/>
   </xs:complexType>
 
+  <xs:complexType name="association-overrides">
+    <xs:sequence>
+      <xs:element name="association-override" type="orm:association-override" minOccurs="1" maxOccurs="unbounded" />
+      <xs:any minOccurs="1" maxOccurs="unbounded" namespace="##other"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="association-override">
+    <xs:sequence>
+      <xs:element name="join-table" type="orm:join-table" minOccurs="0" />
+      <xs:element name="join-columns" type="orm:join-columns" minOccurs="0" />
+      <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
+    </xs:sequence>
+    <xs:attribute name="name" type="xs:NMTOKEN" use="required" />
+  </xs:complexType>
+
+  <xs:complexType name="attribute-overrides">
+    <xs:sequence>
+      <xs:element name="attribute-override" type="orm:attribute-override" minOccurs="1" maxOccurs="unbounded" />
+      <xs:any minOccurs="1" maxOccurs="unbounded" namespace="##other"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="attribute-override">
+    <xs:sequence>
+      <xs:element name="field" type="orm:field" minOccurs="1" />
+      <xs:any minOccurs="1" maxOccurs="unbounded" namespace="##other"/>
+    </xs:sequence>
+    <xs:attribute name="name" type="xs:NMTOKEN" use="required" />
+  </xs:complexType>
+
 </xs:schema>

lib/Doctrine/ORM/AbstractQuery.php

@@ -13,21 +13,24 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM;
 
-use Doctrine\DBAL\Types\Type,
-    Doctrine\DBAL\Cache\QueryCacheProfile,
-    Doctrine\ORM\Query\QueryException,
-    Doctrine\ORM\Internal\Hydration\CacheHydrator;
+use Doctrine\Common\Util\ClassUtils;
+use Doctrine\Common\Collections\ArrayCollection;
+
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Cache\QueryCacheProfile;
+
+use Doctrine\ORM\Query\QueryException;
+use Doctrine\ORM\Mapping;
 
 /**
  * Base contract for ORM queries. Base class for Query and NativeQuery.
  *
- * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
  * @link    www.doctrine-project.org
  * @since   2.0
  * @author  Benjamin Eberlei <kontakt@beberlei.de>
@@ -62,14 +65,9 @@ abstract class AbstractQuery
     const HYDRATE_SIMPLEOBJECT = 5;
 
     /**
-     * @var array The parameter map of this query.
+     * @var \Doctrine\Common\Collections\ArrayCollection The parameter map of this query.
      */
-    protected $_params = array();
-
-    /**
-     * @var array The parameter type map of this query.
-     */
-    protected $_paramTypes = array();
+    protected $parameters;
 
     /**
      * @var ResultSetMapping The user-specified ResultSetMapping to use.
@@ -114,8 +112,18 @@ abstract class AbstractQuery
     public function __construct(EntityManager $em)
     {
         $this->_em = $em;
+        $this->parameters = new ArrayCollection();
     }
 
+    /**
+     * Gets the SQL query that corresponds to this query object.
+     * The returned SQL syntax depends on the connection driver that is used
+     * by this query object at the time of this method call.
+     *
+     * @return string SQL query
+     */
+    abstract public function getSQL();
+
     /**
      * Retrieves the associated EntityManager of this Query instance.
      *
@@ -135,69 +143,67 @@ abstract class AbstractQuery
      */
     public function free()
     {
-        $this->_params = array();
-        $this->_paramTypes = array();
+        $this->parameters = new ArrayCollection();
+
         $this->_hints = array();
     }
 
     /**
      * Get all defined parameters.
      *
-     * @return array The defined query parameters.
+     * @return \Doctrine\Common\Collections\ArrayCollection The defined query parameters.
      */
     public function getParameters()
     {
-        return $this->_params;
-    }
-
-    /**
-     * Get all defined parameter types.
-     *
-     * @return array The defined query parameter types.
-     */
-    public function getParameterTypes()
-    {
-        return $this->_paramTypes;
+        return $this->parameters;
     }
 
     /**
      * Gets a query parameter.
      *
      * @param mixed $key The key (index or name) of the bound parameter.
+     *
      * @return mixed The value of the bound parameter.
      */
     public function getParameter($key)
     {
-        if (isset($this->_params[$key])) {
-            return $this->_params[$key];
-        }
+        $filteredParameters = $this->parameters->filter(
+            function ($parameter) use ($key)
+            {
+                // Must not be identical because of string to integer conversion
+                return ($key == $parameter->getName());
+            }
+        );
 
-        return null;
+        return count($filteredParameters) ? $filteredParameters->first() : null;
     }
 
     /**
-     * Gets a query parameter type.
+     * Sets a collection of query parameters.
      *
-     * @param mixed $key The key (index or name) of the bound parameter.
-     * @return mixed The parameter type of the bound parameter.
+     * @param \Doctrine\Common\Collections\ArrayCollection|array $parameters
+     *
+     * @return \Doctrine\ORM\AbstractQuery This query instance.
      */
-    public function getParameterType($key)
+    public function setParameters($parameters)
     {
-        if (isset($this->_paramTypes[$key])) {
-            return $this->_paramTypes[$key];
+        // BC compatibility with 2.3-
+        if (is_array($parameters)) {
+            $parameterCollection = new ArrayCollection();
+
+            foreach ($parameters as $key => $value) {
+                $parameter = new Query\Parameter($key, $value);
+
+                $parameterCollection->add($parameter);
+            }
+
+            $parameters = $parameterCollection;
         }
 
-        return null;
-    }
+        $this->parameters = $parameters;
 
-    /**
-     * Gets the SQL query that corresponds to this query object.
-     * The returned SQL syntax depends on the connection driver that is used
-     * by this query object at the time of this method call.
-     *
-     * @return string SQL query
-     */
-    abstract public function getSQL();
+        return $this;
+    }
 
     /**
      * Sets a query parameter.
@@ -207,19 +213,29 @@ abstract class AbstractQuery
      * @param string $type The parameter type. If specified, the given value will be run through
      *                     the type conversion of this type. This is usually not needed for
      *                     strings and numeric types.
+     *
      * @return \Doctrine\ORM\AbstractQuery This query instance.
      */
     public function setParameter($key, $value, $type = null)
     {
-        $key = trim($key, ':');
+        $filteredParameters = $this->parameters->filter(
+            function ($parameter) use ($key)
+            {
+                // Must not be identical because of string to integer conversion
+                return ($key == $parameter->getName());
+            }
+        );
 
-        $value = $this->processParameterValue($value);
-        if ($type === null) {
-            $type = Query\ParameterTypeInferer::inferType($value);
+        if (count($filteredParameters)) {
+            $parameter = $filteredParameters->first();
+            $parameter->setValue($value, $type);
+
+            return $this;
         }
 
-        $this->_paramTypes[$key] = $type;
-        $this->_params[$key] = $value;
+        $parameter = new Query\Parameter($key, $value, $type);
+
+        $this->parameters->add($parameter);
 
         return $this;
     }
@@ -230,63 +246,54 @@ abstract class AbstractQuery
      * @param mixed $value
      * @return array
      */
-    private function processParameterValue($value)
+    public function processParameterValue($value)
     {
         switch (true) {
             case is_array($value):
-                for ($i = 0, $l = count($value); $i < $l; $i++) {
-                    $paramValue = $this->processParameterValue($value[$i]);
-                    $value[$i] = is_array($paramValue) ? $paramValue[key($paramValue)] : $paramValue;
+                foreach ($value as $key => $paramValue) {
+                    $paramValue  = $this->processParameterValue($paramValue);
+                    $value[$key] = is_array($paramValue) ? $paramValue[key($paramValue)] : $paramValue;
                 }
 
                 return $value;
 
-            case is_object($value) && $this->_em->getMetadataFactory()->hasMetadataFor(get_class($value)):
+            case is_object($value) && $this->_em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($value)):
                 return $this->convertObjectParameterToScalarValue($value);
 
+            case ($value instanceof Mapping\ClassMetadata):
+                return $value->name;
+
             default:
                 return $value;
         }
     }
 
-    protected function convertObjectParameterToScalarValue($value)
+    private function convertObjectParameterToScalarValue($value)
     {
         $class = $this->_em->getClassMetadata(get_class($value));
 
         if ($class->isIdentifierComposite) {
-            throw new \InvalidArgumentException("Binding an entity with a composite primary key to a query is not supported. You should split the parameter into the explicit fields and bind them seperately.");
+            throw new \InvalidArgumentException(
+                "Binding an entity with a composite primary key to a query is not supported. " .
+                "You should split the parameter into the explicit fields and bind them seperately."
+            );
         }
 
-        if ($this->_em->getUnitOfWork()->getEntityState($value) === UnitOfWork::STATE_MANAGED) {
-            $values = $this->_em->getUnitOfWork()->getEntityIdentifier($value);
-        } else {
-            $values = $class->getIdentifierValues($value);
-        }
+        $values = ($this->_em->getUnitOfWork()->getEntityState($value) === UnitOfWork::STATE_MANAGED)
+            ? $this->_em->getUnitOfWork()->getEntityIdentifier($value)
+            : $class->getIdentifierValues($value);
 
         $value = $values[$class->getSingleIdentifierFieldName()];
-        if (!$value) {
-            throw new \InvalidArgumentException("Binding entities to query parameters only allowed for entities that have an identifier.");
+
+        if (null === $value) {
+            throw new \InvalidArgumentException(
+                "Binding entities to query parameters only allowed for entities that have an identifier."
+            );
         }
 
         return $value;
     }
 
-    /**
-     * Sets a collection of query parameters.
-     *
-     * @param array $params
-     * @param array $types
-     * @return \Doctrine\ORM\AbstractQuery This query instance.
-     */
-    public function setParameters(array $params, array $types = array())
-    {
-        foreach ($params as $key => $value) {
-            $this->setParameter($key, $value, isset($types[$key]) ? $types[$key] : null);
-        }
-
-        return $this;
-    }
-
     /**
      * Sets the ResultSetMapping that should be used for hydration.
      *
@@ -526,37 +533,37 @@ abstract class AbstractQuery
     /**
      * Gets the list of results for the query.
      *
-     * Alias for execute(array(), $hydrationMode = HYDRATE_OBJECT).
+     * Alias for execute(null, $hydrationMode = HYDRATE_OBJECT).
      *
      * @return array
      */
     public function getResult($hydrationMode = self::HYDRATE_OBJECT)
     {
-        return $this->execute(array(), $hydrationMode);
+        return $this->execute(null, $hydrationMode);
     }
 
     /**
      * Gets the array of results for the query.
      *
-     * Alias for execute(array(), HYDRATE_ARRAY).
+     * Alias for execute(null, HYDRATE_ARRAY).
      *
      * @return array
      */
     public function getArrayResult()
     {
-        return $this->execute(array(), self::HYDRATE_ARRAY);
+        return $this->execute(null, self::HYDRATE_ARRAY);
     }
 
     /**
      * Gets the scalar results for the query.
      *
-     * Alias for execute(array(), HYDRATE_SCALAR).
+     * Alias for execute(null, HYDRATE_SCALAR).
      *
      * @return array
      */
     public function getScalarResult()
     {
-        return $this->execute(array(), self::HYDRATE_SCALAR);
+        return $this->execute(null, self::HYDRATE_SCALAR);
     }
 
     /**
@@ -568,7 +575,7 @@ abstract class AbstractQuery
      */
     public function getOneOrNullResult($hydrationMode = null)
     {
-        $result = $this->execute(array(), $hydrationMode);
+        $result = $this->execute(null, $hydrationMode);
 
         if ($this->_hydrationMode !== self::HYDRATE_SINGLE_SCALAR && ! $result) {
             return null;
@@ -600,7 +607,7 @@ abstract class AbstractQuery
      */
     public function getSingleResult($hydrationMode = null)
     {
-        $result = $this->execute(array(), $hydrationMode);
+        $result = $this->execute(null, $hydrationMode);
 
         if ($this->_hydrationMode !== self::HYDRATE_SINGLE_SCALAR && ! $result) {
             throw new NoResultException;
@@ -655,6 +662,18 @@ abstract class AbstractQuery
         return isset($this->_hints[$name]) ? $this->_hints[$name] : false;
     }
 
+    /**
+     * Check if the query has a hint
+     *
+     * @param  string $name The name of the hint
+     *
+     * @return bool False if the query does not have any hint
+     */
+    public function hasHint($name)
+    {
+        return isset($this->_hints[$name]);
+    }
+
     /**
      * Return the key value map of query hints that are currently set.
      *
@@ -669,18 +688,18 @@ abstract class AbstractQuery
      * Executes the query and returns an IterableResult that can be used to incrementally
      * iterate over the result.
      *
-     * @param array $params The query parameters.
+     * @param \Doctrine\Common\Collections\ArrayCollection|array $parameters The query parameters.
      * @param integer $hydrationMode The hydration mode to use.
      * @return \Doctrine\ORM\Internal\Hydration\IterableResult
      */
-    public function iterate(array $params = array(), $hydrationMode = null)
+    public function iterate($parameters = null, $hydrationMode = null)
     {
         if ($hydrationMode !== null) {
             $this->setHydrationMode($hydrationMode);
         }
 
-        if ($params) {
-            $this->setParameters($params);
+        if ( ! empty($parameters)) {
+            $this->setParameters($parameters);
         }
 
         $stmt = $this->_doExecute();
@@ -693,18 +712,18 @@ abstract class AbstractQuery
     /**
      * Executes the query.
      *
-     * @param array $params Any additional query parameters.
+     * @param \Doctrine\Common\Collections\ArrayCollection|array $parameters Query parameters.
      * @param integer $hydrationMode Processing mode to be used during the hydration process.
      * @return mixed
      */
-    public function execute($params = array(), $hydrationMode = null)
+    public function execute($parameters = null, $hydrationMode = null)
     {
         if ($hydrationMode !== null) {
             $this->setHydrationMode($hydrationMode);
         }
 
-        if ($params) {
-            $this->setParameters($params);
+        if ( ! empty($parameters)) {
+            $this->setParameters($parameters);
         }
 
         $setCacheEntry = function() {};
@@ -726,6 +745,7 @@ abstract class AbstractQuery
 
             $setCacheEntry = function($data) use ($cache, $result, $cacheKey, $realCacheKey, $queryCacheProfile) {
                 $result[$realCacheKey] = $data;
+
                 $cache->save($cacheKey, $result, $queryCacheProfile->getLifetime());
             };
         }
@@ -756,24 +776,25 @@ abstract class AbstractQuery
      */
     protected function getHydrationCacheId()
     {
-        $params = $this->getParameters();
+        $parameters = array();
 
-        foreach ($params AS $key => $value) {
-            $params[$key] = $this->processParameterValue($value);
+        foreach ($this->getParameters() as $parameter) {
+            $parameters[$parameter->getName()] = $this->processParameterValue($parameter->getValue());
         }
 
         $sql                    = $this->getSQL();
         $queryCacheProfile      = $this->getHydrationCacheProfile();
         $hints                  = $this->getHints();
         $hints['hydrationMode'] = $this->getHydrationMode();
+
         ksort($hints);
 
-        return $queryCacheProfile->generateCacheKeys($sql, $params, $hints);
+        return $queryCacheProfile->generateCacheKeys($sql, $parameters, $hints);
     }
 
     /**
      * Set the result cache id to use to store the result set cache entry.
-     * If this is not explicitely set by the developer then a hash is automatically
+     * If this is not explicitly set by the developer then a hash is automatically
      * generated for you.
      *
      * @param string $id
@@ -813,8 +834,8 @@ abstract class AbstractQuery
      */
     public function __clone()
     {
-        $this->_params = array();
-        $this->_paramTypes = array();
+        $this->parameters = new ArrayCollection();
+
         $this->_hints = array();
     }
 }

lib/Doctrine/ORM/Configuration.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -23,8 +23,14 @@ use Doctrine\Common\Cache\Cache,
     Doctrine\Common\Cache\ArrayCache,
     Doctrine\Common\Annotations\AnnotationRegistry,
     Doctrine\Common\Annotations\AnnotationReader,
-    Doctrine\ORM\Mapping\Driver\Driver,
-    Doctrine\ORM\Mapping\Driver\AnnotationDriver;
+    Doctrine\Common\Persistence\Mapping\Driver\MappingDriver,
+    Doctrine\ORM\Mapping\Driver\AnnotationDriver,
+    Doctrine\ORM\Mapping\QuoteStrategy,
+    Doctrine\ORM\Mapping\DefaultQuoteStrategy,
+    Doctrine\ORM\Mapping\NamingStrategy,
+    Doctrine\ORM\Mapping\DefaultNamingStrategy,
+    Doctrine\Common\Annotations\SimpleAnnotationReader,
+    Doctrine\Common\Annotations\CachedReader;
 
 /**
  * Configuration container for all configuration options of Doctrine.
@@ -56,8 +62,9 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function getProxyDir()
     {
-        return isset($this->_attributes['proxyDir']) ?
-                $this->_attributes['proxyDir'] : null;
+        return isset($this->_attributes['proxyDir'])
+            ? $this->_attributes['proxyDir']
+            : null;
     }
 
     /**
@@ -68,8 +75,9 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function getAutoGenerateProxyClasses()
     {
-        return isset($this->_attributes['autoGenerateProxyClasses']) ?
-                $this->_attributes['autoGenerateProxyClasses'] : true;
+        return isset($this->_attributes['autoGenerateProxyClasses'])
+            ? $this->_attributes['autoGenerateProxyClasses']
+            : true;
     }
 
     /**
@@ -90,8 +98,9 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function getProxyNamespace()
     {
-        return isset($this->_attributes['proxyNamespace']) ?
-                $this->_attributes['proxyNamespace'] : null;
+        return isset($this->_attributes['proxyNamespace'])
+            ? $this->_attributes['proxyNamespace']
+            : null;
     }
 
     /**
@@ -107,46 +116,40 @@ class Configuration extends \Doctrine\DBAL\Configuration
     /**
      * Sets the cache driver implementation that is used for metadata caching.
      *
-     * @param Driver $driverImpl
+     * @param MappingDriver $driverImpl
      * @todo Force parameter to be a Closure to ensure lazy evaluation
      *       (as soon as a metadata cache is in effect, the driver never needs to initialize).
      */
-    public function setMetadataDriverImpl(Driver $driverImpl)
+    public function setMetadataDriverImpl(MappingDriver $driverImpl)
     {
         $this->_attributes['metadataDriverImpl'] = $driverImpl;
     }
 
     /**
-     * Add a new default annotation driver with a correctly configured annotation reader.
+     * Add a new default annotation driver with a correctly configured annotation reader. If $useSimpleAnnotationReader
+     * is true, the notation `@Entity` will work, otherwise, the notation `@ORM\Entity` will be supported.
      *
      * @param array $paths
-     * @return Mapping\Driver\AnnotationDriver
+     * @param bool $useSimpleAnnotationReader
+     * @return AnnotationDriver
      */
-    public function newDefaultAnnotationDriver($paths = array())
+    public function newDefaultAnnotationDriver($paths = array(), $useSimpleAnnotationReader = true)
     {
-        if (version_compare(\Doctrine\Common\Version::VERSION, '2.2.0-DEV', '>=')) {
-            // Register the ORM Annotations in the AnnotationRegistry
-            AnnotationRegistry::registerFile(__DIR__ . '/Mapping/Driver/DoctrineAnnotations.php');
+        AnnotationRegistry::registerFile(__DIR__ . '/Mapping/Driver/DoctrineAnnotations.php');
 
-            $reader = new \Doctrine\Common\Annotations\SimpleAnnotationReader();
+        if ($useSimpleAnnotationReader) {
+            // Register the ORM Annotations in the AnnotationRegistry
+            $reader = new SimpleAnnotationReader();
             $reader->addNamespace('Doctrine\ORM\Mapping');
-            $reader = new \Doctrine\Common\Annotations\CachedReader($reader, new ArrayCache());
-        } else if (version_compare(\Doctrine\Common\Version::VERSION, '2.1.0-DEV', '>=')) {
-            // Register the ORM Annotations in the AnnotationRegistry
-            AnnotationRegistry::registerFile(__DIR__ . '/Mapping/Driver/DoctrineAnnotations.php');
+            $cachedReader = new CachedReader($reader, new ArrayCache());
 
-            $reader = new AnnotationReader();
-            $reader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\\');
-            $reader->setIgnoreNotImportedAnnotations(true);
-            $reader->setEnableParsePhpImports(false);
-            $reader = new \Doctrine\Common\Annotations\CachedReader(
-                new \Doctrine\Common\Annotations\IndexedReader($reader), new ArrayCache()
-            );
-        } else {
-            $reader = new AnnotationReader();
-            $reader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\\');
+            return new AnnotationDriver($cachedReader, (array) $paths);
         }
-        return new AnnotationDriver($reader, (array)$paths);
+
+        return new AnnotationDriver(
+            new CachedReader(new AnnotationReader(), new ArrayCache()),
+            (array) $paths
+        );
     }
 
     /**
@@ -164,8 +167,8 @@ class Configuration extends \Doctrine\DBAL\Configuration
      * Resolves a registered namespace alias to the full namespace.
      *
      * @param string $entityNamespaceAlias
+     * @throws ORMException
      * @return string
-     * @throws MappingException
      */
     public function getEntityNamespace($entityNamespaceAlias)
     {
@@ -179,8 +182,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
     /**
      * Set the entity alias map
      *
-     * @param array $entityAliasMap
-     * @return void
+     * @param array $entityNamespaces
      */
     public function setEntityNamespaces(array $entityNamespaces)
     {
@@ -201,12 +203,13 @@ class Configuration extends \Doctrine\DBAL\Configuration
      * Gets the cache driver implementation that is used for the mapping metadata.
      *
      * @throws ORMException
-     * @return Mapping\Driver\Driver
+     * @return MappingDriver
      */
     public function getMetadataDriverImpl()
     {
-        return isset($this->_attributes['metadataDriverImpl']) ?
-                $this->_attributes['metadataDriverImpl'] : null;
+        return isset($this->_attributes['metadataDriverImpl'])
+            ? $this->_attributes['metadataDriverImpl']
+            : null;
     }
 
     /**
@@ -216,8 +219,9 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function getQueryCacheImpl()
     {
-        return isset($this->_attributes['queryCacheImpl']) ?
-                $this->_attributes['queryCacheImpl'] : null;
+        return isset($this->_attributes['queryCacheImpl'])
+            ? $this->_attributes['queryCacheImpl']
+            : null;
     }
 
     /**
@@ -259,8 +263,9 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function getMetadataCacheImpl()
     {
-        return isset($this->_attributes['metadataCacheImpl']) ?
-                $this->_attributes['metadataCacheImpl'] : null;
+        return isset($this->_attributes['metadataCacheImpl'])
+            ? $this->_attributes['metadataCacheImpl']
+            : null;
     }
 
     /**
@@ -288,6 +293,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
      * Gets a previously registered named DQL query.
      *
      * @param string $name The name of the query.
+     * @throws ORMException
      * @return string The DQL query.
      */
     public function getNamedQuery($name)
@@ -295,15 +301,16 @@ class Configuration extends \Doctrine\DBAL\Configuration
         if ( ! isset($this->_attributes['namedQueries'][$name])) {
             throw ORMException::namedQueryNotFound($name);
         }
+
         return $this->_attributes['namedQueries'][$name];
     }
 
     /**
      * Adds a named native query to the configuration.
      *
-     * @param string $name The name of the query.
-     * @param string $sql The native SQL query string.
-     * @param ResultSetMapping $rsm The ResultSetMapping used for the results of the SQL query.
+     * @param string                 $name The name of the query.
+     * @param string                 $sql  The native SQL query string.
+     * @param Query\ResultSetMapping $rsm  The ResultSetMapping used for the results of the SQL query.
      */
     public function addNamedNativeQuery($name, $sql, Query\ResultSetMapping $rsm)
     {
@@ -313,15 +320,17 @@ class Configuration extends \Doctrine\DBAL\Configuration
     /**
      * Gets the components of a previously registered named native query.
      *
-     * @param string $name The name of the query.
-     * @return array A tuple with the first element being the SQL string and the second
-     *          element being the ResultSetMapping.
+     * @param  string $name  The name of the query.
+     * @throws ORMException
+     * @return array         A tuple with the first element being the SQL string and the second
+     *                       element being the ResultSetMapping.
      */
     public function getNamedNativeQuery($name)
     {
         if ( ! isset($this->_attributes['namedNativeQueries'][$name])) {
             throw ORMException::namedNativeQueryNotFound($name);
         }
+
         return $this->_attributes['namedNativeQueries'][$name];
     }
 
@@ -334,12 +343,14 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function ensureProductionSettings()
     {
-        if ( !$this->getQueryCacheImpl()) {
+        if ( ! $this->getQueryCacheImpl()) {
             throw ORMException::queryCacheNotConfigured();
         }
-        if ( !$this->getMetadataCacheImpl()) {
+
+        if ( ! $this->getMetadataCacheImpl()) {
             throw ORMException::metadataCacheNotConfigured();
         }
+
         if ($this->getAutoGenerateProxyClasses()) {
             throw ORMException::proxyClassesAlwaysRegenerating();
         }
@@ -354,9 +365,14 @@ class Configuration extends \Doctrine\DBAL\Configuration
      *
      * @param string $name
      * @param string $className
+     * @throws ORMException
      */
     public function addCustomStringFunction($name, $className)
     {
+        if (Query\Parser::isInternalFunction($name)) {
+            throw ORMException::overwriteInternalDQLFunctionNotAllowed($name);
+        }
+
         $this->_attributes['customStringFunctions'][strtolower($name)] = $className;
     }
 
@@ -369,8 +385,10 @@ class Configuration extends \Doctrine\DBAL\Configuration
     public function getCustomStringFunction($name)
     {
         $name = strtolower($name);
-        return isset($this->_attributes['customStringFunctions'][$name]) ?
-                $this->_attributes['customStringFunctions'][$name] : null;
+
+        return isset($this->_attributes['customStringFunctions'][$name])
+            ? $this->_attributes['customStringFunctions'][$name]
+            : null;
     }
 
     /**
@@ -385,7 +403,9 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function setCustomStringFunctions(array $functions)
     {
-        $this->_attributes['customStringFunctions'] = array_change_key_case($functions);
+        foreach ($functions as $name => $className) {
+            $this->addCustomStringFunction($name, $className);
+        }
     }
 
     /**
@@ -397,9 +417,14 @@ class Configuration extends \Doctrine\DBAL\Configuration
      *
      * @param string $name
      * @param string $className
+     * @throws ORMException
      */
     public function addCustomNumericFunction($name, $className)
     {
+        if (Query\Parser::isInternalFunction($name)) {
+            throw ORMException::overwriteInternalDQLFunctionNotAllowed($name);
+        }
+
         $this->_attributes['customNumericFunctions'][strtolower($name)] = $className;
     }
 
@@ -412,8 +437,10 @@ class Configuration extends \Doctrine\DBAL\Configuration
     public function getCustomNumericFunction($name)
     {
         $name = strtolower($name);
-        return isset($this->_attributes['customNumericFunctions'][$name]) ?
-                $this->_attributes['customNumericFunctions'][$name] : null;
+
+        return isset($this->_attributes['customNumericFunctions'][$name])
+            ? $this->_attributes['customNumericFunctions'][$name]
+            : null;
     }
 
     /**
@@ -428,7 +455,9 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function setCustomNumericFunctions(array $functions)
     {
-        $this->_attributes['customNumericFunctions'] = array_change_key_case($functions);
+        foreach ($functions as $name => $className) {
+            $this->addCustomNumericFunction($name, $className);
+        }
     }
 
     /**
@@ -440,9 +469,14 @@ class Configuration extends \Doctrine\DBAL\Configuration
      *
      * @param string $name
      * @param string $className
+     * @throws ORMException
      */
     public function addCustomDatetimeFunction($name, $className)
     {
+        if (Query\Parser::isInternalFunction($name)) {
+            throw ORMException::overwriteInternalDQLFunctionNotAllowed($name);
+        }
+
         $this->_attributes['customDatetimeFunctions'][strtolower($name)] = $className;
     }
 
@@ -455,8 +489,10 @@ class Configuration extends \Doctrine\DBAL\Configuration
     public function getCustomDatetimeFunction($name)
     {
         $name = strtolower($name);
-        return isset($this->_attributes['customDatetimeFunctions'][$name]) ?
-                $this->_attributes['customDatetimeFunctions'][$name] : null;
+
+        return isset($this->_attributes['customDatetimeFunctions'][$name])
+            ? $this->_attributes['customDatetimeFunctions'][$name]
+            : null;
     }
 
     /**
@@ -471,7 +507,23 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function setCustomDatetimeFunctions(array $functions)
     {
-        $this->_attributes['customDatetimeFunctions'] = array_change_key_case($functions);
+        foreach ($functions as $name => $className) {
+            $this->addCustomDatetimeFunction($name, $className);
+        }
+    }
+
+    /**
+     * Set the custom hydrator modes in one pass.
+     *
+     * @param array An array of ($modeName => $hydrator)
+     */
+    public function setCustomHydrationModes($modes)
+    {
+        $this->_attributes['customHydrationModes'] = array();
+
+        foreach ($modes as $modeName => $hydrator) {
+            $this->addCustomHydrationMode($modeName, $hydrator);
+        }
     }
 
     /**
@@ -482,8 +534,9 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function getCustomHydrationMode($modeName)
     {
-        return isset($this->_attributes['customHydrationModes'][$modeName]) ?
-            $this->_attributes['customHydrationModes'][$modeName] : null;
+        return isset($this->_attributes['customHydrationModes'][$modeName])
+            ? $this->_attributes['customHydrationModes'][$modeName]
+            : null;
     }
 
     /**
@@ -500,7 +553,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
     /**
      * Set a class metadata factory.
      *
-     * @param string $cmf
+     * @param string $cmfName
      */
     public function setClassMetadataFactoryName($cmfName)
     {
@@ -512,9 +565,10 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function getClassMetadataFactoryName()
     {
-        if (!isset($this->_attributes['classMetadataFactoryName'])) {
+        if ( ! isset($this->_attributes['classMetadataFactoryName'])) {
             $this->_attributes['classMetadataFactoryName'] = 'Doctrine\ORM\Mapping\ClassMetadataFactory';
         }
+
         return $this->_attributes['classMetadataFactoryName'];
     }
 
@@ -539,8 +593,9 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function getFilterClassName($name)
     {
-        return isset($this->_attributes['filters'][$name]) ?
-                $this->_attributes['filters'][$name] : null;
+        return isset($this->_attributes['filters'][$name])
+            ? $this->_attributes['filters'][$name]
+            : null;
     }
 
     /**
@@ -548,14 +603,16 @@ class Configuration extends \Doctrine\DBAL\Configuration
      *
      * @since 2.2
      * @param string $className
-     * @throws ORMException If not is a \Doctrine\ORM\EntityRepository
+     * @throws ORMException If not is a \Doctrine\Common\Persistence\ObjectRepository
      */
     public function setDefaultRepositoryClassName($className)
     {
-        if ($className != "Doctrine\ORM\EntityRepository" &&
-           !is_subclass_of($className, 'Doctrine\ORM\EntityRepository')){
+        $reflectionClass = new \ReflectionClass($className);
+
+        if ( ! $reflectionClass->implementsInterface('Doctrine\Common\Persistence\ObjectRepository')) {
             throw ORMException::invalidEntityRepository($className);
         }
+
         $this->_attributes['defaultRepositoryClassName'] = $className;
     }
 
@@ -567,7 +624,60 @@ class Configuration extends \Doctrine\DBAL\Configuration
      */
     public function getDefaultRepositoryClassName()
     {
-        return isset($this->_attributes['defaultRepositoryClassName']) ?
-                $this->_attributes['defaultRepositoryClassName'] : 'Doctrine\ORM\EntityRepository';
+        return isset($this->_attributes['defaultRepositoryClassName'])
+            ? $this->_attributes['defaultRepositoryClassName']
+            : 'Doctrine\ORM\EntityRepository';
+    }
+
+    /**
+     * Set naming strategy.
+     *
+     * @since 2.3
+     * @param NamingStrategy $namingStrategy
+     */
+    public function setNamingStrategy(NamingStrategy $namingStrategy)
+    {
+        $this->_attributes['namingStrategy'] = $namingStrategy;
+    }
+
+    /**
+     * Get naming strategy..
+     *
+     * @since 2.3
+     * @return NamingStrategy
+     */
+    public function getNamingStrategy()
+    {
+        if ( ! isset($this->_attributes['namingStrategy'])) {
+            $this->_attributes['namingStrategy'] = new DefaultNamingStrategy();
+        }
+
+        return $this->_attributes['namingStrategy'];
+    }
+
+    /**
+     * Set quote strategy.
+     *
+     * @since 2.3
+     * @param Doctrine\ORM\Mapping\QuoteStrategy $quoteStrategy
+     */
+    public function setQuoteStrategy(QuoteStrategy $quoteStrategy)
+    {
+        $this->_attributes['quoteStrategy'] = $quoteStrategy;
+    }
+
+    /**
+     * Get quote strategy.
+     *
+     * @since 2.3
+     * @return Doctrine\ORM\Mapping\QuoteStrategy
+     */
+    public function getQuoteStrategy()
+    {
+        if ( ! isset($this->_attributes['quoteStrategy'])) {
+            $this->_attributes['quoteStrategy'] = new DefaultQuoteStrategy();
+        }
+
+        return $this->_attributes['quoteStrategy'];
     }
 }

lib/Doctrine/ORM/EntityManager.php

@@ -13,13 +13,13 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM;
 
-use Closure, Exception,
+use Exception,
     Doctrine\Common\EventManager,
     Doctrine\Common\Persistence\ObjectManager,
     Doctrine\DBAL\Connection,
@@ -128,16 +128,17 @@ class EntityManager implements ObjectManager
      */
     protected function __construct(Connection $conn, Configuration $config, EventManager $eventManager)
     {
-        $this->conn = $conn;
-        $this->config = $config;
+        $this->conn         = $conn;
+        $this->config       = $config;
         $this->eventManager = $eventManager;
 
         $metadataFactoryClassName = $config->getClassMetadataFactoryName();
+
         $this->metadataFactory = new $metadataFactoryClassName;
         $this->metadataFactory->setEntityManager($this);
         $this->metadataFactory->setCacheDriver($this->config->getMetadataCacheImpl());
 
-        $this->unitOfWork = new UnitOfWork($this);
+        $this->unitOfWork   = new UnitOfWork($this);
         $this->proxyFactory = new ProxyFactory(
             $this,
             $config->getProxyDir(),
@@ -191,8 +192,6 @@ class EntityManager implements ObjectManager
 
     /**
      * Starts a transaction on the underlying database connection.
-     *
-     * @deprecated Use {@link getConnection}.beginTransaction().
      */
     public function beginTransaction()
     {
@@ -209,15 +208,19 @@ class EntityManager implements ObjectManager
      * If an exception occurs during execution of the function or flushing or transaction commit,
      * the transaction is rolled back, the EntityManager closed and the exception re-thrown.
      *
-     * @param Closure $func The function to execute transactionally.
+     * @param callable $func The function to execute transactionally.
      * @return mixed Returns the non-empty value returned from the closure or true instead
      */
-    public function transactional(Closure $func)
+    public function transactional($func)
     {
+        if (!is_callable($func)) {
+            throw new \InvalidArgumentException('Expected argument of type "callable", got "' . gettype($func) . '"');
+        }
+
         $this->conn->beginTransaction();
 
         try {
-            $return = $func($this);
+            $return = call_user_func($func, $this);
 
             $this->flush();
             $this->conn->commit();
@@ -233,8 +236,6 @@ class EntityManager implements ObjectManager
 
     /**
      * Commits a transaction on the underlying database connection.
-     *
-     * @deprecated Use {@link getConnection}.commit().
      */
     public function commit()
     {
@@ -243,8 +244,6 @@ class EntityManager implements ObjectManager
 
     /**
      * Performs a rollback on the underlying database connection.
-     *
-     * @deprecated Use {@link getConnection}.rollback().
      */
     public function rollback()
     {
@@ -272,7 +271,7 @@ class EntityManager implements ObjectManager
     /**
      * Creates a new Query object.
      *
-     * @param string  The DQL string.
+     * @param string $dql The DQL string.
      * @return \Doctrine\ORM\Query
      */
     public function createQuery($dql = "")
@@ -307,6 +306,7 @@ class EntityManager implements ObjectManager
     public function createNativeQuery($sql, ResultSetMapping $rsm)
     {
         $query = new NativeQuery($this);
+
         $query->setSql($sql);
         $query->setResultSetMapping($rsm);
 
@@ -354,21 +354,82 @@ class EntityManager implements ObjectManager
 
         $this->unitOfWork->commit($entity);
     }
-
+    
     /**
      * Finds an Entity by its identifier.
      *
-     * This is just a convenient shortcut for getRepository($entityName)->find($id).
-     *
      * @param string $entityName
-     * @param mixed $identifier
-     * @param int $lockMode
-     * @param int $lockVersion
+     * @param mixed $id
+     * @param integer $lockMode
+     * @param integer $lockVersion
+     *
      * @return object
      */
-    public function find($entityName, $identifier, $lockMode = LockMode::NONE, $lockVersion = null)
+    public function find($entityName, $id, $lockMode = LockMode::NONE, $lockVersion = null)
     {
-        return $this->getRepository($entityName)->find($identifier, $lockMode, $lockVersion);
+        $class = $this->metadataFactory->getMetadataFor(ltrim($entityName, '\\'));
+
+        if ( ! is_array($id)) {
+            $id = array($class->identifier[0] => $id);
+        }
+
+        $sortedId = array();
+
+        foreach ($class->identifier as $identifier) {
+            if ( ! isset($id[$identifier])) {
+                throw ORMException::missingIdentifierField($class->name, $identifier);
+            }
+
+            $sortedId[$identifier] = $id[$identifier];
+        }
+
+        $unitOfWork = $this->getUnitOfWork();
+
+        // Check identity map first
+        if (($entity = $unitOfWork->tryGetById($sortedId, $class->rootEntityName)) !== false) {
+            if ( ! ($entity instanceof $class->name)) {
+                return null;
+            }
+
+            switch ($lockMode) {
+                case LockMode::OPTIMISTIC:
+                    $this->lock($entity, $lockMode, $lockVersion);
+                    break;
+
+                case LockMode::PESSIMISTIC_READ:
+                case LockMode::PESSIMISTIC_WRITE:
+                    $persister = $unitOfWork->getEntityPersister($class->name);
+                    $persister->refresh($sortedId, $entity, $lockMode);
+                    break;
+            }
+
+            return $entity; // Hit!
+        }
+
+        $persister = $unitOfWork->getEntityPersister($class->name);
+
+        switch ($lockMode) {
+            case LockMode::NONE:
+                return $persister->load($sortedId);
+
+            case LockMode::OPTIMISTIC:
+                if ( ! $class->isVersioned) {
+                    throw OptimisticLockException::notVersioned($class->name);
+                }
+
+                $entity = $persister->load($sortedId);
+
+                $unitOfWork->lock($entity, $lockMode, $lockVersion);
+
+                return $entity;
+
+            default:
+                if ( ! $this->getConnection()->isTransactionActive()) {
+                    throw TransactionRequiredException::transactionRequired();
+                }
+
+                return $persister->load($sortedId, null, null, array(), $lockMode);
+        }
     }
 
     /**
@@ -382,19 +443,23 @@ class EntityManager implements ObjectManager
     public function getReference($entityName, $id)
     {
         $class = $this->metadataFactory->getMetadataFor(ltrim($entityName, '\\'));
+
         if ( ! is_array($id)) {
             $id = array($class->identifier[0] => $id);
         }
+
         $sortedId = array();
+
         foreach ($class->identifier as $identifier) {
-            if (!isset($id[$identifier])) {
+            if ( ! isset($id[$identifier])) {
                 throw ORMException::missingIdentifierField($class->name, $identifier);
             }
+
             $sortedId[$identifier] = $id[$identifier];
         }
 
         // Check identity map first, if its already in there just return it.
-        if ($entity = $this->unitOfWork->tryGetById($sortedId, $class->rootEntityName)) {
+        if (($entity = $this->unitOfWork->tryGetById($sortedId, $class->rootEntityName)) !== false) {
             return ($entity instanceof $class->name) ? $entity : null;
         }
 
@@ -407,6 +472,7 @@ class EntityManager implements ObjectManager
         }
 
         $entity = $this->proxyFactory->getProxy($class->name, $sortedId);
+
         $this->unitOfWork->registerManaged($entity, $sortedId, array());
 
         return $entity;
@@ -436,7 +502,7 @@ class EntityManager implements ObjectManager
         $class = $this->metadataFactory->getMetadataFor(ltrim($entityName, '\\'));
 
         // Check identity map first, if its already in there just return it.
-        if ($entity = $this->unitOfWork->tryGetById($identifier, $class->rootEntityName)) {
+        if (($entity = $this->unitOfWork->tryGetById($identifier, $class->rootEntityName)) !== false) {
             return ($entity instanceof $class->name) ? $entity : null;
         }
 
@@ -445,7 +511,9 @@ class EntityManager implements ObjectManager
         }
 
         $entity = $class->newInstance();
+
         $class->setIdentifierValues($entity, $identifier);
+
         $this->unitOfWork->registerManaged($entity, $identifier, array());
         $this->unitOfWork->markReadOnly($entity);
 
@@ -471,6 +539,7 @@ class EntityManager implements ObjectManager
     public function close()
     {
         $this->clear();
+
         $this->closed = true;
     }
 
@@ -488,7 +557,7 @@ class EntityManager implements ObjectManager
     public function persist($entity)
     {
         if ( ! is_object($entity)) {
-            throw new \InvalidArgumentException(gettype($entity));
+            throw ORMInvalidArgumentException::invalidObject('EntityManager#persist()' , $entity);
         }
 
         $this->errorIfClosed();
@@ -507,7 +576,7 @@ class EntityManager implements ObjectManager
     public function remove($entity)
     {
         if ( ! is_object($entity)) {
-            throw new \InvalidArgumentException(gettype($entity));
+            throw ORMInvalidArgumentException::invalidObject('EntityManager#remove()' , $entity);
         }
 
         $this->errorIfClosed();
@@ -524,7 +593,7 @@ class EntityManager implements ObjectManager
     public function refresh($entity)
     {
         if ( ! is_object($entity)) {
-            throw new \InvalidArgumentException(gettype($entity));
+            throw ORMInvalidArgumentException::invalidObject('EntityManager#refresh()' , $entity);
         }
 
         $this->errorIfClosed();
@@ -544,7 +613,7 @@ class EntityManager implements ObjectManager
     public function detach($entity)
     {
         if ( ! is_object($entity)) {
-            throw new \InvalidArgumentException(gettype($entity));
+            throw ORMInvalidArgumentException::invalidObject('EntityManager#detach()' , $entity);
         }
 
         $this->unitOfWork->detach($entity);
@@ -561,7 +630,7 @@ class EntityManager implements ObjectManager
     public function merge($entity)
     {
         if ( ! is_object($entity)) {
-            throw new \InvalidArgumentException(gettype($entity));
+            throw ORMInvalidArgumentException::invalidObject('EntityManager#merge()' , $entity);
         }
 
         $this->errorIfClosed();
@@ -732,7 +801,7 @@ class EntityManager implements ObjectManager
                 return new Internal\Hydration\SimpleObjectHydrator($this);
 
             default:
-                if ($class = $this->config->getCustomHydrationMode($hydrationMode)) {
+                if (($class = $this->config->getCustomHydrationMode($hydrationMode)) !== null) {
                     return new $class($this);
                 }
         }
@@ -818,8 +887,7 @@ class EntityManager implements ObjectManager
      */
     public function isFiltersStateClean()
     {
-        return null === $this->filterCollection
-           || $this->filterCollection->isClean();
+        return null === $this->filterCollection || $this->filterCollection->isClean();
     }
 
     /**

lib/Doctrine/ORM/EntityNotFoundException.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -31,4 +31,4 @@ class EntityNotFoundException extends ORMException
     {
         parent::__construct('Entity was not found.');
     }
-}
+}

lib/Doctrine/ORM/EntityRepository.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -22,6 +22,11 @@ namespace Doctrine\ORM;
 use Doctrine\DBAL\LockMode;
 use Doctrine\Common\Persistence\ObjectRepository;
 
+use Doctrine\Common\Collections\Selectable;
+use Doctrine\Common\Collections\Criteria;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\ExpressionBuilder;
+
 /**
  * An EntityRepository serves as a repository for entities with generic as well as
  * business specific methods for retrieving entities.
@@ -35,7 +40,7 @@ use Doctrine\Common\Persistence\ObjectRepository;
  * @author  Jonathan Wage <jonwage@gmail.com>
  * @author  Roman Borschel <roman@code-factory.org>
  */
-class EntityRepository implements ObjectRepository
+class EntityRepository implements ObjectRepository, Selectable
 {
     /**
      * @var string
@@ -61,8 +66,8 @@ class EntityRepository implements ObjectRepository
     public function __construct($em, Mapping\ClassMetadata $class)
     {
         $this->_entityName = $class->name;
-        $this->_em = $em;
-        $this->_class = $class;
+        $this->_em         = $em;
+        $this->_class      = $class;
     }
 
     /**
@@ -89,6 +94,21 @@ class EntityRepository implements ObjectRepository
         return $this->_em->createQuery($this->_class->getNamedQuery($queryName));
     }
 
+    /**
+     * Creates a native SQL query.
+     *
+     * @param string $queryName
+     * @return NativeQuery
+     */
+    public function createNativeNamedQuery($queryName)
+    {
+        $queryMapping   = $this->_class->getNamedNativeQuery($queryName);
+        $rsm            = new Query\ResultSetMappingBuilder($this->_em);
+        $rsm->addNamedNativeQueryMapping($this->_class, $queryMapping);
+
+        return $this->_em->createNativeQuery($queryMapping['query'], $rsm);
+    }
+
     /**
      * Clears the repository, causing all managed entities to become detached.
      */
@@ -100,66 +120,15 @@ class EntityRepository implements ObjectRepository
     /**
      * Finds an entity by its primary key / identifier.
      *
-     * @param $id The identifier.
-     * @param int $lockMode
-     * @param int $lockVersion
+     * @param mixed $id The identifier.
+     * @param integer $lockMode
+     * @param integer $lockVersion
+     *
      * @return object The entity.
      */
     public function find($id, $lockMode = LockMode::NONE, $lockVersion = null)
     {
-        if ( ! is_array($id)) {
-            $id = array($this->_class->identifier[0] => $id);
-        }
-        $sortedId = array();
-        foreach ($this->_class->identifier as $identifier) {
-            if (!isset($id[$identifier])) {
-                throw ORMException::missingIdentifierField($this->_class->name, $identifier);
-            }
-            $sortedId[$identifier] = $id[$identifier];
-        }
-
-        // Check identity map first
-        if ($entity = $this->_em->getUnitOfWork()->tryGetById($sortedId, $this->_class->rootEntityName)) {
-            if ( ! ($entity instanceof $this->_class->name)) {
-                return null;
-            }
-
-            switch ($lockMode) {
-                case LockMode::OPTIMISTIC:
-                    $this->_em->lock($entity, $lockMode, $lockVersion);
-                    break;
-                case LockMode::PESSIMISTIC_READ:
-                case LockMode::PESSIMISTIC_WRITE:
-                    $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
-                    $persister->refresh($sortedId, $entity, $lockMode);
-                    break;
-            }
-
-            return $entity; // Hit!
-        }
-
-        switch ($lockMode) {
-            case LockMode::NONE:
-                return $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName)->load($sortedId);
-
-            case LockMode::OPTIMISTIC:
-                if ( ! $this->_class->isVersioned) {
-                    throw OptimisticLockException::notVersioned($this->_entityName);
-                }
-
-                $entity = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName)->load($sortedId);
-
-                $this->_em->getUnitOfWork()->lock($entity, $lockMode, $lockVersion);
-
-                return $entity;
-
-            default:
-                if ( ! $this->_em->getConnection()->isTransactionActive()) {
-                    throw TransactionRequiredException::transactionRequired();
-                }
-
-                return $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName)->load($sortedId, null, null, array(), $lockMode);
-        }
+        return $this->_em->find($this->_entityName, $id, $lockMode, $lockVersion);
     }
 
     /**
@@ -183,18 +152,23 @@ class EntityRepository implements ObjectRepository
      */
     public function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
     {
-        return $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName)->loadAll($criteria, $orderBy, $limit, $offset);
+        $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
+
+        return $persister->loadAll($criteria, $orderBy, $limit, $offset);
     }
 
     /**
      * Finds a single entity by a set of criteria.
      *
      * @param array $criteria
+     * @param array|null $orderBy
      * @return object
      */
-    public function findOneBy(array $criteria)
+    public function findOneBy(array $criteria, array $orderBy = null)
     {
-        return $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName)->load($criteria, null, null, array(), 0, 1);
+        $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
+
+        return $persister->load($criteria, null, null, array(), 0, 1, $orderBy);
     }
 
     /**
@@ -208,13 +182,13 @@ class EntityRepository implements ObjectRepository
     public function __call($method, $arguments)
     {
         switch (true) {
-            case (substr($method, 0, 6) == 'findBy'):
-                $by = substr($method, 6, strlen($method));
+            case (0 === strpos($method, 'findBy')):
+                $by = substr($method, 6);
                 $method = 'findBy';
                 break;
 
-            case (substr($method, 0, 9) == 'findOneBy'):
-                $by = substr($method, 9, strlen($method));
+            case (0 === strpos($method, 'findOneBy')):
+                $by = substr($method, 9);
                 $method = 'findOneBy';
                 break;
 
@@ -232,7 +206,22 @@ class EntityRepository implements ObjectRepository
         $fieldName = lcfirst(\Doctrine\Common\Util\Inflector::classify($by));
 
         if ($this->_class->hasField($fieldName) || $this->_class->hasAssociation($fieldName)) {
-            return $this->$method(array($fieldName => $arguments[0]));
+            switch (count($arguments)) {
+                case 1:
+                    return $this->$method(array($fieldName => $arguments[0]));
+
+                case 2:
+                    return $this->$method(array($fieldName => $arguments[0]), $arguments[1]);
+
+                case 3:
+                    return $this->$method(array($fieldName => $arguments[0]), $arguments[1], $arguments[2]);
+
+                case 4:
+                    return $this->$method(array($fieldName => $arguments[0]), $arguments[1], $arguments[2], $arguments[3]);
+
+                default:
+                    // Do nothing
+            }
         }
 
         throw ORMException::invalidFindByCall($this->_entityName, $fieldName, $method.$by);
@@ -269,4 +258,20 @@ class EntityRepository implements ObjectRepository
     {
         return $this->_class;
     }
+
+    /**
+     * Select all elements from a selectable that match the expression and
+     * return a new collection containing these elements.
+     *
+     * @param \Doctrine\Common\Collections\Criteria $criteria
+     *
+     * @return \Doctrine\Common\Collections\Collection
+     */
+    public function matching(Criteria $criteria)
+    {
+        $persister = $this->_em->getUnitOfWork()->getEntityPersister($this->_entityName);
+
+        return new ArrayCollection($persister->loadCriteria($criteria));
+    }
 }
+

lib/Doctrine/ORM/Event/LifecycleEventArgs.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
 */
 
@@ -56,7 +56,7 @@ class LifecycleEventArgs extends EventArgs
     }
 
     /**
-     * Retireve associated Entity.
+     * Retrieve associated Entity.
      *
      * @return object
      */
@@ -74,4 +74,4 @@ class LifecycleEventArgs extends EventArgs
     {
         return $this->em;
     }
-}
+}

lib/Doctrine/ORM/Event/LoadClassMetadataEventArgs.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Event/OnClearEventArgs.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -81,4 +81,4 @@ class OnClearEventArgs extends \Doctrine\Common\EventArgs
     {
         return ($this->entityClass === null);
     }
-}
+}

lib/Doctrine/ORM/Event/OnFlushEventArgs.php

@@ -1,7 +1,5 @@
 <?php
 /*
- *  $Id$
- *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -15,9 +13,9 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
-*/
+ */
 
 namespace Doctrine\ORM\Event;
 
@@ -83,4 +81,4 @@ class OnFlushEventArgs extends \Doctrine\Common\EventArgs
         return $this->_entitiesToPersist;
     }
     */
-}
+}

lib/Doctrine/ORM/Event/PostFlushEventArgs.php

@@ -1,7 +1,5 @@
 <?php
 /*
- *  $Id$
- *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -15,10 +13,9 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
-
 namespace Doctrine\ORM\Event;
 
 use Doctrine\ORM\EntityManager;
@@ -58,4 +55,4 @@ class PostFlushEventArgs extends EventArgs
     {
         return $this->em;
     }
-}
+}

lib/Doctrine/ORM/Event/PreFlushEventArgs.php

@@ -1,7 +1,5 @@
 <?php
 /*
- *  $Id$
- *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -15,9 +13,9 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
-*/
+ */
 
 namespace Doctrine\ORM\Event;
 
@@ -27,7 +25,6 @@ namespace Doctrine\ORM\Event;
  * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
  * @link        www.doctrine-project.com
  * @since       2.0
- * @version     $Revision$
  * @author      Roman Borschel <roman@code-factory.de>
  * @author      Benjamin Eberlei <kontakt@beberlei.de>
  */

lib/Doctrine/ORM/Event/PreUpdateEventArgs.php

@@ -1,7 +1,5 @@
 <?php
 /*
- *  $Id$
- *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -15,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -81,7 +79,7 @@ class PreUpdateEventArgs extends LifecycleEventArgs
      */
     public function getOldValue($field)
     {
-    	$this->assertValidField($field);
+        $this->assertValidField($field);
 
         return $this->entityChangeSet[$field][0];
     }
@@ -119,7 +117,7 @@ class PreUpdateEventArgs extends LifecycleEventArgs
      */
     private function assertValidField($field)
     {
-    	if ( ! isset($this->entityChangeSet[$field])) {
+        if ( ! isset($this->entityChangeSet[$field])) {
             throw new \InvalidArgumentException(sprintf(
                 'Field "%s" is not a valid field of the entity "%s" in PreUpdateEventArgs.',
                 $field,

lib/Doctrine/ORM/Events.php

@@ -1,7 +1,5 @@
 <?php
 /*
- *  $Id$
- *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -15,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -145,4 +143,4 @@ final class Events
      * @var string
      */
     const onClear = 'onClear';
-}
+}

lib/Doctrine/ORM/Id/AbstractIdGenerator.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -45,4 +45,4 @@ abstract class AbstractIdGenerator
     {
         return false;
     }
-}
+}

lib/Doctrine/ORM/Id/AssignedGenerator.php

@@ -13,14 +13,13 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Id;
 
 use Doctrine\ORM\EntityManager;
-use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\ORMException;
 
 /**

lib/Doctrine/ORM/Id/BigIntegerIdentityGenerator.php

@@ -0,0 +1,66 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Id;
+
+use Doctrine\ORM\EntityManager;
+
+/**
+ * Id generator that obtains IDs from special "identity" columns. These are columns
+ * that automatically get a database-generated, auto-incremented identifier on INSERT.
+ * This generator obtains the last insert id after such an insert.
+ */
+class BigIntegerIdentityGenerator extends AbstractIdGenerator
+{
+    /**
+     * The name of the sequence to pass to lastInsertId(), if any.
+     *
+     * @var string
+     */
+    private $sequenceName;
+
+    /**
+     * Constructor.
+     *
+     * @param string|null $seqName The name of the sequence to pass to lastInsertId()
+     *                             to obtain the last generated identifier within the current
+     *                             database session/connection, if any.
+     */
+    public function __construct($sequenceName = null)
+    {
+        $this->sequenceName = $sequenceName;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function generate(EntityManager $em, $entity)
+    {
+        return (string)$em->getConnection()->lastInsertId($this->sequenceName);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isPostInsertGenerator()
+    {
+        return true;
+    }
+}
+

lib/Doctrine/ORM/Id/IdentityGenerator.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -28,17 +28,21 @@ use Doctrine\ORM\EntityManager;
  */
 class IdentityGenerator extends AbstractIdGenerator
 {
-    /** @var string The name of the sequence to pass to lastInsertId(), if any. */
-    private $_seqName;
+    /**
+     * The name of the sequence to pass to lastInsertId(), if any.
+     *
+     * @var string
+     */
+    private $sequenceName;
 
     /**
      * @param string $seqName The name of the sequence to pass to lastInsertId()
      *                        to obtain the last generated identifier within the current
      *                        database session/connection, if any.
      */
-    public function __construct($seqName = null)
+    public function __construct($sequenceName = null)
     {
-        $this->_seqName = $seqName;
+        $this->sequenceName = $sequenceName;
     }
 
     /**
@@ -46,7 +50,7 @@ class IdentityGenerator extends AbstractIdGenerator
      */
     public function generate(EntityManager $em, $entity)
     {
-        return (int)$em->getConnection()->lastInsertId($this->_seqName);
+        return (int)$em->getConnection()->lastInsertId($this->sequenceName);
     }
 
     /**
@@ -56,4 +60,4 @@ class IdentityGenerator extends AbstractIdGenerator
     {
         return true;
     }
-}
+}

lib/Doctrine/ORM/Id/SequenceGenerator.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Id/TableGenerator.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -78,4 +78,4 @@ class TableGenerator extends AbstractIdGenerator
 
         return $this->_nextValue++;
     }
-}
+}

lib/Doctrine/ORM/Id/UuidGenerator.php

@@ -0,0 +1,48 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Id;
+
+use Serializable, Doctrine\ORM\EntityManager;
+
+/**
+ * Represents an ID generator that uses the database UUID expression
+ *
+ * @since 2.3
+ * @author Maarten de Keizer <m.de.keizer@markei.nl>
+ */
+class UuidGenerator extends AbstractIdGenerator
+{
+    
+    /**
+     * Generates an ID for the given entity.
+     *
+     * @param Doctrine\ORM\EntityManager $em The EntityManager to user
+     * @param object $entity
+     * @return string The generated value.
+     * @override
+     */
+    public function generate(EntityManager $em, $entity)
+    {
+        $conn = $em->getConnection();
+        $sql = 'SELECT ' . $conn->getDatabasePlatform()->getGuidExpression();
+        return $conn->query($sql)->fetchColumn(0);
+    }
+    
+}

lib/Doctrine/ORM/Internal/CommitOrderCalculator.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -115,4 +115,4 @@ class CommitOrderCalculator
     {
         $this->_classes[$class->name] = $class;
     }
-}
+}

lib/Doctrine/ORM/Internal/Hydration/AbstractHydrator.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -37,22 +37,22 @@ use PDO,
  */
 abstract class AbstractHydrator
 {
-    /** @var ResultSetMapping The ResultSetMapping. */
+    /** @var \Doctrine\ORM\Query\ResultSetMapping The ResultSetMapping. */
     protected $_rsm;
 
     /** @var EntityManager The EntityManager instance. */
     protected $_em;
 
-    /** @var AbstractPlatform The dbms Platform instance */
+    /** @var \Doctrine\DBAL\Platforms\AbstractPlatform The dbms Platform instance */
     protected $_platform;
 
-    /** @var UnitOfWork The UnitOfWork of the associated EntityManager. */
+    /** @var \Doctrine\ORM\UnitOfWork The UnitOfWork of the associated EntityManager. */
     protected $_uow;
 
     /** @var array The cache used during row-by-row hydration. */
     protected $_cache = array();
 
-    /** @var Statement The statement that provides the data to hydrate. */
+    /** @var \Doctrine\DBAL\Driver\Statement The statement that provides the data to hydrate. */
     protected $_stmt;
 
     /** @var array The query hints. */
@@ -97,6 +97,7 @@ abstract class AbstractHydrator
      *
      * @param object $stmt
      * @param object $resultSetMapping
+     * @param array $hints
      * @return mixed
      */
     public function hydrateAll($stmt, $resultSetMapping, array $hints = array())

lib/Doctrine/ORM/Internal/Hydration/ArrayHydrator.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -111,13 +111,14 @@ class ArrayHydrator extends AbstractHydrator
                 // Get a reference to the right element in the result tree.
                 // This element will get the associated element attached.
                 if ($this->_rsm->isMixed && isset($this->_rootAliases[$parent])) {
-                	$first = reset($this->_resultPointers);
+                    $first = reset($this->_resultPointers);
                     // TODO: Exception if $key === null ?
                     $baseElement =& $this->_resultPointers[$parent][key($first)];
                 } else if (isset($this->_resultPointers[$parent])) {
                     $baseElement =& $this->_resultPointers[$parent];
                 } else {
                     unset($this->_resultPointers[$dqlAlias]); // Ticket #1228
+
                     continue;
                 }
 
@@ -139,6 +140,7 @@ class ArrayHydrator extends AbstractHydrator
 
                         if ( ! $indexExists || ! $indexIsValid) {
                             $element = $data;
+
                             if (isset($this->_rsm->indexByMap[$dqlAlias])) {
                                 $baseElement[$relationAlias][$row[$this->_rsm->indexByMap[$dqlAlias]]] = $element;
                             } else {
@@ -155,7 +157,10 @@ class ArrayHydrator extends AbstractHydrator
                 } else {
                     $oneToOne = true;
 
-                    if ( ! isset($nonemptyComponents[$dqlAlias]) && ! isset($baseElement[$relationAlias])) {
+                    if (
+                        ( ! isset($nonemptyComponents[$dqlAlias])) &&
+                        ( ! isset($baseElement[$relationAlias]))
+                    ) {
                         $baseElement[$relationAlias] = null;
                     } else if ( ! isset($baseElement[$relationAlias])) {
                         $baseElement[$relationAlias] = $data;
@@ -164,10 +169,9 @@ class ArrayHydrator extends AbstractHydrator
 
                 $coll =& $baseElement[$relationAlias];
 
-                if ($coll !== null) {
+                if (is_array($coll)) {
                     $this->updateResultPointer($coll, $index, $dqlAlias, $oneToOne);
                 }
-
             } else {
                 // It's a root result element
 
@@ -176,22 +180,21 @@ class ArrayHydrator extends AbstractHydrator
 
                 // if this row has a NULL value for the root result id then make it a null result.
                 if ( ! isset($nonemptyComponents[$dqlAlias]) ) {
-                    if ($this->_rsm->isMixed) {
-                        $result[] = array($entityKey => null);
-                    } else {
-                        $result[] = null;
-                    }
+                    $result[] = $this->_rsm->isMixed
+                        ? array($entityKey => null)
+                        : null;
+
                     $resultKey = $this->_resultCounter;
                     ++$this->_resultCounter;
+
                     continue;
                 }
 
                 // Check for an existing element
                 if ($this->_isSimpleQuery || ! isset($this->_identifierMap[$dqlAlias][$id[$dqlAlias]])) {
-                    $element = $rowData[$dqlAlias];
-                    if ($this->_rsm->isMixed) {
-                        $element = array($entityKey => $element);
-                    }
+                    $element = $this->_rsm->isMixed
+                        ? array($entityKey => $rowData[$dqlAlias])
+                        : $rowData[$dqlAlias];
 
                     if (isset($this->_rsm->indexByMap[$dqlAlias])) {
                         $resultKey = $row[$this->_rsm->indexByMap[$dqlAlias]];
@@ -199,6 +202,7 @@ class ArrayHydrator extends AbstractHydrator
                     } else {
                         $resultKey = $this->_resultCounter;
                         $result[] = $element;
+
                         ++$this->_resultCounter;
                     }
 
@@ -206,11 +210,13 @@ class ArrayHydrator extends AbstractHydrator
                 } else {
                     $index = $this->_identifierMap[$dqlAlias][$id[$dqlAlias]];
                     $resultKey = $index;
+
                     /*if ($this->_rsm->isMixed) {
                         $result[] =& $result[$index];
                         ++$this->_resultCounter;
                     }*/
                 }
+
                 $this->updateResultPointer($result, $index, $dqlAlias, false);
             }
         }
@@ -219,11 +225,9 @@ class ArrayHydrator extends AbstractHydrator
         if (isset($scalars)) {
             if ( ! isset($resultKey) ) {
                 // this only ever happens when no object is fetched (scalar result only)
-                if (isset($this->_rsm->indexByMap['scalars'])) {
-                    $resultKey = $row[$this->_rsm->indexByMap['scalars']];
-                } else {
-                    $resultKey = $this->_resultCounter - 1;
-                }
+                $resultKey = isset($this->_rsm->indexByMap['scalars'])
+                    ? $row[$this->_rsm->indexByMap['scalars']]
+                    : $this->_resultCounter - 1;
             }
 
             foreach ($scalars as $name => $value) {
@@ -249,6 +253,12 @@ class ArrayHydrator extends AbstractHydrator
             return;
         }
 
+        if ($oneToOne) {
+            $this->_resultPointers[$dqlAlias] =& $coll;
+
+            return;
+        }
+
         if ($index !== false) {
             $this->_resultPointers[$dqlAlias] =& $coll[$index];
 
@@ -259,12 +269,6 @@ class ArrayHydrator extends AbstractHydrator
             return;
         }
 
-        if ($oneToOne) {
-            $this->_resultPointers[$dqlAlias] =& $coll;
-
-            return;
-        }
-
         end($coll);
         $this->_resultPointers[$dqlAlias] =& $coll[key($coll)];
 

lib/Doctrine/ORM/Internal/Hydration/HydrationException.php

@@ -23,4 +23,34 @@ class HydrationException extends \Doctrine\ORM\ORMException
             "discriminator value in a table row."
         );
     }
+
+    /**
+     * @since 2.3
+     * @param   string $entityName
+     * @param   string $discrColumnName
+     * @param   string $dqlAlias
+     * @return  HydrationException
+     */
+    public static function missingDiscriminatorColumn($entityName, $discrColumnName, $dqlAlias)
+    {
+        return new self(sprintf(
+            'The discriminator column "%s" is missing for "%s" using the DQL alias "%s".',
+            $discrColumnName, $entityName, $dqlAlias
+        ));
+    }
+
+    /**
+     * @since 2.3
+     * @param   string $entityName
+     * @param   string $discrColumnName
+     * @param   string $dqlAlias
+     * @return  HydrationException
+     */
+    public static function missingDiscriminatorMetaMappingColumn($entityName, $discrColumnName, $dqlAlias)
+    {
+        return new self(sprintf(
+            'The meta mapping for the discriminator column "%s" is missing for "%s" using the DQL alias "%s".',
+            $discrColumnName, $entityName, $dqlAlias
+        ));
+    }
 }

lib/Doctrine/ORM/Internal/Hydration/IterableResult.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -101,4 +101,4 @@ class IterableResult implements \Iterator
     {
         return ($this->_current!=false);
     }
-}
+}

lib/Doctrine/ORM/Internal/Hydration/ObjectHydrator.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -27,6 +27,7 @@ use PDO,
     Doctrine\ORM\Events,
     Doctrine\Common\Collections\ArrayCollection,
     Doctrine\Common\Collections\Collection,
+    Doctrine\ORM\UnitOfWork,
     Doctrine\ORM\Proxy\Proxy;
 
 /**
@@ -65,8 +66,8 @@ class ObjectHydrator extends AbstractHydrator
 
         $this->_resultCounter = 0;
 
-        if ( ! isset($this->_hints['deferEagerLoad'])) {
-            $this->_hints['deferEagerLoad'] = true;
+        if ( ! isset($this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD])) {
+            $this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD] = true;
         }
 
         foreach ($this->_rsm->aliasMap as $dqlAlias => $className) {
@@ -123,7 +124,7 @@ class ObjectHydrator extends AbstractHydrator
      */
     protected function cleanup()
     {
-        $eagerLoad = (isset($this->_hints['deferEagerLoad'])) && $this->_hints['deferEagerLoad'] == true;
+        $eagerLoad = (isset($this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD])) && $this->_hints[UnitOfWork::HINT_DEFEREAGERLOAD] == true;
 
         parent::cleanup();
 
@@ -160,10 +161,10 @@ class ObjectHydrator extends AbstractHydrator
     /**
      * Initializes a related collection.
      *
-     * @param object $entity The entity to which the collection belongs.
+     * @param object        $entity         The entity to which the collection belongs.
      * @param ClassMetadata $class
-     * @param string $name The name of the field on the entity that holds the collection.
-     * @param string $parentDqlAlias Alias of the parent fetch joining this collection.
+     * @param string        $fieldName      The name of the field on the entity that holds the collection.
+     * @param string        $parentDqlAlias Alias of the parent fetch joining this collection.
      */
     private function _initRelatedCollection($entity, $class, $fieldName, $parentDqlAlias)
     {
@@ -207,8 +208,8 @@ class ObjectHydrator extends AbstractHydrator
     /**
      * Gets an entity instance.
      *
-     * @param $data The instance data.
-     * @param $dqlAlias The DQL alias of the entity's class.
+     * @param array  $data     The instance data.
+     * @param string $dqlAlias The DQL alias of the entity's class.
      * @return object The entity.
      */
     private function _getEntity(array $data, $dqlAlias)
@@ -216,8 +217,17 @@ class ObjectHydrator extends AbstractHydrator
         $className = $this->_rsm->aliasMap[$dqlAlias];
 
         if (isset($this->_rsm->discriminatorColumns[$dqlAlias])) {
+
+            if ( ! isset($this->_rsm->metaMappings[$this->_rsm->discriminatorColumns[$dqlAlias]])) {
+                throw HydrationException::missingDiscriminatorMetaMappingColumn($className, $this->_rsm->discriminatorColumns[$dqlAlias], $dqlAlias);
+            }
+
             $discrColumn = $this->_rsm->metaMappings[$this->_rsm->discriminatorColumns[$dqlAlias]];
 
+            if ( ! isset($data[$discrColumn])) {
+                throw HydrationException::missingDiscriminatorColumn($className, $discrColumn, $dqlAlias);
+            }
+
             if ($data[$discrColumn] === "") {
                 throw HydrationException::emptyDiscriminatorValue($dqlAlias);
             }
@@ -236,6 +246,11 @@ class ObjectHydrator extends AbstractHydrator
         return $this->_uow->createEntity($className, $data, $this->_hints);
     }
 
+    /**
+     * @param string $className
+     * @param array  $data
+     * @return mixed
+     */
     private function _getEntityFromIdentityMap($className, array $data)
     {
         // TODO: Abstract this code and UnitOfWork::createEntity() equivalent?
@@ -293,8 +308,8 @@ class ObjectHydrator extends AbstractHydrator
      *         level of the hydrated result. A typical example are the objects of the type
      *         specified by the FROM clause in a DQL query.
      *
-     * @param array $data The data of the row to process.
-     * @param array $cache The cache to use.
+     * @param array $row    The data of the row to process.
+     * @param array $cache  The cache to use.
      * @param array $result The result array to fill.
      */
     protected function hydrateRowData(array $row, array &$cache, array &$result)
@@ -329,7 +344,7 @@ class ObjectHydrator extends AbstractHydrator
                 $path = $parentAlias . '.' . $dqlAlias;
 
                 // We have a RIGHT JOIN result here. Doctrine cannot hydrate RIGHT JOIN Object-Graphs
-                if (!isset($nonemptyComponents[$parentAlias])) {
+                if ( ! isset($nonemptyComponents[$parentAlias])) {
                     // TODO: Add special case code where we hydrate the right join objects into identity map at least
                     continue;
                 }
@@ -434,6 +449,7 @@ class ObjectHydrator extends AbstractHydrator
                             $this->_resultPointers[$dqlAlias] = $element;
                         } else {
                             $this->_uow->setOriginalEntityProperty($oid, $relationField, null);
+                            $reflField->setValue($parentObject, null);
                         }
                         // else leave $reflFieldValue null for single-valued associations
                     } else {

lib/Doctrine/ORM/Internal/Hydration/ScalarHydrator.php

@@ -13,14 +13,12 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Internal\Hydration;
 
-use Doctrine\DBAL\Connection;
-
 /**
  * Hydrator that produces flat, rectangular results of scalar data.
  * The created result is almost the same as a regular SQL result set, except
@@ -54,4 +52,4 @@ class ScalarHydrator extends AbstractHydrator
     {
         $result[] = $this->gatherScalarRowData($data, $cache);
     }
-}
+}

lib/Doctrine/ORM/Internal/Hydration/SimpleObjectHydrator.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -75,7 +75,7 @@ class SimpleObjectHydrator extends AbstractHydrator
             return;
         }
 
-        foreach ($this->_rsm->declaringClasses AS $column => $class) {
+        foreach ($this->_rsm->declaringClasses as $column => $class) {
             $this->declaringClasses[$column] = $this->_em->getClassMetadata($class);
         }
     }
@@ -92,6 +92,10 @@ class SimpleObjectHydrator extends AbstractHydrator
         if ($this->class->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
             $discrColumnName = $this->_platform->getSQLResultCasing($this->class->discriminatorColumn['name']);
 
+            if ( ! isset($sqlResult[$discrColumnName])) {
+                throw HydrationException::missingDiscriminatorColumn($entityName, $discrColumnName, key($this->_rsm->aliasMap));
+            }
+
             if ($sqlResult[$discrColumnName] === '') {
                 throw HydrationException::emptyDiscriminatorValue(key($this->_rsm->aliasMap));
             }
@@ -174,10 +178,13 @@ class SimpleObjectHydrator extends AbstractHydrator
                 // One solution is to load the association, but it might require extra efforts.
                 return array('name' => $column);
 
-            default:
+            case (isset($this->_rsm->metaMappings[$column])):
                 return array(
                     'name' => $this->_rsm->metaMappings[$column]
                 );
+
+            default:
+                return null;
         }
     }
 }

lib/Doctrine/ORM/Internal/Hydration/SingleScalarHydrator.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -53,4 +53,4 @@ class SingleScalarHydrator extends AbstractHydrator
 
         return array_shift($result);
     }
-}
+}

lib/Doctrine/ORM/Mapping/Annotation.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/AssociationOverride.php

@@ -0,0 +1,56 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * This annotation is used to override association mapping of property for an entity relationship.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("ANNOTATION")
+ */
+final class AssociationOverride implements Annotation
+{
+
+    /**
+     * The name of the relationship property whose mapping is being overridden
+     * 
+     * @var string 
+     */
+    public $name;
+
+    /**
+     * The join column that is being mapped to the persistent attribute.
+     *
+     * @var array<\Doctrine\ORM\Mapping\JoinColumn>
+     */
+    public $joinColumns;
+
+
+    /**
+     * The join table that maps the relationship.
+     *
+     * @var \Doctrine\ORM\Mapping\JoinTable
+     */
+    public $joinTable;
+
+}

lib/Doctrine/ORM/Mapping/AssociationOverrides.php

@@ -0,0 +1,41 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * This annotation is used to override association mappings of relationship properties.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("CLASS")
+ */
+final class AssociationOverrides implements Annotation
+{
+
+    /**
+     * Mapping overrides of relationship properties
+     *
+     * @var array<\Doctrine\ORM\Mapping\AssociationOverride> 
+     */
+    public $value;
+
+}

lib/Doctrine/ORM/Mapping/AttributeOverride.php

@@ -0,0 +1,47 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * This annotation is used to override the mapping of a entity property.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("ANNOTATION")
+ */
+final class AttributeOverride implements Annotation
+{
+
+    /**
+     * The name of the property whose mapping is being overridden.
+     * 
+     * @var string 
+     */
+    public $name;
+
+    /**
+     * The column definition.
+     *
+     * @var \Doctrine\ORM\Mapping\Column
+     */
+    public $column;
+}

lib/Doctrine/ORM/Mapping/AttributeOverrides.php

@@ -0,0 +1,41 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * This annotation is used to override the mapping of a entity property.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("CLASS")
+ */
+final class AttributeOverrides implements Annotation
+{
+
+    /**
+     * One or more field or property mapping overrides.
+     *
+     * @var array<\Doctrine\ORM\Mapping\AttributeOverride>
+     */
+    public $value;
+
+}

lib/Doctrine/ORM/Mapping/Builder/AssociationBuilder.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -164,4 +164,4 @@ class AssociationBuilder
         }
         return $this->builder;
     }
-}
+}

lib/Doctrine/ORM/Mapping/Builder/ClassMetadataBuilder.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/Builder/FieldBuilder.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -220,4 +220,4 @@ class FieldBuilder
         }
         return $this->builder;
     }
-}
+}

lib/Doctrine/ORM/Mapping/Builder/ManyToManyAssociationBuilder.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -83,4 +83,4 @@ class ManyToManyAssociationBuilder extends OneToManyAssociationBuilder
         $cm->mapManyToMany($mapping);
         return $this->builder;
     }
-}
+}

lib/Doctrine/ORM/Mapping/Builder/OneToManyAssociationBuilder.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -59,4 +59,4 @@ class OneToManyAssociationBuilder extends AssociationBuilder
         $cm->mapOneToMany($mapping);
         return $this->builder;
     }
-}
+}

lib/Doctrine/ORM/Mapping/ChangeTrackingPolicy.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/ClassMetadata.php

@@ -13,31 +13,16 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Mapping;
 
-use ReflectionClass, ReflectionProperty;
-
 /**
- * A <tt>ClassMetadata</tt> instance holds all the object-relational mapping metadata
- * of an entity and it's associations.
+ * {@inheritDoc}
  *
- * Once populated, ClassMetadata instances are usually cached in a serialized form.
- *
- * <b>IMPORTANT NOTE:</b>
- *
- * The fields of this class are only public for 2 reasons:
- * 1) To allow fast READ access.
- * 2) To drastically reduce the size of a serialized instance (private/protected members
- *    get the whole class name, namespace inclusive, prepended to every property in
- *    the serialized representation).
- *
- * @author Roman Borschel <roman@code-factory.org>
- * @author Jonathan H. Wage <jonwage@gmail.com>
- * @since 2.0
+ * @todo remove or rename ClassMetadataInfo to ClassMetadata
  */
 class ClassMetadata extends ClassMetadataInfo
 {

lib/Doctrine/ORM/Mapping/ClassMetadataFactory.php

@@ -13,24 +13,27 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Mapping;
 
-use ReflectionException,
-    Doctrine\ORM\ORMException,
-    Doctrine\ORM\EntityManager,
-    Doctrine\DBAL\Platforms,
-    Doctrine\ORM\Events,
-    Doctrine\Common\Persistence\Mapping\RuntimeReflectionService,
-    Doctrine\Common\Persistence\Mapping\ReflectionService,
-    Doctrine\Common\Persistence\Mapping\ClassMetadataFactory as ClassMetadataFactoryInterface;
+use ReflectionException;
+use Doctrine\ORM\ORMException;
+use Doctrine\ORM\EntityManager;
+use Doctrine\DBAL\Platforms;
+use Doctrine\ORM\Events;
+use Doctrine\Common\Persistence\Mapping\ReflectionService;
+use Doctrine\Common\Persistence\Mapping\ClassMetadata as ClassMetadataInterface;
+use Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory;
+use Doctrine\ORM\Id\IdentityGenerator;
+use Doctrine\ORM\Id\BigIntegerIdentityGenerator;
+use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
 
 /**
  * The ClassMetadataFactory is used to create ClassMetadata objects that contain all the
- * metadata mapping informations of a class which describes how a class should be mapped
+ * metadata mapping information of a class which describes how a class should be mapped
  * to a relational database.
  *
  * @since   2.0
@@ -39,7 +42,7 @@ use ReflectionException,
  * @author  Jonathan Wage <jonwage@gmail.com>
  * @author  Roman Borschel <roman@code-factory.org>
  */
-class ClassMetadataFactory implements ClassMetadataFactoryInterface
+class ClassMetadataFactory extends AbstractClassMetadataFactory
 {
     /**
      * @var EntityManager
@@ -47,12 +50,12 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
     private $em;
 
     /**
-     * @var AbstractPlatform
+     * @var \Doctrine\DBAL\Platforms\AbstractPlatform
      */
     private $targetPlatform;
 
     /**
-     * @var \Doctrine\ORM\Mapping\Driver\Driver
+     * @var \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver
      */
     private $driver;
 
@@ -62,27 +65,7 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
     private $evm;
 
     /**
-     * @var \Doctrine\Common\Cache\Cache
-     */
-    private $cacheDriver;
-
-    /**
-     * @var array
-     */
-    private $loadedMetadata = array();
-
-    /**
-     * @var bool
-     */
-    private $initialized = false;
-
-    /**
-     * @var ReflectionService
-     */
-    private $reflectionService;
-
-    /**
-     * @param EntityManager $$em
+     * @param EntityManager $em
      */
     public function setEntityManager(EntityManager $em)
     {
@@ -90,55 +73,9 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
     }
 
     /**
-     * Sets the cache driver used by the factory to cache ClassMetadata instances.
-     *
-     * @param \Doctrine\Common\Cache\Cache $cacheDriver
+     * {@inheritDoc}.
      */
-    public function setCacheDriver($cacheDriver)
-    {
-        $this->cacheDriver = $cacheDriver;
-    }
-
-    /**
-     * Gets the cache driver used by the factory to cache ClassMetadata instances.
-     *
-     * @return \Doctrine\Common\Cache\Cache
-     */
-    public function getCacheDriver()
-    {
-        return $this->cacheDriver;
-    }
-
-    public function getLoadedMetadata()
-    {
-        return $this->loadedMetadata;
-    }
-
-    /**
-     * Forces the factory to load the metadata of all classes known to the underlying
-     * mapping driver.
-     *
-     * @return array The ClassMetadata instances of all mapped classes.
-     */
-    public function getAllMetadata()
-    {
-        if ( ! $this->initialized) {
-            $this->initialize();
-        }
-
-        $metadata = array();
-        foreach ($this->driver->getAllClassNames() as $className) {
-            $metadata[] = $this->getMetadataFor($className);
-        }
-
-        return $metadata;
-    }
-
-    /**
-     * Lazy initialization of this stuff, especially the metadata driver,
-     * since these are not needed at all when a metadata cache is active.
-     */
-    private function initialize()
+    protected function initialize()
     {
         $this->driver = $this->em->getConfiguration()->getMetadataDriverImpl();
         $this->targetPlatform = $this->em->getConnection()->getDatabasePlatform();
@@ -147,215 +84,99 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
     }
 
     /**
-     * Gets the class metadata descriptor for a class.
-     *
-     * @param string $className The name of the class.
-     * @return \Doctrine\ORM\Mapping\ClassMetadata
+     * {@inheritDoc}
      */
-    public function getMetadataFor($className)
+    protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
     {
-        if ( ! isset($this->loadedMetadata[$className])) {
-            $realClassName = $className;
+        /* @var $class ClassMetadata */
+        /* @var $parent ClassMetadata */
+        if ($parent) {
+            $class->setInheritanceType($parent->inheritanceType);
+            $class->setDiscriminatorColumn($parent->discriminatorColumn);
+            $class->setIdGeneratorType($parent->generatorType);
+            $this->addInheritedFields($class, $parent);
+            $this->addInheritedRelations($class, $parent);
+            $class->setIdentifier($parent->identifier);
+            $class->setVersioned($parent->isVersioned);
+            $class->setVersionField($parent->versionField);
+            $class->setDiscriminatorMap($parent->discriminatorMap);
+            $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
+            $class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
 
-            // Check for namespace alias
-            if (strpos($className, ':') !== false) {
-                list($namespaceAlias, $simpleClassName) = explode(':', $className);
-                $realClassName = $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
-
-                if (isset($this->loadedMetadata[$realClassName])) {
-                    // We do not have the alias name in the map, include it
-                    $this->loadedMetadata[$className] = $this->loadedMetadata[$realClassName];
-
-                    return $this->loadedMetadata[$realClassName];
-                }
-            }
-
-            if ($this->cacheDriver) {
-                if (($cached = $this->cacheDriver->fetch("$realClassName\$CLASSMETADATA")) !== false) {
-                    $this->wakeupReflection($cached, $this->getReflectionService());
-                    $this->loadedMetadata[$realClassName] = $cached;
-                } else {
-                    foreach ($this->loadMetadata($realClassName) as $loadedClassName) {
-                        $this->cacheDriver->save(
-                            "$loadedClassName\$CLASSMETADATA", $this->loadedMetadata[$loadedClassName], null
-                        );
-                    }
-                }
-            } else {
-                $this->loadMetadata($realClassName);
-            }
-
-            if ($className != $realClassName) {
-                // We do not have the alias name in the map, include it
-                $this->loadedMetadata[$className] = $this->loadedMetadata[$realClassName];
+            if ($parent->isMappedSuperclass) {
+                $class->setCustomRepositoryClass($parent->customRepositoryClassName);
             }
         }
 
-        return $this->loadedMetadata[$className];
-    }
-
-    /**
-     * Checks whether the factory has the metadata for a class loaded already.
-     *
-     * @param string $className
-     * @return boolean TRUE if the metadata of the class in question is already loaded, FALSE otherwise.
-     */
-    public function hasMetadataFor($className)
-    {
-        return isset($this->loadedMetadata[$className]);
-    }
-
-    /**
-     * Sets the metadata descriptor for a specific class.
-     *
-     * NOTE: This is only useful in very special cases, like when generating proxy classes.
-     *
-     * @param string $className
-     * @param ClassMetadata $class
-     */
-    public function setMetadataFor($className, $class)
-    {
-        $this->loadedMetadata[$className] = $class;
-    }
-
-    /**
-     * Get array of parent classes for the given entity class
-     *
-     * @param string $name
-     * @return array $parentClasses
-     */
-    protected function getParentClasses($name)
-    {
-        // Collect parent classes, ignoring transient (not-mapped) classes.
-        $parentClasses = array();
-        foreach (array_reverse($this->getReflectionService()->getParentClasses($name)) as $parentClass) {
-            if ( ! $this->driver->isTransient($parentClass)) {
-                $parentClasses[] = $parentClass;
-            }
-        }
-        return $parentClasses;
-    }
-
-    /**
-     * Loads the metadata of the class in question and all it's ancestors whose metadata
-     * is still not loaded.
-     *
-     * @param string $name The name of the class for which the metadata should get loaded.
-     * @param array  $tables The metadata collection to which the loaded metadata is added.
-     */
-    protected function loadMetadata($name)
-    {
-        if ( ! $this->initialized) {
-            $this->initialize();
+        // Invoke driver
+        try {
+            $this->driver->loadMetadataForClass($class->getName(), $class);
+        } catch (ReflectionException $e) {
+            throw MappingException::reflectionFailure($class->getName(), $e);
         }
 
-        $loaded = array();
-
-        $parentClasses = $this->getParentClasses($name);
-        $parentClasses[] = $name;
-
-        // Move down the hierarchy of parent classes, starting from the topmost class
-        $parent = null;
-        $rootEntityFound = false;
-        $visited = array();
-        foreach ($parentClasses as $className) {
-            if (isset($this->loadedMetadata[$className])) {
-                $parent = $this->loadedMetadata[$className];
-                if ( ! $parent->isMappedSuperclass) {
-                    $rootEntityFound = true;
-                    array_unshift($visited, $className);
-                }
-                continue;
+        // If this class has a parent the id generator strategy is inherited.
+        // However this is only true if the hierarchy of parents contains the root entity,
+        // if it consists of mapped superclasses these don't necessarily include the id field.
+        if ($parent && $rootEntityFound) {
+            if ($parent->isIdGeneratorSequence()) {
+                $class->setSequenceGeneratorDefinition($parent->sequenceGeneratorDefinition);
+            } else if ($parent->isIdGeneratorTable()) {
+                $class->tableGeneratorDefinition = $parent->tableGeneratorDefinition;
             }
 
-            $class = $this->newClassMetadataInstance($className);
-            $this->initializeReflection($class, $this->getReflectionService());
-
-            if ($parent) {
-                $class->setInheritanceType($parent->inheritanceType);
-                $class->setDiscriminatorColumn($parent->discriminatorColumn);
+            if ($parent->generatorType) {
                 $class->setIdGeneratorType($parent->generatorType);
-                $this->addInheritedFields($class, $parent);
-                $this->addInheritedRelations($class, $parent);
-                $class->setIdentifier($parent->identifier);
-                $class->setVersioned($parent->isVersioned);
-                $class->setVersionField($parent->versionField);
-                $class->setDiscriminatorMap($parent->discriminatorMap);
-                $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
-                $class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
-                if ($parent->isMappedSuperclass) {
-                    $class->setCustomRepositoryClass($parent->customRepositoryClassName);
-                }
             }
 
-            // Invoke driver
-            try {
-                $this->driver->loadMetadataForClass($className, $class);
-            } catch (ReflectionException $e) {
-                throw MappingException::reflectionFailure($className, $e);
+            if ($parent->idGenerator) {
+                $class->setIdGenerator($parent->idGenerator);
             }
-
-            // If this class has a parent the id generator strategy is inherited.
-            // However this is only true if the hierachy of parents contains the root entity,
-            // if it consinsts of mapped superclasses these don't necessarily include the id field.
-            if ($parent && $rootEntityFound) {
-                if ($parent->isIdGeneratorSequence()) {
-                    $class->setSequenceGeneratorDefinition($parent->sequenceGeneratorDefinition);
-                } else if ($parent->isIdGeneratorTable()) {
-                    $class->getTableGeneratorDefinition($parent->tableGeneratorDefinition);
-                }
-                if ($parent->generatorType) {
-                    $class->setIdGeneratorType($parent->generatorType);
-                }
-                if ($parent->idGenerator) {
-                    $class->setIdGenerator($parent->idGenerator);
-                }
-            } else {
-                $this->completeIdGeneratorMapping($class);
-            }
-
-            if ($parent && $parent->isInheritanceTypeSingleTable()) {
-                $class->setPrimaryTable($parent->table);
-            }
-
-            if ($parent && $parent->containsForeignIdentifier) {
-                $class->containsForeignIdentifier = true;
-            }
-
-            if ($parent && !empty ($parent->namedQueries)) {
-                $this->addInheritedNamedQueries($class, $parent);
-            }
-
-            $class->setParentClasses($visited);
-
-            if ($this->evm->hasListeners(Events::loadClassMetadata)) {
-                $eventArgs = new \Doctrine\ORM\Event\LoadClassMetadataEventArgs($class, $this->em);
-                $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
-            }
-            $this->wakeupReflection($class, $this->getReflectionService());
-
-            $this->validateRuntimeMetadata($class, $parent);
-
-            $this->loadedMetadata[$className] = $class;
-
-            $parent = $class;
-
-            if ( ! $class->isMappedSuperclass) {
-                $rootEntityFound = true;
-                array_unshift($visited, $className);
-            }
-
-            $loaded[] = $className;
+        } else {
+            $this->completeIdGeneratorMapping($class);
         }
 
-        return $loaded;
+        if ($parent && $parent->isInheritanceTypeSingleTable()) {
+            $class->setPrimaryTable($parent->table);
+        }
+
+        if ($parent && $parent->containsForeignIdentifier) {
+            $class->containsForeignIdentifier = true;
+        }
+
+        if ($parent && !empty($parent->namedQueries)) {
+            $this->addInheritedNamedQueries($class, $parent);
+        }
+
+        if ($parent && !empty($parent->namedNativeQueries)) {
+            $this->addInheritedNamedNativeQueries($class, $parent);
+        }
+
+        if ($parent && !empty($parent->sqlResultSetMappings)) {
+            $this->addInheritedSqlResultSetMappings($class, $parent);
+        }
+
+        $class->setParentClasses($nonSuperclassParents);
+
+        if ( $class->isRootEntity() && ! $class->isInheritanceTypeNone() && ! $class->discriminatorMap) {
+            $this->addDefaultDiscriminatorMap($class);
+        }
+
+        if ($this->evm->hasListeners(Events::loadClassMetadata)) {
+            $eventArgs = new LoadClassMetadataEventArgs($class, $this->em);
+            $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
+        }
+
+        $this->wakeupReflection($class, $this->getReflectionService());
+        $this->validateRuntimeMetadata($class, $parent);
     }
 
     /**
      * Validate runtime metadata is correctly defined.
      *
      * @param ClassMetadata $class
-     * @param ClassMetadata $parent
+     * @param $parent
+     * @throws MappingException
      */
     protected function validateRuntimeMetadata($class, $parent)
     {
@@ -369,33 +190,85 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
         $class->validateLifecycleCallbacks($this->getReflectionService());
 
         // verify inheritance
-        if (!$class->isMappedSuperclass && !$class->isInheritanceTypeNone()) {
-            if (!$parent) {
+        if ( ! $class->isMappedSuperclass && !$class->isInheritanceTypeNone()) {
+            if ( ! $parent) {
                 if (count($class->discriminatorMap) == 0) {
                     throw MappingException::missingDiscriminatorMap($class->name);
                 }
-                if (!$class->discriminatorColumn) {
+                if ( ! $class->discriminatorColumn) {
                     throw MappingException::missingDiscriminatorColumn($class->name);
                 }
             } else if ($parent && !$class->reflClass->isAbstract() && !in_array($class->name, array_values($class->discriminatorMap))) {
-                // enforce discriminator map for all entities of an inheritance hierachy, otherwise problems will occur.
+                // enforce discriminator map for all entities of an inheritance hierarchy, otherwise problems will occur.
                 throw MappingException::mappedClassNotPartOfDiscriminatorMap($class->name, $class->rootEntityName);
             }
         } else if ($class->isMappedSuperclass && $class->name == $class->rootEntityName && (count($class->discriminatorMap) || $class->discriminatorColumn)) {
-            // second condition is necessary for mapped superclasses in the middle of an inheritance hierachy
+            // second condition is necessary for mapped superclasses in the middle of an inheritance hierarchy
             throw MappingException::noInheritanceOnMappedSuperClass($class->name);
         }
     }
 
     /**
-     * Creates a new ClassMetadata instance for the given class name.
-     *
-     * @param string $className
-     * @return \Doctrine\ORM\Mapping\ClassMetadata
+     * {@inheritDoc}
      */
     protected function newClassMetadataInstance($className)
     {
-        return new ClassMetadata($className);
+        return new ClassMetadata($className, $this->em->getConfiguration()->getNamingStrategy());
+    }
+
+    /**
+     * Adds a default discriminator map if no one is given
+     *
+     * If an entity is of any inheritance type and does not contain a
+     * discriminator map, then the map is generated automatically. This process
+     * is expensive computation wise.
+     *
+     * The automatically generated discriminator map contains the lowercase short name of
+     * each class as key.
+     *
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $class
+     * @throws MappingException
+     */
+    private function addDefaultDiscriminatorMap(ClassMetadata $class)
+    {
+        $allClasses = $this->driver->getAllClassNames();
+        $fqcn = $class->getName();
+        $map = array($this->getShortName($class->name) => $fqcn);
+
+        $duplicates = array();
+        foreach ($allClasses as $subClassCandidate) {
+            if (is_subclass_of($subClassCandidate, $fqcn)) {
+                $shortName = $this->getShortName($subClassCandidate);
+
+                if (isset($map[$shortName])) {
+                    $duplicates[] = $shortName;
+                }
+
+                $map[$shortName] = $subClassCandidate;
+            }
+        }
+
+        if ($duplicates) {
+            throw MappingException::duplicateDiscriminatorEntry($class->name, $duplicates, $map);
+        }
+
+        $class->setDiscriminatorMap($map);
+    }
+
+    /**
+     * Get the lower-case short name of a class.
+     *
+     * @param string $className
+     * @return string
+     */
+    private function getShortName($className)
+    {
+        if (strpos($className, "\\") === false) {
+            return strtolower($className);
+        }
+
+        $parts = explode("\\", $className);
+        return strtolower(end($parts));
     }
 
     /**
@@ -406,7 +279,7 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
      */
     private function addInheritedFields(ClassMetadata $subClass, ClassMetadata $parentClass)
     {
-        foreach ($parentClass->fieldMappings as $fieldName => $mapping) {
+        foreach ($parentClass->fieldMappings as $mapping) {
             if ( ! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {
                 $mapping['inherited'] = $parentClass->name;
             }
@@ -425,6 +298,7 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
      *
      * @param \Doctrine\ORM\Mapping\ClassMetadata $subClass
      * @param \Doctrine\ORM\Mapping\ClassMetadata $parentClass
+     * @throws MappingException
      */
     private function addInheritedRelations(ClassMetadata $subClass, ClassMetadata $parentClass)
     {
@@ -457,7 +331,7 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
     private function addInheritedNamedQueries(ClassMetadata $subClass, ClassMetadata $parentClass)
     {
         foreach ($parentClass->namedQueries as $name => $query) {
-            if (!isset ($subClass->namedQueries[$name])) {
+            if ( ! isset ($subClass->namedQueries[$name])) {
                 $subClass->addNamedQuery(array(
                     'name'  => $query['name'],
                     'query' => $query['query']
@@ -466,11 +340,64 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
         }
     }
 
+    /**
+     * Adds inherited named native queries to the subclass mapping.
+     *
+     * @since 2.3
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $subClass
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $parentClass
+     */
+    private function addInheritedNamedNativeQueries(ClassMetadata $subClass, ClassMetadata $parentClass)
+    {
+        foreach ($parentClass->namedNativeQueries as $name => $query) {
+            if ( ! isset ($subClass->namedNativeQueries[$name])) {
+                $subClass->addNamedNativeQuery(array(
+                    'name'              => $query['name'],
+                    'query'             => $query['query'],
+                    'isSelfClass'       => $query['isSelfClass'],
+                    'resultSetMapping'  => $query['resultSetMapping'],
+                    'resultClass'       => $query['isSelfClass'] ? $subClass->name : $query['resultClass'],
+                ));
+            }
+        }
+    }
+
+    /**
+     * Adds inherited sql result set mappings to the subclass mapping.
+     *
+     * @since 2.3
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $subClass
+     * @param \Doctrine\ORM\Mapping\ClassMetadata $parentClass
+     */
+    private function addInheritedSqlResultSetMappings(ClassMetadata $subClass, ClassMetadata $parentClass)
+    {
+        foreach ($parentClass->sqlResultSetMappings as $name => $mapping) {
+            if ( ! isset ($subClass->sqlResultSetMappings[$name])) {
+                $entities = array();
+                foreach ($mapping['entities'] as $entity) {
+                    $entities[] = array(
+                        'fields'                => $entity['fields'],
+                        'isSelfClass'           => $entity['isSelfClass'],
+                        'discriminatorColumn'   => $entity['discriminatorColumn'],
+                        'entityClass'           => $entity['isSelfClass'] ? $subClass->name : $entity['entityClass'],
+                    );
+                }
+
+                $subClass->addSqlResultSetMapping(array(
+                    'name'          => $mapping['name'],
+                    'columns'       => $mapping['columns'],
+                    'entities'      => $entities,
+                ));
+            }
+        }
+    }
+
     /**
      * Completes the ID generator mapping. If "auto" is specified we choose the generator
      * most appropriate for the targeted database platform.
      *
-     * @param \Doctrine\ORM\Mapping\ClassMetadata $class
+     * @param ClassMetadataInfo $class
+     * @throws ORMException
      */
     private function completeIdGeneratorMapping(ClassMetadataInfo $class)
     {
@@ -491,103 +418,126 @@ class ClassMetadataFactory implements ClassMetadataFactoryInterface
                 // For PostgreSQL IDENTITY (SERIAL) we need a sequence name. It defaults to
                 // <table>_<column>_seq in PostgreSQL for SERIAL columns.
                 // Not pretty but necessary and the simplest solution that currently works.
-                $seqName = $this->targetPlatform instanceof Platforms\PostgreSQLPlatform ?
-                        $class->getTableName() . '_' . $class->columnNames[$class->identifier[0]] . '_seq' :
-                        null;
-                $class->setIdGenerator(new \Doctrine\ORM\Id\IdentityGenerator($seqName));
+                $sequenceName = null;
+                $fieldName    = $class->identifier ? $class->getSingleIdentifierFieldName() : null;
+
+                if ($this->targetPlatform instanceof Platforms\PostgreSQLPlatform) {
+                    $columnName     = $class->getSingleIdentifierColumnName();
+                    $quoted         = isset($class->fieldMappings[$fieldName]['quoted']) || isset($class->table['quoted']);
+                    $sequenceName   = $class->getTableName() . '_' . $columnName . '_seq';
+                    $definition     = array(
+                        'sequenceName' => $this->targetPlatform->fixSchemaElementName($sequenceName)
+                    );
+
+                    if ($quoted) {
+                        $definition['quoted'] = true;
+                    }
+
+                    $sequenceName = $this->em->getConfiguration()->getQuoteStrategy()->getSequenceName($definition, $class, $this->targetPlatform);
+                }
+
+                $generator = ($fieldName && $class->fieldMappings[$fieldName]['type'] === "bigint")
+                    ? new BigIntegerIdentityGenerator($sequenceName)
+                    : new IdentityGenerator($sequenceName);
+
+                $class->setIdGenerator($generator);
+
                 break;
+
             case ClassMetadata::GENERATOR_TYPE_SEQUENCE:
                 // If there is no sequence definition yet, create a default definition
                 $definition = $class->sequenceGeneratorDefinition;
+
                 if ( ! $definition) {
-                    $sequenceName = $class->getTableName() . '_' . $class->getSingleIdentifierColumnName() . '_seq';
-                    $definition['sequenceName'] = $this->targetPlatform->fixSchemaElementName($sequenceName);
-                    $definition['allocationSize'] = 1;
-                    $definition['initialValue'] = 1;
+                    $fieldName      = $class->getSingleIdentifierFieldName();
+                    $columnName     = $class->getSingleIdentifierColumnName();
+                    $quoted         = isset($class->fieldMappings[$fieldName]['quoted']) || isset($class->table['quoted']);
+                    $sequenceName   = $class->getTableName() . '_' . $columnName . '_seq';
+                    $definition     = array(
+                        'sequenceName'      => $this->targetPlatform->fixSchemaElementName($sequenceName),
+                        'allocationSize'    => 1,
+                        'initialValue'      => 1,
+                    );
+
+                    if ($quoted) {
+                        $definition['quoted'] = true;
+                    }
+
                     $class->setSequenceGeneratorDefinition($definition);
                 }
+
                 $sequenceGenerator = new \Doctrine\ORM\Id\SequenceGenerator(
-                    $definition['sequenceName'],
+                    $this->em->getConfiguration()->getQuoteStrategy()->getSequenceName($definition, $class, $this->targetPlatform),
                     $definition['allocationSize']
                 );
                 $class->setIdGenerator($sequenceGenerator);
                 break;
+
             case ClassMetadata::GENERATOR_TYPE_NONE:
                 $class->setIdGenerator(new \Doctrine\ORM\Id\AssignedGenerator());
                 break;
+
+            case ClassMetadata::GENERATOR_TYPE_UUID:
+                $class->setIdGenerator(new \Doctrine\ORM\Id\UuidGenerator());
+                break;
+
             case ClassMetadata::GENERATOR_TYPE_TABLE:
                 throw new ORMException("TableGenerator not yet implemented.");
                 break;
+
+            case ClassMetadata::GENERATOR_TYPE_CUSTOM:
+                $definition = $class->customGeneratorDefinition;
+                if ( ! class_exists($definition['class'])) {
+                    throw new ORMException("Can't instantiate custom generator : " .
+                        $definition['class']);
+                }
+                $class->setIdGenerator(new $definition['class']);
+                break;
+
             default:
                 throw new ORMException("Unknown generator type: " . $class->generatorType);
         }
     }
 
     /**
-     * Check if this class is mapped by this EntityManager + ClassMetadata configuration
-     *
-     * @param $class
-     * @return bool
+     * {@inheritDoc}
      */
-    public function isTransient($class)
-    {
-        if ( ! $this->initialized) {
-            $this->initialize();
-        }
-
-        // Check for namespace alias
-        if (strpos($class, ':') !== false) {
-            list($namespaceAlias, $simpleClassName) = explode(':', $class);
-            $class = $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
-        }
-
-        return $this->driver->isTransient($class);
-    }
-
-    /**
-     * Get reflectionService.
-     *
-     * @return \Doctrine\Common\Persistence\Mapping\ReflectionService
-     */
-    public function getReflectionService()
-    {
-        if ($this->reflectionService === null) {
-            $this->reflectionService = new RuntimeReflectionService();
-        }
-        return $this->reflectionService;
-    }
-
-    /**
-     * Set reflectionService.
-     *
-     * @param reflectionService the value to set.
-     */
-    public function setReflectionService(ReflectionService $reflectionService)
-    {
-        $this->reflectionService = $reflectionService;
-    }
-
-    /**
-     * Wakeup reflection after ClassMetadata gets unserialized from cache.
-     *
-     * @param ClassMetadataInfo $class
-     * @param ReflectionService $reflService
-     * @return void
-     */
-    protected function wakeupReflection(ClassMetadataInfo $class, ReflectionService $reflService)
+    protected function wakeupReflection(ClassMetadataInterface $class, ReflectionService $reflService)
     {
+        /* @var $class ClassMetadata */
         $class->wakeupReflection($reflService);
     }
 
     /**
-     * Initialize Reflection after ClassMetadata was constructed.
-     *
-     * @param ClassMetadataInfo $class
-     * @param ReflectionService $reflService
-     * @return void
+     * {@inheritDoc}
      */
-    protected function initializeReflection(ClassMetadataInfo $class, ReflectionService $reflService)
+    protected function initializeReflection(ClassMetadataInterface $class, ReflectionService $reflService)
     {
+        /* @var $class ClassMetadata */
         $class->initializeReflection($reflService);
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
+    {
+        return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getDriver()
+    {
+        return $this->driver;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function isEntity(ClassMetadataInterface $class)
+    {
+        return isset($class->isMappedSuperclass) && $class->isMappedSuperclass === false;
+    }
 }

lib/Doctrine/ORM/Mapping/Column.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -21,7 +21,7 @@ namespace Doctrine\ORM\Mapping;
 
 /**
  * @Annotation
- * @Target("PROPERTY")
+ * @Target({"PROPERTY","ANNOTATION"})
  */
 final class Column implements Annotation
 {

lib/Doctrine/ORM/Mapping/ColumnResult.php

@@ -0,0 +1,42 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * References name of a column in the SELECT clause of a SQL query.
+ * Scalar result types can be included in the query result by specifying this annotation in the metadata.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("ANNOTATION")
+ */
+final class ColumnResult implements Annotation
+{
+
+    /**
+     * The name of a column in the SELECT clause of a SQL query
+     *
+     * @var string
+     */
+    public $name;
+
+}

lib/Doctrine/ORM/Mapping/CustomIdGenerator.php

@@ -0,0 +1,30 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * @Annotation
+ * @Target("PROPERTY")
+ */
+final class CustomIdGenerator implements Annotation
+{
+    /** @var string */
+    public $class;
+}

lib/Doctrine/ORM/Mapping/DefaultNamingStrategy.php

@@ -0,0 +1,86 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * The default NamingStrategy
+ *
+ * 
+ * @link    www.doctrine-project.org
+ * @since   2.3
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class DefaultNamingStrategy implements NamingStrategy
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function classToTableName($className)
+    {
+        if (strpos($className, '\\') !== false) {
+            return substr($className, strrpos($className, '\\') + 1);
+        }
+
+        return $className;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function propertyToColumnName($propertyName)
+    {
+        return $propertyName;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function referenceColumnName()
+    {
+        return 'id';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function joinColumnName($propertyName)
+    {
+        return $propertyName . '_' . $this->referenceColumnName();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function joinTableName($sourceEntity, $targetEntity, $propertyName = null)
+    {
+        return strtolower($this->classToTableName($sourceEntity) . '_' .
+                $this->classToTableName($targetEntity));
+    }
+    
+    /**
+     * {@inheritdoc}
+     */
+    public function joinKeyColumnName($entityName, $referencedColumnName = null)
+    {
+        return strtolower($this->classToTableName($entityName) . '_' .
+                ($referencedColumnName ?: $this->referenceColumnName()));
+    }
+}

lib/Doctrine/ORM/Mapping/DefaultQuoteStrategy.php

@@ -0,0 +1,140 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+
+/**
+ * A set of rules for determining the physical column, alias and table quotes
+ *
+ * @since   2.3
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class DefaultQuoteStrategy implements QuoteStrategy
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getColumnName($fieldName, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return isset($class->fieldMappings[$fieldName]['quoted'])
+            ? $platform->quoteIdentifier($class->fieldMappings[$fieldName]['columnName'])
+            : $class->fieldMappings[$fieldName]['columnName'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getTableName(ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return isset($class->table['quoted']) 
+            ? $platform->quoteIdentifier($class->table['name'])
+            : $class->table['name'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSequenceName(array $definition, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return isset($definition['quoted'])
+            ? $platform->quoteIdentifier($definition['sequenceName'])
+            : $definition['sequenceName'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getJoinColumnName(array $joinColumn, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return isset($joinColumn['quoted'])
+            ? $platform->quoteIdentifier($joinColumn['name'])
+            : $joinColumn['name'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getReferencedJoinColumnName(array $joinColumn, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return isset($joinColumn['quoted'])
+            ? $platform->quoteIdentifier($joinColumn['referencedColumnName'])
+            : $joinColumn['referencedColumnName'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getJoinTableName(array $association, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return isset($association['joinTable']['quoted'])
+            ? $platform->quoteIdentifier($association['joinTable']['name'])
+            : $association['joinTable']['name'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getIdentifierColumnNames(ClassMetadata $class, AbstractPlatform $platform)
+    {
+        $quotedColumnNames = array();
+
+        foreach ($class->identifier as $fieldName) {
+            if (isset($class->fieldMappings[$fieldName])) {
+                $quotedColumnNames[] = $this->getColumnName($fieldName, $class, $platform);
+
+                continue;
+            }
+
+            // Association defined as Id field
+            $joinColumns            = $class->associationMappings[$fieldName]['joinColumns'];
+            $assocQuotedColumnNames = array_map(
+                function ($joinColumn) use ($platform)
+                {
+                    return isset($joinColumn['quoted'])
+                        ? $platform->quoteIdentifier($joinColumn['name'])
+                        : $joinColumn['name'];
+                },
+                $joinColumns
+            );
+
+            $quotedColumnNames = array_merge($quotedColumnNames, $assocQuotedColumnNames);
+        }
+
+        return $quotedColumnNames;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getColumnAlias($columnName, $counter, AbstractPlatform $platform, ClassMetadata $class = null)
+    {
+        // Trim the column alias to the maximum identifier length of the platform.
+        // If the alias is to long, characters are cut off from the beginning.
+        // And strip non alphanumeric characters
+        $columnName = $columnName . $counter;
+        $columnName = substr($columnName, -$platform->getMaxIdentifierLength());
+        $columnName = preg_replace('/[^A-Za-z0-9_]/', '', $columnName);
+
+        return $platform->getSQLResultCasing($columnName);
+    }
+
+}

lib/Doctrine/ORM/Mapping/DiscriminatorColumn.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -33,4 +33,6 @@ final class DiscriminatorColumn implements Annotation
     public $length;
     /** @var mixed */
     public $fieldName; // field name used in non-object hydration (array/scalar)
+    /** @var string */
+    public $columnDefinition;
 }

lib/Doctrine/ORM/Mapping/DiscriminatorMap.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/Driver/AbstractFileDriver.php

@@ -1,213 +0,0 @@
-<?php
-/*
- *  $Id$
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
- * <http://www.doctrine-project.org>.
- */
-
-namespace Doctrine\ORM\Mapping\Driver;
-
-use Doctrine\ORM\Mapping\MappingException;
-
-/**
- * Base driver for file-based metadata drivers.
- *
- * A file driver operates in a mode where it loads the mapping files of individual
- * classes on demand. This requires the user to adhere to the convention of 1 mapping
- * file per class and the file names of the mapping files must correspond to the full
- * class name, including namespace, with the namespace delimiters '\', replaced by dots '.'.
- *
- * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
- * @link        www.doctrine-project.com
- * @since       2.0
- * @version     $Revision$
- * @author		Benjamin Eberlei <kontakt@beberlei.de>
- * @author		Guilherme Blanco <guilhermeblanco@hotmail.com>
- * @author      Jonathan H. Wage <jonwage@gmail.com>
- * @author      Roman Borschel <roman@code-factory.org>
- */
-abstract class AbstractFileDriver implements Driver
-{
-    /**
-     * The paths where to look for mapping files.
-     *
-     * @var array
-     */
-    protected $_paths = array();
-
-    /**
-     * The file extension of mapping documents.
-     *
-     * @var string
-     */
-    protected $_fileExtension;
-
-    /**
-     * Initializes a new FileDriver that looks in the given path(s) for mapping
-     * documents and operates in the specified operating mode.
-     *
-     * @param string|array $paths One or multiple paths where mapping documents can be found.
-     */
-    public function __construct($paths)
-    {
-        $this->addPaths((array) $paths);
-    }
-
-    /**
-     * Append lookup paths to metadata driver.
-     *
-     * @param array $paths
-     */
-    public function addPaths(array $paths)
-    {
-        $this->_paths = array_unique(array_merge($this->_paths, $paths));
-    }
-
-    /**
-     * Retrieve the defined metadata lookup paths.
-     *
-     * @return array
-     */
-    public function getPaths()
-    {
-        return $this->_paths;
-    }
-
-    /**
-     * Get the file extension used to look for mapping files under
-     *
-     * @return void
-     */
-    public function getFileExtension()
-    {
-        return $this->_fileExtension;
-    }
-
-    /**
-     * Set the file extension used to look for mapping files under
-     *
-     * @param string $fileExtension The file extension to set
-     * @return void
-     */
-    public function setFileExtension($fileExtension)
-    {
-        $this->_fileExtension = $fileExtension;
-    }
-
-    /**
-     * Get the element of schema meta data for the class from the mapping file.
-     * This will lazily load the mapping file if it is not loaded yet
-     *
-     * @return array $element  The element of schema meta data
-     */
-    public function getElement($className)
-    {
-        $result = $this->_loadMappingFile($this->_findMappingFile($className));
-
-        if(!isset($result[$className])){
-            throw MappingException::invalidMappingFile($className, str_replace('\\', '.', $className) . $this->_fileExtension);
-        }
-        return $result[$className];
-    }
-
-    /**
-     * Whether the class with the specified name should have its metadata loaded.
-     * This is only the case if it is either mapped as an Entity or a
-     * MappedSuperclass.
-     *
-     * @param string $className
-     * @return boolean
-     */
-    public function isTransient($className)
-    {
-        $fileName = str_replace('\\', '.', $className) . $this->_fileExtension;
-
-        // Check whether file exists
-        foreach ((array) $this->_paths as $path) {
-            if (file_exists($path . DIRECTORY_SEPARATOR . $fileName)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Gets the names of all mapped classes known to this driver.
-     *
-     * @return array The names of all mapped classes known to this driver.
-     */
-    public function getAllClassNames()
-    {
-        $classes = array();
-
-        if ($this->_paths) {
-            foreach ((array) $this->_paths as $path) {
-                if ( ! is_dir($path)) {
-                    throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
-                }
-
-                $iterator = new \RecursiveIteratorIterator(
-                    new \RecursiveDirectoryIterator($path),
-                    \RecursiveIteratorIterator::LEAVES_ONLY
-                );
-
-                foreach ($iterator as $file) {
-                    if (($fileName = $file->getBasename($this->_fileExtension)) == $file->getBasename()) {
-                        continue;
-                    }
-
-                    // NOTE: All files found here means classes are not transient!
-                    $classes[] = str_replace('.', '\\', $fileName);
-                }
-            }
-        }
-
-        return $classes;
-    }
-
-    /**
-     * Finds the mapping file for the class with the given name by searching
-     * through the configured paths.
-     *
-     * @param $className
-     * @return string The (absolute) file name.
-     * @throws MappingException
-     */
-    protected function _findMappingFile($className)
-    {
-        $fileName = str_replace('\\', '.', $className) . $this->_fileExtension;
-
-        // Check whether file exists
-        foreach ((array) $this->_paths as $path) {
-            if (file_exists($path . DIRECTORY_SEPARATOR . $fileName)) {
-                return $path . DIRECTORY_SEPARATOR . $fileName;
-            }
-        }
-
-        throw MappingException::mappingFileNotFound($className, $fileName);
-    }
-
-    /**
-     * Loads a mapping file with the given name and returns a map
-     * from class/entity names to their corresponding elements.
-     *
-     * @param string $file The mapping file to load.
-     * @return array
-     */
-    abstract protected function _loadMappingFile($file);
-}

lib/Doctrine/ORM/Mapping/Driver/AnnotationDriver.php

@@ -13,17 +13,18 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Mapping\Driver;
 
-use Doctrine\Common\Cache\ArrayCache,
-    Doctrine\Common\Annotations\AnnotationReader,
-    Doctrine\Common\Annotations\AnnotationRegistry,
-    Doctrine\ORM\Mapping\ClassMetadataInfo,
-    Doctrine\ORM\Mapping\MappingException;
+use Doctrine\Common\Annotations\AnnotationReader,
+    Doctrine\ORM\Mapping\MappingException,
+    Doctrine\ORM\Mapping\JoinColumn,
+    Doctrine\ORM\Mapping\Column,
+    Doctrine\Common\Persistence\Mapping\ClassMetadata,
+    Doctrine\Common\Persistence\Mapping\Driver\AnnotationDriver as AbstractAnnotationDriver;
 
 /**
  * The AnnotationDriver reads the mapping metadata from docblock annotations.
@@ -34,113 +35,30 @@ use Doctrine\Common\Cache\ArrayCache,
  * @author Jonathan H. Wage <jonwage@gmail.com>
  * @author Roman Borschel <roman@code-factory.org>
  */
-class AnnotationDriver implements Driver
+class AnnotationDriver extends AbstractAnnotationDriver
 {
     /**
-     * The AnnotationReader.
-     *
-     * @var AnnotationReader
+     * {@inheritDoc}
      */
-    protected $_reader;
+    protected $entityAnnotationClasses = array(
+        'Doctrine\ORM\Mapping\Entity' => 1,
+        'Doctrine\ORM\Mapping\MappedSuperclass' => 2,
+    );
 
     /**
-     * The paths where to look for mapping files.
-     *
-     * @var array
+     * {@inheritDoc}
      */
-    protected $_paths = array();
-
-    /**
-     * The file extension of mapping documents.
-     *
-     * @var string
-     */
-    protected $_fileExtension = '.php';
-
-    /**
-     * @param array
-     */
-    protected $_classNames;
-
-    /**
-     * Initializes a new AnnotationDriver that uses the given AnnotationReader for reading
-     * docblock annotations.
-     *
-     * @param AnnotationReader $reader The AnnotationReader to use, duck-typed.
-     * @param string|array $paths One or multiple paths where mapping classes can be found.
-     */
-    public function __construct($reader, $paths = null)
-    {
-        $this->_reader = $reader;
-        if ($paths) {
-            $this->addPaths((array) $paths);
-        }
-    }
-
-    /**
-     * Append lookup paths to metadata driver.
-     *
-     * @param array $paths
-     */
-    public function addPaths(array $paths)
-    {
-        $this->_paths = array_unique(array_merge($this->_paths, $paths));
-    }
-
-    /**
-     * Retrieve the defined metadata lookup paths.
-     *
-     * @return array
-     */
-    public function getPaths()
-    {
-        return $this->_paths;
-    }
-
-    /**
-     * Retrieve the current annotation reader
-     *
-     * @return AnnotationReader
-     */
-    public function getReader()
-    {
-        return $this->_reader;
-    }
-
-    /**
-     * Get the file extension used to look for mapping files under
-     *
-     * @return void
-     */
-    public function getFileExtension()
-    {
-        return $this->_fileExtension;
-    }
-
-    /**
-     * Set the file extension used to look for mapping files under
-     *
-     * @param string $fileExtension The file extension to set
-     * @return void
-     */
-    public function setFileExtension($fileExtension)
-    {
-        $this->_fileExtension = $fileExtension;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function loadMetadataForClass($className, ClassMetadataInfo $metadata)
+    public function loadMetadataForClass($className, ClassMetadata $metadata)
     {
+        /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadataInfo */
         $class = $metadata->getReflectionClass();
-        if (!$class) {
+        if ( ! $class) {
             // this happens when running annotation driver in combination with
             // static reflection services. This is not the nicest fix
             $class = new \ReflectionClass($metadata->name);
         }
 
-        $classAnnotations = $this->_reader->getClassAnnotations($class);
+        $classAnnotations = $this->reader->getClassAnnotations($class);
 
         if ($classAnnotations) {
             foreach ($classAnnotations as $key => $annot) {
@@ -201,19 +119,75 @@ class AnnotationDriver implements Driver
                 }
             }
 
+            if ($tableAnnot->options !== null) {
+                $primaryTable['options'] = $tableAnnot->options;
+            }
+
             $metadata->setPrimaryTable($primaryTable);
         }
 
+        // Evaluate NamedNativeQueries annotation
+        if (isset($classAnnotations['Doctrine\ORM\Mapping\NamedNativeQueries'])) {
+            $namedNativeQueriesAnnot = $classAnnotations['Doctrine\ORM\Mapping\NamedNativeQueries'];
+
+            foreach ($namedNativeQueriesAnnot->value as $namedNativeQuery) {
+                $metadata->addNamedNativeQuery(array(
+                    'name'              => $namedNativeQuery->name,
+                    'query'             => $namedNativeQuery->query,
+                    'resultClass'       => $namedNativeQuery->resultClass,
+                    'resultSetMapping'  => $namedNativeQuery->resultSetMapping,
+                ));
+            }
+        }
+
+        // Evaluate SqlResultSetMappings annotation
+        if (isset($classAnnotations['Doctrine\ORM\Mapping\SqlResultSetMappings'])) {
+            $sqlResultSetMappingsAnnot = $classAnnotations['Doctrine\ORM\Mapping\SqlResultSetMappings'];
+
+            foreach ($sqlResultSetMappingsAnnot->value as $resultSetMapping) {
+                $entities = array();
+                $columns  = array();
+                foreach ($resultSetMapping->entities as $entityResultAnnot) {
+                    $entityResult = array(
+                        'fields'                => array(),
+                        'entityClass'           => $entityResultAnnot->entityClass,
+                        'discriminatorColumn'   => $entityResultAnnot->discriminatorColumn,
+                    );
+
+                    foreach ($entityResultAnnot->fields as $fieldResultAnnot) {
+                        $entityResult['fields'][] = array(
+                            'name'      => $fieldResultAnnot->name,
+                            'column'    => $fieldResultAnnot->column
+                        );
+                    }
+
+                    $entities[] = $entityResult;
+                }
+
+                foreach ($resultSetMapping->columns as $columnResultAnnot) {
+                    $columns[] = array(
+                        'name' => $columnResultAnnot->name,
+                    );
+                }
+
+                $metadata->addSqlResultSetMapping(array(
+                    'name'          => $resultSetMapping->name,
+                    'entities'      => $entities,
+                    'columns'       => $columns
+                ));
+            }
+        }
+
         // Evaluate NamedQueries annotation
         if (isset($classAnnotations['Doctrine\ORM\Mapping\NamedQueries'])) {
             $namedQueriesAnnot = $classAnnotations['Doctrine\ORM\Mapping\NamedQueries'];
 
-            if (!is_array($namedQueriesAnnot->value)) {
+            if ( ! is_array($namedQueriesAnnot->value)) {
                 throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations.");
             }
 
             foreach ($namedQueriesAnnot->value as $namedQuery) {
-                if (!($namedQuery instanceof \Doctrine\ORM\Mapping\NamedQuery)) {
+                if ( ! ($namedQuery instanceof \Doctrine\ORM\Mapping\NamedQuery)) {
                     throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations.");
                 }
                 $metadata->addNamedQuery(array(
@@ -235,7 +209,8 @@ class AnnotationDriver implements Driver
                     $metadata->setDiscriminatorColumn(array(
                         'name' => $discrColumnAnnot->name,
                         'type' => $discrColumnAnnot->type,
-                        'length' => $discrColumnAnnot->length
+                        'length' => $discrColumnAnnot->length,
+                        'columnDefinition'    => $discrColumnAnnot->columnDefinition
                     ));
                 } else {
                     $metadata->setDiscriminatorColumn(array('name' => 'dtype', 'type' => 'string', 'length' => 255));
@@ -257,6 +232,7 @@ class AnnotationDriver implements Driver
         }
 
         // Evaluate annotations on properties/fields
+        /* @var $property \ReflectionProperty */
         foreach ($class->getProperties() as $property) {
             if ($metadata->isMappedSuperclass && ! $property->isPrivate()
                 ||
@@ -272,79 +248,53 @@ class AnnotationDriver implements Driver
             // Check for JoinColummn/JoinColumns annotations
             $joinColumns = array();
 
-            if ($joinColumnAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\JoinColumn')) {
-                $joinColumns[] = array(
-                    'name' => $joinColumnAnnot->name,
-                    'referencedColumnName' => $joinColumnAnnot->referencedColumnName,
-                    'unique' => $joinColumnAnnot->unique,
-                    'nullable' => $joinColumnAnnot->nullable,
-                    'onDelete' => $joinColumnAnnot->onDelete,
-                    'columnDefinition' => $joinColumnAnnot->columnDefinition,
-                );
-            } else if ($joinColumnsAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\JoinColumns')) {
+            if ($joinColumnAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\JoinColumn')) {
+                $joinColumns[] = $this->joinColumnToArray($joinColumnAnnot);
+            } else if ($joinColumnsAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\JoinColumns')) {
                 foreach ($joinColumnsAnnot->value as $joinColumn) {
-                    $joinColumns[] = array(
-                        'name' => $joinColumn->name,
-                        'referencedColumnName' => $joinColumn->referencedColumnName,
-                        'unique' => $joinColumn->unique,
-                        'nullable' => $joinColumn->nullable,
-                        'onDelete' => $joinColumn->onDelete,
-                        'columnDefinition' => $joinColumn->columnDefinition,
-                    );
+                    $joinColumns[] = $this->joinColumnToArray($joinColumn);
                 }
             }
 
             // Field can only be annotated with one of:
             // @Column, @OneToOne, @OneToMany, @ManyToOne, @ManyToMany
-            if ($columnAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Column')) {
+            if ($columnAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Column')) {
                 if ($columnAnnot->type == null) {
                     throw MappingException::propertyTypeIsRequired($className, $property->getName());
                 }
 
-                $mapping['type'] = $columnAnnot->type;
-                $mapping['length'] = $columnAnnot->length;
-                $mapping['precision'] = $columnAnnot->precision;
-                $mapping['scale'] = $columnAnnot->scale;
-                $mapping['nullable'] = $columnAnnot->nullable;
-                $mapping['unique'] = $columnAnnot->unique;
-                if ($columnAnnot->options) {
-                    $mapping['options'] = $columnAnnot->options;
-                }
+                $mapping = $this->columnToArray($property->getName(), $columnAnnot);
 
-                if (isset($columnAnnot->name)) {
-                    $mapping['columnName'] = $columnAnnot->name;
-                }
-
-                if (isset($columnAnnot->columnDefinition)) {
-                    $mapping['columnDefinition'] = $columnAnnot->columnDefinition;
-                }
-
-                if ($idAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Id')) {
+                if ($idAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Id')) {
                     $mapping['id'] = true;
                 }
 
-                if ($generatedValueAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\GeneratedValue')) {
+                if ($generatedValueAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\GeneratedValue')) {
                     $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_' . $generatedValueAnnot->strategy));
                 }
 
-                if ($versionAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Version')) {
+                if ($this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Version')) {
                     $metadata->setVersionMapping($mapping);
                 }
 
                 $metadata->mapField($mapping);
 
                 // Check for SequenceGenerator/TableGenerator definition
-                if ($seqGeneratorAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\SequenceGenerator')) {
+                if ($seqGeneratorAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\SequenceGenerator')) {
                     $metadata->setSequenceGeneratorDefinition(array(
                         'sequenceName' => $seqGeneratorAnnot->sequenceName,
                         'allocationSize' => $seqGeneratorAnnot->allocationSize,
                         'initialValue' => $seqGeneratorAnnot->initialValue
                     ));
-                } else if ($tblGeneratorAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\TableGenerator')) {
+                } else if ($this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\TableGenerator')) {
                     throw MappingException::tableIdGeneratorNotImplemented($className);
+                } else if ($customGeneratorAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\CustomIdGenerator')) {
+                    $metadata->setCustomGeneratorDefinition(array(
+                        'class' => $customGeneratorAnnot->class
+                    ));
                 }
-            } else if ($oneToOneAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OneToOne')) {
-                if ($idAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Id')) {
+            } else if ($oneToOneAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OneToOne')) {
+                if ($idAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Id')) {
                     $mapping['id'] = true;
                 }
 
@@ -356,7 +306,7 @@ class AnnotationDriver implements Driver
                 $mapping['orphanRemoval'] = $oneToOneAnnot->orphanRemoval;
                 $mapping['fetch'] = $this->getFetchMode($className, $oneToOneAnnot->fetch);
                 $metadata->mapOneToOne($mapping);
-            } else if ($oneToManyAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OneToMany')) {
+            } else if ($oneToManyAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OneToMany')) {
                 $mapping['mappedBy'] = $oneToManyAnnot->mappedBy;
                 $mapping['targetEntity'] = $oneToManyAnnot->targetEntity;
                 $mapping['cascade'] = $oneToManyAnnot->cascade;
@@ -364,13 +314,13 @@ class AnnotationDriver implements Driver
                 $mapping['orphanRemoval'] = $oneToManyAnnot->orphanRemoval;
                 $mapping['fetch'] = $this->getFetchMode($className, $oneToManyAnnot->fetch);
 
-                if ($orderByAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OrderBy')) {
+                if ($orderByAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OrderBy')) {
                     $mapping['orderBy'] = $orderByAnnot->value;
                 }
 
                 $metadata->mapOneToMany($mapping);
-            } else if ($manyToOneAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\ManyToOne')) {
-                if ($idAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Id')) {
+            } else if ($manyToOneAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\ManyToOne')) {
+                if ($idAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Id')) {
                     $mapping['id'] = true;
                 }
 
@@ -380,35 +330,21 @@ class AnnotationDriver implements Driver
                 $mapping['targetEntity'] = $manyToOneAnnot->targetEntity;
                 $mapping['fetch'] = $this->getFetchMode($className, $manyToOneAnnot->fetch);
                 $metadata->mapManyToOne($mapping);
-            } else if ($manyToManyAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\ManyToMany')) {
+            } else if ($manyToManyAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\ManyToMany')) {
                 $joinTable = array();
 
-                if ($joinTableAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\JoinTable')) {
+                if ($joinTableAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\JoinTable')) {
                     $joinTable = array(
                         'name' => $joinTableAnnot->name,
                         'schema' => $joinTableAnnot->schema
                     );
 
                     foreach ($joinTableAnnot->joinColumns as $joinColumn) {
-                        $joinTable['joinColumns'][] = array(
-                            'name' => $joinColumn->name,
-                            'referencedColumnName' => $joinColumn->referencedColumnName,
-                            'unique' => $joinColumn->unique,
-                            'nullable' => $joinColumn->nullable,
-                            'onDelete' => $joinColumn->onDelete,
-                            'columnDefinition' => $joinColumn->columnDefinition,
-                        );
+                        $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumn);
                     }
 
                     foreach ($joinTableAnnot->inverseJoinColumns as $joinColumn) {
-                        $joinTable['inverseJoinColumns'][] = array(
-                            'name' => $joinColumn->name,
-                            'referencedColumnName' => $joinColumn->referencedColumnName,
-                            'unique' => $joinColumn->unique,
-                            'nullable' => $joinColumn->nullable,
-                            'onDelete' => $joinColumn->onDelete,
-                            'columnDefinition' => $joinColumn->columnDefinition,
-                        );
+                        $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumn);
                     }
                 }
 
@@ -421,7 +357,7 @@ class AnnotationDriver implements Driver
                 $mapping['orphanRemoval'] = $manyToManyAnnot->orphanRemoval;
                 $mapping['fetch'] = $this->getFetchMode($className, $manyToManyAnnot->fetch);
 
-                if ($orderByAnnot = $this->_reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OrderBy')) {
+                if ($orderByAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OrderBy')) {
                     $mapping['orderBy'] = $orderByAnnot->value;
                 }
 
@@ -429,12 +365,63 @@ class AnnotationDriver implements Driver
             }
         }
 
+        // Evaluate AssociationOverrides annotation
+        if (isset($classAnnotations['Doctrine\ORM\Mapping\AssociationOverrides'])) {
+            $associationOverridesAnnot = $classAnnotations['Doctrine\ORM\Mapping\AssociationOverrides'];
+
+            foreach ($associationOverridesAnnot->value as $associationOverride) {
+                $override   = array();
+                $fieldName  = $associationOverride->name;
+
+                // Check for JoinColummn/JoinColumns annotations
+                if ($associationOverride->joinColumns) {
+                    $joinColumns = array();
+                    foreach ($associationOverride->joinColumns as $joinColumn) {
+                        $joinColumns[] = $this->joinColumnToArray($joinColumn);
+                    }
+                    $override['joinColumns'] = $joinColumns;
+                }
+
+                // Check for JoinTable annotations
+                if ($associationOverride->joinTable) {
+                    $joinTable      = null;
+                    $joinTableAnnot = $associationOverride->joinTable;
+                    $joinTable = array(
+                        'name'      => $joinTableAnnot->name,
+                        'schema'    => $joinTableAnnot->schema
+                    );
+
+                    foreach ($joinTableAnnot->joinColumns as $joinColumn) {
+                        $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumn);
+                    }
+
+                    foreach ($joinTableAnnot->inverseJoinColumns as $joinColumn) {
+                        $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumn);
+                    }
+
+                    $override['joinTable'] = $joinTable;
+                }
+
+                $metadata->setAssociationOverride($fieldName, $override);
+            }
+        }
+
+        // Evaluate AttributeOverrides annotation
+        if (isset($classAnnotations['Doctrine\ORM\Mapping\AttributeOverrides'])) {
+            $attributeOverridesAnnot = $classAnnotations['Doctrine\ORM\Mapping\AttributeOverrides'];
+            foreach ($attributeOverridesAnnot->value as $attributeOverrideAnnot) {
+                $attributeOverride = $this->columnToArray($attributeOverrideAnnot->name, $attributeOverrideAnnot->column);
+                $metadata->setAttributeOverride($attributeOverrideAnnot->name, $attributeOverride);
+            }
+        }
+
         // Evaluate @HasLifecycleCallbacks annotation
         if (isset($classAnnotations['Doctrine\ORM\Mapping\HasLifecycleCallbacks'])) {
+            /* @var $method \ReflectionMethod */
             foreach ($class->getMethods() as $method) {
                 // filter for the declaring class only, callbacks from parents will already be registered.
                 if ($method->isPublic() && $method->getDeclaringClass()->getName() == $class->name) {
-                    $annotations = $this->_reader->getMethodAnnotations($method);
+                    $annotations = $this->reader->getMethodAnnotations($method);
 
                     if ($annotations) {
                         foreach ($annotations as $key => $annot) {
@@ -481,90 +468,6 @@ class AnnotationDriver implements Driver
         }
     }
 
-    /**
-     * Whether the class with the specified name is transient. Only non-transient
-     * classes, that is entities and mapped superclasses, should have their metadata loaded.
-     * A class is non-transient if it is annotated with either @Entity or
-     * @MappedSuperclass in the class doc block.
-     *
-     * @param string $className
-     * @return boolean
-     */
-    public function isTransient($className)
-    {
-        $classAnnotations = $this->_reader->getClassAnnotations(new \ReflectionClass($className));
-
-        if ($classAnnotations && is_numeric(key($classAnnotations))) {
-            foreach ($classAnnotations as $annot) {
-                if ($annot instanceof \Doctrine\ORM\Mapping\Entity) {
-                    return false;
-                }
-                if ($annot instanceof \Doctrine\ORM\Mapping\MappedSuperclass) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        return ! isset($classAnnotations['Doctrine\ORM\Mapping\Entity']) &&
-               ! isset($classAnnotations['Doctrine\ORM\Mapping\MappedSuperclass']);
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function getAllClassNames()
-    {
-        if ($this->_classNames !== null) {
-            return $this->_classNames;
-        }
-
-        if (!$this->_paths) {
-            throw MappingException::pathRequired();
-        }
-
-        $classes = array();
-        $includedFiles = array();
-
-        foreach ($this->_paths as $path) {
-            if ( ! is_dir($path)) {
-                throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
-            }
-
-            $iterator = new \RegexIterator(
-                new \RecursiveIteratorIterator(
-                    new \RecursiveDirectoryIterator($path, \FilesystemIterator::SKIP_DOTS),
-                    \RecursiveIteratorIterator::LEAVES_ONLY
-                ),
-                '/^.+' . str_replace('.', '\.', $this->_fileExtension) . '$/i',
-                \RecursiveRegexIterator::GET_MATCH
-            );
-
-            foreach ($iterator as $file) {
-                $sourceFile = realpath($file[0]);
-
-                require_once $sourceFile;
-
-                $includedFiles[] = $sourceFile;
-            }
-        }
-
-        $declared = get_declared_classes();
-
-        foreach ($declared as $className) {
-            $rc = new \ReflectionClass($className);
-            $sourceFile = $rc->getFileName();
-            if (in_array($sourceFile, $includedFiles) && ! $this->isTransient($className)) {
-                $classes[] = $className;
-            }
-        }
-
-        $this->_classNames = $classes;
-
-        return $classes;
-    }
-
     /**
      * Attempts to resolve the fetch mode.
      *
@@ -575,12 +478,65 @@ class AnnotationDriver implements Driver
      */
     private function getFetchMode($className, $fetchMode)
     {
-        if(!defined('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode)) {
+        if( ! defined('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode)) {
             throw MappingException::invalidFetchMode($className,  $fetchMode);
         }
 
         return constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode);
     }
+
+    /**
+     * Parse the given JoinColumn as array
+     *
+     * @param   JoinColumn $joinColumn
+     * @return  array
+     */
+    private function joinColumnToArray(JoinColumn $joinColumn)
+    {
+        return array(
+            'name' => $joinColumn->name,
+            'unique' => $joinColumn->unique,
+            'nullable' => $joinColumn->nullable,
+            'onDelete' => $joinColumn->onDelete,
+            'columnDefinition' => $joinColumn->columnDefinition,
+            'referencedColumnName' => $joinColumn->referencedColumnName,
+        );
+    }
+
+    /**
+     * Parse the given Column as array
+     *
+     * @param   string $fieldName
+     * @param   Column $column
+     * @return  array
+     */
+    private function columnToArray($fieldName, Column $column)
+    {
+        $mapping = array(
+            'fieldName' => $fieldName,
+            'type'      => $column->type,
+            'scale'     => $column->scale,
+            'length'    => $column->length,
+            'unique'    => $column->unique,
+            'nullable'  => $column->nullable,
+            'precision' => $column->precision
+        );
+
+        if ($column->options) {
+            $mapping['options'] = $column->options;
+        }
+
+        if (isset($column->name)) {
+            $mapping['columnName'] = $column->name;
+        }
+
+        if (isset($column->columnDefinition)) {
+            $mapping['columnDefinition'] = $column->columnDefinition;
+        }
+
+        return $mapping;
+    }
+
     /**
      * Factory method for the Annotation Driver
      *
@@ -592,8 +548,8 @@ class AnnotationDriver implements Driver
     {
         if ($reader == null) {
             $reader = new AnnotationReader();
-            $reader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\\');
         }
+
         return new self($reader, $paths);
     }
 }

lib/Doctrine/ORM/Mapping/Driver/DatabaseDriver.php

@@ -13,31 +13,31 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Mapping\Driver;
 
-use Doctrine\Common\Cache\ArrayCache,
-    Doctrine\Common\Annotations\AnnotationReader,
-    Doctrine\DBAL\Schema\AbstractSchemaManager,
+use Doctrine\DBAL\Schema\AbstractSchemaManager,
     Doctrine\DBAL\Schema\SchemaException,
+    Doctrine\Common\Persistence\Mapping\Driver\MappingDriver,
+    Doctrine\Common\Persistence\Mapping\ClassMetadata,
     Doctrine\ORM\Mapping\ClassMetadataInfo,
-    Doctrine\ORM\Mapping\MappingException,
-    Doctrine\Common\Util\Inflector;
+    Doctrine\Common\Util\Inflector,
+    Doctrine\ORM\Mapping\MappingException;
 
 /**
  * The DatabaseDriver reverse engineers the mapping metadata from a database.
  *
- * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ *
  * @link    www.doctrine-project.org
  * @since   2.0
  * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
  * @author  Jonathan Wage <jonwage@gmail.com>
  * @author  Benjamin Eberlei <kontakt@beberlei.de>
  */
-class DatabaseDriver implements Driver
+class DatabaseDriver implements MappingDriver
 {
     /**
      * @var AbstractSchemaManager
@@ -74,10 +74,8 @@ class DatabaseDriver implements Driver
     private $namespace;
 
     /**
-     * Initializes a new AnnotationDriver that uses the given AnnotationReader for reading
-     * docblock annotations.
      *
-     * @param AnnotationReader $reader The AnnotationReader to use.
+     * @param AbstractSchemaManager $schemaManager
      */
     public function __construct(AbstractSchemaManager $schemaManager)
     {
@@ -94,12 +92,12 @@ class DatabaseDriver implements Driver
     public function setTables($entityTables, $manyToManyTables)
     {
         $this->tables = $this->manyToManyTables = $this->classToTableNames = array();
-        foreach ($entityTables AS $table) {
+        foreach ($entityTables as $table) {
             $className = $this->getClassNameForTable($table->getName());
             $this->classToTableNames[$className] = $table->getName();
             $this->tables[$table->getName()] = $table;
         }
-        foreach ($manyToManyTables AS $table) {
+        foreach ($manyToManyTables as $table) {
             $this->manyToManyTables[$table->getName()] = $table;
         }
     }
@@ -117,8 +115,8 @@ class DatabaseDriver implements Driver
         }
 
         $this->tables = $this->manyToManyTables = $this->classToTableNames = array();
-        foreach ($tables AS $tableName => $table) {
-            /* @var $table Table */
+        foreach ($tables as $tableName => $table) {
+            /* @var $table \Doctrine\DBAL\Schema\Table */
             if ($this->_sm->getDatabasePlatform()->supportsForeignKeyConstraints()) {
                 $foreignKeys = $table->getForeignKeys();
             } else {
@@ -126,7 +124,7 @@ class DatabaseDriver implements Driver
             }
 
             $allForeignKeyColumns = array();
-            foreach ($foreignKeys AS $foreignKey) {
+            foreach ($foreignKeys as $foreignKey) {
                 $allForeignKeyColumns = array_merge($allForeignKeyColumns, $foreignKey->getLocalColumns());
             }
 
@@ -154,9 +152,9 @@ class DatabaseDriver implements Driver
     }
 
     /**
-     * {@inheritdoc}
+     * {@inheritDoc}
      */
-    public function loadMetadataForClass($className, ClassMetadataInfo $metadata)
+    public function loadMetadataForClass($className, ClassMetadata $metadata)
     {
         $this->reverseEngineerMappingFromDatabase();
 
@@ -184,7 +182,7 @@ class DatabaseDriver implements Driver
         }
 
         $allForeignKeyColumns = array();
-        foreach ($foreignKeys AS $foreignKey) {
+        foreach ($foreignKeys as $foreignKey) {
             $allForeignKeyColumns = array_merge($allForeignKeyColumns, $foreignKey->getLocalColumns());
         }
 
@@ -192,13 +190,13 @@ class DatabaseDriver implements Driver
         $fieldMappings = array();
         foreach ($columns as $column) {
             $fieldMapping = array();
-            
+
             if (in_array($column->getName(), $allForeignKeyColumns)) {
                 continue;
             } else if ($primaryKeyColumns && in_array($column->getName(), $primaryKeyColumns)) {
                 $fieldMapping['id'] = true;
             }
-            
+
             $fieldMapping['fieldName'] = $this->getFieldNameForColumn($tableName, $column->getName(), false);
             $fieldMapping['columnName'] = $column->getName();
             $fieldMapping['type'] = strtolower((string) $column->getType());
@@ -219,7 +217,8 @@ class DatabaseDriver implements Driver
         }
 
         if ($ids) {
-            if (count($ids) == 1) {
+            // We need to check for the columns here, because we might have associations as id as well.
+            if (count($primaryKeyColumns) == 1) {
                 $metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
             }
 
@@ -232,13 +231,13 @@ class DatabaseDriver implements Driver
             $metadata->mapField($fieldMapping);
         }
 
-        foreach ($this->manyToManyTables AS $manyTable) {
-            foreach ($manyTable->getForeignKeys() AS $foreignKey) {
+        foreach ($this->manyToManyTables as $manyTable) {
+            foreach ($manyTable->getForeignKeys() as $foreignKey) {
                 // foreign  key maps to the table of the current entity, many to many association probably exists
                 if (strtolower($tableName) == strtolower($foreignKey->getForeignTableName())) {
                     $myFk = $foreignKey;
                     $otherFk = null;
-                    foreach ($manyTable->getForeignKeys() AS $foreignKey) {
+                    foreach ($manyTable->getForeignKeys() as $foreignKey) {
                         if ($foreignKey != $myFk) {
                             $otherFk = $foreignKey;
                             break;
@@ -299,6 +298,10 @@ class DatabaseDriver implements Driver
             $associationMapping['fieldName'] = $this->getFieldNameForColumn($tableName, $localColumn, true);
             $associationMapping['targetEntity'] = $this->getClassNameForTable($foreignTable);
 
+            if (isset($metadata->fieldMappings[$associationMapping['fieldName']])) {
+                $associationMapping['fieldName'] = $associationMapping['fieldName'] . "2";
+            }
+
             if ($primaryKeyColumns && in_array($localColumn, $primaryKeyColumns)) {
                 $associationMapping['id'] = true;
             }
@@ -309,7 +312,7 @@ class DatabaseDriver implements Driver
                     'referencedColumnName' => $fkCols[$i],
                 );
             }
-            
+
             //Here we need to check if $cols are the same as $primaryKeyColums
             if (!array_diff($cols,$primaryKeyColumns)) {
                 $metadata->mapOneToOne($associationMapping);
@@ -320,7 +323,7 @@ class DatabaseDriver implements Driver
     }
 
     /**
-     * {@inheritdoc}
+     * {@inheritDoc}
      */
     public function isTransient($className)
     {
@@ -328,11 +331,7 @@ class DatabaseDriver implements Driver
     }
 
     /**
-     * Return all the class names supported by this driver.
-     *
-     * IMPORTANT: This method must return an array of class not tables names.
-     *
-     * @return array
+     * {@inheritDoc}
      */
     public function getAllClassNames()
     {

lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -39,6 +39,7 @@ require_once __DIR__.'/../UniqueConstraint.php';
 require_once __DIR__.'/../Index.php';
 require_once __DIR__.'/../JoinTable.php';
 require_once __DIR__.'/../SequenceGenerator.php';
+require_once __DIR__.'/../CustomIdGenerator.php';
 require_once __DIR__.'/../ChangeTrackingPolicy.php';
 require_once __DIR__.'/../OrderBy.php';
 require_once __DIR__.'/../NamedQueries.php';
@@ -52,3 +53,14 @@ require_once __DIR__.'/../PreRemove.php';
 require_once __DIR__.'/../PostRemove.php';
 require_once __DIR__.'/../PostLoad.php';
 require_once __DIR__.'/../PreFlush.php';
+require_once __DIR__.'/../FieldResult.php';
+require_once __DIR__.'/../ColumnResult.php';
+require_once __DIR__.'/../EntityResult.php';
+require_once __DIR__.'/../NamedNativeQuery.php';
+require_once __DIR__.'/../NamedNativeQueries.php';
+require_once __DIR__.'/../SqlResultSetMapping.php';
+require_once __DIR__.'/../SqlResultSetMappings.php';
+require_once __DIR__.'/../AssociationOverride.php';
+require_once __DIR__.'/../AssociationOverrides.php';
+require_once __DIR__.'/../AttributeOverride.php';
+require_once __DIR__.'/../AttributeOverrides.php';

lib/Doctrine/ORM/Mapping/Driver/DriverChain.php

@@ -13,114 +13,19 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Mapping\Driver;
 
-use Doctrine\ORM\Mapping\Driver\Driver,
-    Doctrine\ORM\Mapping\ClassMetadataInfo,
-    Doctrine\ORM\Mapping\MappingException;
+use Doctrine\Common\Persistence\Mapping\Driver\MappingDriverChain;
 
 /**
- * The DriverChain allows you to add multiple other mapping drivers for
- * certain namespaces
+ * {@inheritDoc}
  *
- * @since 2.0
- * @author Benjamin Eberlei <kontakt@beberlei.de>
- * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
- * @author Jonathan H. Wage <jonwage@gmail.com>
- * @author Roman Borschel <roman@code-factory.org>
- * @todo Rename: MappingDriverChain or MetadataDriverChain
+ * @deprecated this driver will be removed. Use Doctrine\Common\Persistence\Mapping\Driver\MappingDriverChain instead
  */
-class DriverChain implements Driver
+class DriverChain extends MappingDriverChain
 {
-    /**
-     * @var array
-     */
-    private $_drivers = array();
-
-    /**
-     * Add a nested driver.
-     *
-     * @param Driver $nestedDriver
-     * @param string $namespace
-     */
-    public function addDriver(Driver $nestedDriver, $namespace)
-    {
-        $this->_drivers[$namespace] = $nestedDriver;
-    }
-
-    /**
-     * Get the array of nested drivers.
-     *
-     * @return array $drivers
-     */
-    public function getDrivers()
-    {
-        return $this->_drivers;
-    }
-
-    /**
-     * Loads the metadata for the specified class into the provided container.
-     *
-     * @param string $className
-     * @param ClassMetadataInfo $metadata
-     */
-    public function loadMetadataForClass($className, ClassMetadataInfo $metadata)
-    {
-        foreach ($this->_drivers as $namespace => $driver) {
-            if (strpos($className, $namespace) === 0) {
-                $driver->loadMetadataForClass($className, $metadata);
-                return;
-            }
-        }
-
-        throw MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
-    }
-
-    /**
-     * Gets the names of all mapped classes known to this driver.
-     *
-     * @return array The names of all mapped classes known to this driver.
-     */
-    public function getAllClassNames()
-    {
-        $classNames = array();
-        $driverClasses = array();
-        foreach ($this->_drivers AS $namespace => $driver) {
-            $oid = spl_object_hash($driver);
-            if (!isset($driverClasses[$oid])) {
-                $driverClasses[$oid] = $driver->getAllClassNames();
-            }
-
-            foreach ($driverClasses[$oid] AS $className) {
-                if (strpos($className, $namespace) === 0) {
-                    $classNames[$className] = true;
-                }
-            }
-        }
-        return array_keys($classNames);
-    }
-
-    /**
-     * Whether the class with the specified name should have its metadata loaded.
-     *
-     * This is only the case for non-transient classes either mapped as an Entity or MappedSuperclass.
-     *
-     * @param string $className
-     * @return boolean
-     */
-    public function isTransient($className)
-    {
-        foreach ($this->_drivers AS $namespace => $driver) {
-            if (strpos($className, $namespace) === 0) {
-                return $driver->isTransient($className);
-            }
-        }
-
-        // class isTransient, i.e. not an entity or mapped superclass
-        return true;
-    }
 }

lib/Doctrine/ORM/Mapping/Driver/PHPDriver.php

@@ -13,57 +13,19 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Mapping\Driver;
 
-use Doctrine\Common\Cache\ArrayCache,
-    Doctrine\Common\Annotations\AnnotationReader,
-    Doctrine\DBAL\Schema\AbstractSchemaManager,
-    Doctrine\ORM\Mapping\ClassMetadataInfo,
-    Doctrine\ORM\Mapping\MappingException,
-    Doctrine\Common\Util\Inflector,
-    Doctrine\ORM\Mapping\Driver\AbstractFileDriver;
+use Doctrine\Common\Persistence\Mapping\Driver\PHPDriver as CommonPHPDriver;
 
 /**
- * The PHPDriver includes php files which just populate ClassMetadataInfo
- * instances with plain php code
+ * {@inheritDoc}
  *
- * @license 	http://www.opensource.org/licenses/lgpl-license.php LGPL
- * @link    	www.doctrine-project.org
- * @since   	2.0
- * @version     $Revision$
- * @author		Benjamin Eberlei <kontakt@beberlei.de>
- * @author		Guilherme Blanco <guilhermeblanco@hotmail.com>
- * @author      Jonathan H. Wage <jonwage@gmail.com>
- * @author      Roman Borschel <roman@code-factory.org>
- * @todo Rename: PHPDriver
+ * @deprecated this driver will be removed. Use Doctrine\Common\Persistence\Mapping\Driver\PHPDriver instead
  */
-class PHPDriver extends AbstractFileDriver
+class PHPDriver extends CommonPHPDriver
 {
-    /**
-     * {@inheritdoc}
-     */
-    protected $_fileExtension = '.php';
-    protected $_metadata;
-
-    /**
-     * {@inheritdoc}
-     */
-    public function loadMetadataForClass($className, ClassMetadataInfo $metadata)
-    {
-        $this->_metadata = $metadata;
-        $this->_loadMappingFile($this->_findMappingFile($className));
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function _loadMappingFile($file)
-    {
-        $metadata = $this->_metadata;
-        include $file;
-    }
 }

lib/Doctrine/ORM/Mapping/Driver/SimplifiedXmlDriver.php

@@ -13,13 +13,13 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
 */
 
 namespace Doctrine\ORM\Mapping\Driver;
 
-use Doctrine\ORM\Mapping\MappingException;
+use Doctrine\Common\Persistence\Mapping\Driver\SymfonyFileLocator;
 
 /**
  * XmlDriver that additionally looks for mapping information in a global file.
@@ -30,147 +30,14 @@ use Doctrine\ORM\Mapping\MappingException;
  */
 class SimplifiedXmlDriver extends XmlDriver
 {
-    protected $_prefixes = array();
-    protected $_globalBasename;
-    protected $_classCache;
-    protected $_fileExtension = '.orm.xml';
+    const DEFAULT_FILE_EXTENSION = '.orm.xml';
 
-    public function __construct($prefixes)
+    /**
+     * {@inheritDoc}
+     */
+    public function __construct($prefixes, $fileExtension = self::DEFAULT_FILE_EXTENSION)
     {
-        $this->addNamespacePrefixes($prefixes);
-    }
-
-    public function setGlobalBasename($file)
-    {
-        $this->_globalBasename = $file;
-    }
-
-    public function getGlobalBasename()
-    {
-        return $this->_globalBasename;
-    }
-
-    public function addNamespacePrefixes($prefixes)
-    {
-        $this->_prefixes = array_merge($this->_prefixes, $prefixes);
-        $this->addPaths(array_flip($prefixes));
-    }
-
-    public function getNamespacePrefixes()
-    {
-        return $this->_prefixes;
-    }
-
-    public function isTransient($className)
-    {
-        if (null === $this->_classCache) {
-            $this->initialize();
-        }
-
-        // The mapping is defined in the global mapping file
-        if (isset($this->_classCache[$className])) {
-            return false;
-        }
-
-        try {
-            $this->_findMappingFile($className);
-
-            return false;
-        } catch (MappingException $e) {
-            return true;
-        }
-    }
-
-    public function getAllClassNames()
-    {
-        if (null === $this->_classCache) {
-            $this->initialize();
-        }
-
-        $classes = array();
-
-        if ($this->_paths) {
-            foreach ((array) $this->_paths as $path) {
-                if (!is_dir($path)) {
-                    throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
-                }
-
-                $iterator = new \RecursiveIteratorIterator(
-                    new \RecursiveDirectoryIterator($path),
-                    \RecursiveIteratorIterator::LEAVES_ONLY
-                );
-
-                foreach ($iterator as $file) {
-                    $fileName = $file->getBasename($this->_fileExtension);
-
-                    if ($fileName == $file->getBasename() || $fileName == $this->_globalBasename) {
-                        continue;
-                    }
-
-                    // NOTE: All files found here means classes are not transient!
-                    if (isset($this->_prefixes[$path])) {
-                        $classes[] = $this->_prefixes[$path].'\\'.str_replace('.', '\\', $fileName);
-                    } else {
-                        $classes[] = str_replace('.', '\\', $fileName);
-                    }
-                }
-            }
-        }
-
-        return array_merge($classes, array_keys($this->_classCache));
-    }
-
-    public function getElement($className)
-    {
-        if (null === $this->_classCache) {
-            $this->initialize();
-        }
-
-        if (!isset($this->_classCache[$className])) {
-            $this->_classCache[$className] = parent::getElement($className);
-        }
-
-        return $this->_classCache[$className];
-    }
-
-    protected function initialize()
-    {
-        $this->_classCache = array();
-        if (null !== $this->_globalBasename) {
-            foreach ($this->_paths as $path) {
-                if (is_file($file = $path.'/'.$this->_globalBasename.$this->_fileExtension)) {
-                    $this->_classCache = array_merge($this->_classCache, $this->_loadMappingFile($file));
-                }
-            }
-        }
-    }
-
-    protected function _findMappingFile($className)
-    {
-        $defaultFileName = str_replace('\\', '.', $className).$this->_fileExtension;
-        foreach ($this->_paths as $path) {
-            if (!isset($this->_prefixes[$path])) {
-                if (is_file($path.DIRECTORY_SEPARATOR.$defaultFileName)) {
-                    return $path.DIRECTORY_SEPARATOR.$defaultFileName;
-                }
-
-                continue;
-            }
-
-            $prefix = $this->_prefixes[$path];
-
-            if (0 !== strpos($className, $prefix.'\\')) {
-                continue;
-            }
-
-            $filename = $path.'/'.strtr(substr($className, strlen($prefix)+1), '\\', '.').$this->_fileExtension;
-            if (is_file($filename)) {
-                return $filename;
-            }
-
-            throw MappingException::mappingFileNotFound($className, $filename);
-        }
-
-        throw MappingException::mappingFileNotFound($className, substr($className, strrpos($className, '\\') + 1).$this->_fileExtension);
+        $locator = new SymfonyFileLocator((array) $prefixes, $fileExtension);
+        parent::__construct($locator, $fileExtension);
     }
 }

lib/Doctrine/ORM/Mapping/Driver/SimplifiedYamlDriver.php

@@ -13,13 +13,13 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
 */
 
 namespace Doctrine\ORM\Mapping\Driver;
 
-use Doctrine\ORM\Mapping\MappingException;
+use Doctrine\Common\Persistence\Mapping\Driver\SymfonyFileLocator;
 
 /**
  * YamlDriver that additionally looks for mapping information in a global file.
@@ -30,152 +30,14 @@ use Doctrine\ORM\Mapping\MappingException;
  */
 class SimplifiedYamlDriver extends YamlDriver
 {
-    protected $_prefixes = array();
-    protected $_globalBasename;
-    protected $_classCache;
-    protected $_fileExtension = '.orm.yml';
+    const DEFAULT_FILE_EXTENSION = '.orm.yml';
 
-    public function __construct($prefixes)
+    /**
+     * {@inheritDoc}
+     */
+    public function __construct($prefixes, $fileExtension = self::DEFAULT_FILE_EXTENSION)
     {
-        $this->addNamespacePrefixes($prefixes);
-    }
-
-    public function setGlobalBasename($file)
-    {
-        $this->_globalBasename = $file;
-    }
-
-    public function getGlobalBasename()
-    {
-        return $this->_globalBasename;
-    }
-
-    public function addNamespacePrefixes($prefixes)
-    {
-        $this->_prefixes = array_merge($this->_prefixes, $prefixes);
-        $this->addPaths(array_flip($prefixes));
-    }
-
-    public function addNamespacePrefix($prefix, $path)
-    {
-        $this->_prefixes[$path] = $prefix;
-    }
-
-    public function getNamespacePrefixes()
-    {
-        return $this->_prefixes;
-    }
-
-    public function isTransient($className)
-    {
-        if (null === $this->_classCache) {
-            $this->initialize();
-        }
-
-        // The mapping is defined in the global mapping file
-        if (isset($this->_classCache[$className])) {
-            return false;
-        }
-
-        try {
-            $this->_findMappingFile($className);
-
-            return false;
-        } catch (MappingException $e) {
-            return true;
-        }
-    }
-
-    public function getAllClassNames()
-    {
-        if (null === $this->_classCache) {
-            $this->initialize();
-        }
-
-        $classes = array();
-
-        if ($this->_paths) {
-            foreach ((array) $this->_paths as $path) {
-                if (!is_dir($path)) {
-                    throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
-                }
-
-                $iterator = new \RecursiveIteratorIterator(
-                    new \RecursiveDirectoryIterator($path),
-                    \RecursiveIteratorIterator::LEAVES_ONLY
-                );
-
-                foreach ($iterator as $file) {
-                    $fileName = $file->getBasename($this->_fileExtension);
-
-                    if ($fileName == $file->getBasename() || $fileName == $this->_globalBasename) {
-                        continue;
-                    }
-
-                    // NOTE: All files found here means classes are not transient!
-                    if (isset($this->_prefixes[$path])) {
-                        $classes[] = $this->_prefixes[$path].'\\'.str_replace('.', '\\', $fileName);
-                    } else {
-                        $classes[] = str_replace('.', '\\', $fileName);
-                    }
-                }
-            }
-        }
-
-        return array_merge($classes, array_keys($this->_classCache));
-    }
-
-    public function getElement($className)
-    {
-        if (null === $this->_classCache) {
-            $this->initialize();
-        }
-
-        if (!isset($this->_classCache[$className])) {
-            $this->_classCache[$className] = parent::getElement($className);
-        }
-
-        return $this->_classCache[$className];
-    }
-
-    protected function initialize()
-    {
-        $this->_classCache = array();
-        if (null !== $this->_globalBasename) {
-            foreach ($this->_paths as $path) {
-                if (is_file($file = $path.'/'.$this->_globalBasename.$this->_fileExtension)) {
-                    $this->_classCache = array_merge($this->_classCache, $this->_loadMappingFile($file));
-                }
-            }
-        }
-    }
-
-    protected function _findMappingFile($className)
-    {
-        $defaultFileName = str_replace('\\', '.', $className).$this->_fileExtension;
-        foreach ($this->_paths as $path) {
-            if (!isset($this->_prefixes[$path])) {
-                if (is_file($path.DIRECTORY_SEPARATOR.$defaultFileName)) {
-                    return $path.DIRECTORY_SEPARATOR.$defaultFileName;
-                }
-
-                continue;
-            }
-
-            $prefix = $this->_prefixes[$path];
-
-            if (0 !== strpos($className, $prefix.'\\')) {
-                continue;
-            }
-
-            $filename = $path.'/'.strtr(substr($className, strlen($prefix)+1), '\\', '.').$this->_fileExtension;
-            if (is_file($filename)) {
-                return $filename;
-            }
-
-            throw MappingException::mappingFileNotFound($className, $filename);
-        }
-
-        throw MappingException::mappingFileNotFound($className, substr($className, strrpos($className, '\\') + 1).$this->_fileExtension);
+        $locator = new SymfonyFileLocator((array) $prefixes, $fileExtension);
+        parent::__construct($locator, $fileExtension);
     }
 }

lib/Doctrine/ORM/Mapping/Driver/StaticPHPDriver.php

@@ -13,126 +13,19 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Mapping\Driver;
 
-use Doctrine\ORM\Mapping\ClassMetadataInfo,
- Doctrine\ORM\Mapping\MappingException;
+use Doctrine\Common\Persistence\Mapping\Driver\StaticPHPDriver as CommonStaticPHPDriver;
 
 /**
- * The StaticPHPDriver calls a static loadMetadata() method on your entity
- * classes where you can manually populate the ClassMetadata instance.
+ * {@inheritDoc}
  *
- * @license 	http://www.opensource.org/licenses/lgpl-license.php LGPL
- * @link    	www.doctrine-project.org
- * @since   	2.0
- * @author      Benjamin Eberlei <kontakt@beberlei.de>
- * @author      Guilherme Blanco <guilhermeblanco@hotmail.com>
- * @author      Jonathan H. Wage <jonwage@gmail.com>
- * @author      Roman Borschel <roman@code-factory.org>
+ * @deprecated this driver will be removed. Use Doctrine\Common\Persistence\Mapping\Driver\StaticPHPDriver instead
  */
-class StaticPHPDriver implements Driver
+class StaticPHPDriver extends CommonStaticPHPDriver
 {
-    /**
-     * Paths of entity directories.
-     *
-     * @var array
-     */
-    private $_paths = array();
-
-    /**
-     * Map of all class names.
-     *
-     * @var array
-     */
-    private $_classNames;
-
-    /**
-     * The file extension of mapping documents.
-     *
-     * @var string
-     */
-    private $_fileExtension = '.php';
-
-    public function __construct($paths)
-    {
-        $this->addPaths((array) $paths);
-    }
-
-    public function addPaths(array $paths)
-    {
-        $this->_paths = array_unique(array_merge($this->_paths, $paths));
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function loadMetadataForClass($className, ClassMetadataInfo $metadata)
-    {
-        call_user_func_array(array($className, 'loadMetadata'), array($metadata));
-    }
-
-    /**
-     * {@inheritDoc}
-     * @todo Same code exists in AnnotationDriver, should we re-use it somehow or not worry about it?
-     */
-    public function getAllClassNames()
-    {
-        if ($this->_classNames !== null) {
-            return $this->_classNames;
-        }
-
-        if (!$this->_paths) {
-            throw MappingException::pathRequired();
-        }
-
-        $classes = array();
-        $includedFiles = array();
-
-        foreach ($this->_paths as $path) {
-            if (!is_dir($path)) {
-                throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
-            }
-
-            $iterator = new \RecursiveIteratorIterator(
-                            new \RecursiveDirectoryIterator($path),
-                            \RecursiveIteratorIterator::LEAVES_ONLY
-            );
-
-            foreach ($iterator as $file) {
-                if (($fileName = $file->getBasename($this->_fileExtension)) == $file->getBasename()) {
-                    continue;
-                }
-
-                $sourceFile = realpath($file->getPathName());
-                require_once $sourceFile;
-                $includedFiles[] = $sourceFile;
-            }
-        }
-
-        $declared = get_declared_classes();
-
-        foreach ($declared as $className) {
-            $rc = new \ReflectionClass($className);
-            $sourceFile = $rc->getFileName();
-            if (in_array($sourceFile, $includedFiles) && !$this->isTransient($className)) {
-                $classes[] = $className;
-            }
-        }
-
-        $this->_classNames = $classes;
-
-        return $classes;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function isTransient($className)
-    {
-        return method_exists($className, 'loadMetadata') ? false : true;
-    }
-}
+}

lib/Doctrine/ORM/Mapping/Driver/XmlDriver.php

@@ -1,7 +1,5 @@
 <?php
 /*
- *  $Id$
- *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -15,14 +13,15 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Mapping\Driver;
 
 use SimpleXMLElement,
-    Doctrine\ORM\Mapping\ClassMetadataInfo,
+    Doctrine\Common\Persistence\Mapping\Driver\FileDriver,
+    Doctrine\Common\Persistence\Mapping\ClassMetadata,
     Doctrine\ORM\Mapping\MappingException;
 
 /**
@@ -31,31 +30,37 @@ use SimpleXMLElement,
  * @license 	http://www.opensource.org/licenses/lgpl-license.php LGPL
  * @link    	www.doctrine-project.org
  * @since   	2.0
- * @version     $Revision$
  * @author		Benjamin Eberlei <kontakt@beberlei.de>
  * @author		Guilherme Blanco <guilhermeblanco@hotmail.com>
  * @author      Jonathan H. Wage <jonwage@gmail.com>
  * @author      Roman Borschel <roman@code-factory.org>
  */
-class XmlDriver extends AbstractFileDriver
+class XmlDriver extends FileDriver
 {
-    /**
-     * {@inheritdoc}
-     */
-    protected $_fileExtension = '.dcm.xml';
+    const DEFAULT_FILE_EXTENSION = '.dcm.xml';
 
     /**
-     * {@inheritdoc}
+     * {@inheritDoc}
      */
-    public function loadMetadataForClass($className, ClassMetadataInfo $metadata)
+    public function __construct($locator, $fileExtension = self::DEFAULT_FILE_EXTENSION)
     {
+        parent::__construct($locator, $fileExtension);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function loadMetadataForClass($className, ClassMetadata $metadata)
+    {
+        /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadataInfo */
+        /* @var $xmlRoot SimpleXMLElement */
         $xmlRoot = $this->getElement($className);
 
         if ($xmlRoot->getName() == 'entity') {
             if (isset($xmlRoot['repository-class'])) {
                 $metadata->setCustomRepositoryClass((string)$xmlRoot['repository-class']);
             }
-            if (isset($xmlRoot['read-only']) && $xmlRoot['read-only'] == "true") {
+            if (isset($xmlRoot['read-only']) && $this->evaluateBoolean($xmlRoot['read-only'])) {
                 $metadata->markReadOnly();
             }
         } else if ($xmlRoot->getName() == 'mapped-superclass') {
@@ -76,7 +81,7 @@ class XmlDriver extends AbstractFileDriver
         $metadata->setPrimaryTable($table);
 
         // Evaluate named queries
-        if (isset($xmlRoot['named-queries'])) {
+        if (isset($xmlRoot->{'named-queries'})) {
             foreach ($xmlRoot->{'named-queries'}->{'named-query'} as $namedQueryElement) {
                 $metadata->addNamedQuery(array(
                     'name'  => (string)$namedQueryElement['name'],
@@ -85,6 +90,58 @@ class XmlDriver extends AbstractFileDriver
             }
         }
 
+        // Evaluate native named queries
+        if (isset($xmlRoot->{'named-native-queries'})) {
+            foreach ($xmlRoot->{'named-native-queries'}->{'named-native-query'} as $nativeQueryElement) {
+                $metadata->addNamedNativeQuery(array(
+                    'name'              => isset($nativeQueryElement['name']) ? (string)$nativeQueryElement['name'] : null,
+                    'query'             => isset($nativeQueryElement->query) ? (string)$nativeQueryElement->query : null,
+                    'resultClass'       => isset($nativeQueryElement['result-class']) ? (string)$nativeQueryElement['result-class'] : null,
+                    'resultSetMapping'  => isset($nativeQueryElement['result-set-mapping']) ? (string)$nativeQueryElement['result-set-mapping'] : null,
+                ));
+            }
+        }
+
+        // Evaluate sql result set mapping
+        if (isset($xmlRoot->{'sql-result-set-mappings'})) {
+            foreach ($xmlRoot->{'sql-result-set-mappings'}->{'sql-result-set-mapping'} as $rsmElement) {
+                $entities   = array();
+                $columns    = array();
+                foreach ($rsmElement as $entityElement) {
+                    //<entity-result/>
+                    if (isset($entityElement['entity-class'])) {
+                        $entityResult = array(
+                            'fields'                => array(),
+                            'entityClass'           => (string)$entityElement['entity-class'],
+                            'discriminatorColumn'   => isset($entityElement['discriminator-column']) ? (string)$entityElement['discriminator-column'] : null,
+                        );
+
+                        foreach ($entityElement as $fieldElement) {
+                            $entityResult['fields'][] = array(
+                                'name'      => isset($fieldElement['name']) ? (string)$fieldElement['name'] : null,
+                                'column'    => isset($fieldElement['column']) ? (string)$fieldElement['column'] : null,
+                            );
+                        }
+
+                        $entities[] = $entityResult;
+                    }
+
+                    //<column-result/>
+                    if (isset($entityElement['name'])) {
+                        $columns[] = array(
+                            'name' => (string)$entityElement['name'],
+                        );
+                    }
+                }
+
+                $metadata->addSqlResultSetMapping(array(
+                    'name'          => (string)$rsmElement['name'],
+                    'entities'      => $entities,
+                    'columns'       => $columns
+                ));
+            }
+        }
+
         /* not implemented specially anyway. use table = schema.table
         if (isset($xmlRoot['schema'])) {
             $metadata->table['schema'] = (string)$xmlRoot['schema'];
@@ -99,9 +156,10 @@ class XmlDriver extends AbstractFileDriver
                 if (isset($xmlRoot->{'discriminator-column'})) {
                     $discrColumn = $xmlRoot->{'discriminator-column'};
                     $metadata->setDiscriminatorColumn(array(
-                        'name' => (string)$discrColumn['name'],
-                        'type' => (string)$discrColumn['type'],
-                        'length' => (string)$discrColumn['length']
+                        'name' => isset($discrColumn['name']) ? (string)$discrColumn['name'] : null,
+                        'type' => isset($discrColumn['type']) ? (string)$discrColumn['type'] : null,
+                        'length' => isset($discrColumn['length']) ? (string)$discrColumn['length'] : null,
+                        'columnDefinition' => isset($discrColumn['column-definition']) ? (string)$discrColumn['column-definition'] : null
                     ));
                 } else {
                     $metadata->setDiscriminatorColumn(array('name' => 'dtype', 'type' => 'string', 'length' => 255));
@@ -110,7 +168,7 @@ class XmlDriver extends AbstractFileDriver
                 // Evaluate <discriminator-map...>
                 if (isset($xmlRoot->{'discriminator-map'})) {
                     $map = array();
-                    foreach ($xmlRoot->{'discriminator-map'}->{'discriminator-mapping'} AS $discrMapElement) {
+                    foreach ($xmlRoot->{'discriminator-map'}->{'discriminator-mapping'} as $discrMapElement) {
                         $map[(string)$discrMapElement['value']] = (string)$discrMapElement['class'];
                     }
                     $metadata->setDiscriminatorMap($map);
@@ -161,61 +219,39 @@ class XmlDriver extends AbstractFileDriver
             }
         }
 
+        if (isset($xmlRoot->options)) {
+            $metadata->table['options'] = $this->_parseOptions($xmlRoot->options->children());
+        }
+
+        // The mapping assignement is done in 2 times as a bug might occurs on some php/xml lib versions
+        // The internal SimpleXmlIterator get resetted, to this generate a duplicate field exception
+        $mappings = array();
         // Evaluate <field ...> mappings
         if (isset($xmlRoot->field)) {
             foreach ($xmlRoot->field as $fieldMapping) {
-                $mapping = array(
-                    'fieldName' => (string)$fieldMapping['name'],
-                );
+                $mapping = $this->columnToArray($fieldMapping);
 
-                if (isset($fieldMapping['type'])) {
-                    $mapping['type'] = (string)$fieldMapping['type'];
-                }
-
-                if (isset($fieldMapping['column'])) {
-                    $mapping['columnName'] = (string)$fieldMapping['column'];
-                }
-
-                if (isset($fieldMapping['length'])) {
-                    $mapping['length'] = (int)$fieldMapping['length'];
-                }
-
-                if (isset($fieldMapping['precision'])) {
-                    $mapping['precision'] = (int)$fieldMapping['precision'];
-                }
-
-                if (isset($fieldMapping['scale'])) {
-                    $mapping['scale'] = (int)$fieldMapping['scale'];
-                }
-
-                if (isset($fieldMapping['unique'])) {
-                    $mapping['unique'] = ((string)$fieldMapping['unique'] == "false") ? false : true;
-                }
-
-                if (isset($fieldMapping['options'])) {
-                    $mapping['options'] = (array)$fieldMapping['options'];
-                }
-
-                if (isset($fieldMapping['nullable'])) {
-                    $mapping['nullable'] = ((string)$fieldMapping['nullable'] == "false") ? false : true;
-                }
-
-                if (isset($fieldMapping['version']) && $fieldMapping['version']) {
+                if (isset($mapping['version'])) {
                     $metadata->setVersionMapping($mapping);
-                }
-
-                if (isset($fieldMapping['column-definition'])) {
-                    $mapping['columnDefinition'] = (string)$fieldMapping['column-definition'];
+                    unset($mapping['version']);
                 }
 
                 $metadata->mapField($mapping);
             }
         }
 
+        foreach ($mappings as $mapping) {
+            if (isset($mapping['version'])) {
+                $metadata->setVersionMapping($mapping);
+            }
+
+            $metadata->mapField($mapping);
+        }
+
         // Evaluate <id ...> mappings
         $associationIds = array();
         foreach ($xmlRoot->id as $idElement) {
-            if ((bool)$idElement['association-key'] == true) {
+            if (isset($idElement['association-key']) && $this->evaluateBoolean($idElement['association-key'])) {
                 $associationIds[(string)$idElement['name']] = true;
                 continue;
             }
@@ -229,6 +265,10 @@ class XmlDriver extends AbstractFileDriver
                 $mapping['type'] = (string)$idElement['type'];
             }
 
+            if (isset($idElement['length'])) {
+                $mapping['length'] = (string)$idElement['length'];
+            }
+
             if (isset($idElement['column'])) {
                 $mapping['columnName'] = (string)$idElement['column'];
             }
@@ -254,6 +294,11 @@ class XmlDriver extends AbstractFileDriver
                     'allocationSize' => (string)$seqGenerator['allocation-size'],
                     'initialValue' => (string)$seqGenerator['initial-value']
                 ));
+            } else if (isset($idElement->{'custom-id-generator'})) {
+                $customGenerator = $idElement->{'custom-id-generator'};
+                $metadata->setCustomGeneratorDefinition(array(
+                    'class' => (string) $customGenerator['class']
+                ));
             } else if (isset($idElement->{'table-generator'})) {
                 throw MappingException::tableIdGeneratorNotImplemented($className);
             }
@@ -284,10 +329,10 @@ class XmlDriver extends AbstractFileDriver
                     $joinColumns = array();
 
                     if (isset($oneToOneElement->{'join-column'})) {
-                        $joinColumns[] = $this->_getJoinColumnMapping($oneToOneElement->{'join-column'});
+                        $joinColumns[] = $this->joinColumnToArray($oneToOneElement->{'join-column'});
                     } else if (isset($oneToOneElement->{'join-columns'})) {
                         foreach ($oneToOneElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
-                            $joinColumns[] = $this->_getJoinColumnMapping($joinColumnElement);
+                            $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
                         }
                     }
 
@@ -299,7 +344,7 @@ class XmlDriver extends AbstractFileDriver
                 }
 
                 if (isset($oneToOneElement['orphan-removal'])) {
-                    $mapping['orphanRemoval'] = (bool)$oneToOneElement['orphan-removal'];
+                    $mapping['orphanRemoval'] = $this->evaluateBoolean($oneToOneElement['orphan-removal']);
                 }
 
                 $metadata->mapOneToOne($mapping);
@@ -324,12 +369,12 @@ class XmlDriver extends AbstractFileDriver
                 }
 
                 if (isset($oneToManyElement['orphan-removal'])) {
-                    $mapping['orphanRemoval'] = (bool)$oneToManyElement['orphan-removal'];
+                    $mapping['orphanRemoval'] = $this->evaluateBoolean($oneToManyElement['orphan-removal']);
                 }
 
                 if (isset($oneToManyElement->{'order-by'})) {
                     $orderBy = array();
-                    foreach ($oneToManyElement->{'order-by'}->{'order-by-field'} AS $orderByField) {
+                    foreach ($oneToManyElement->{'order-by'}->{'order-by-field'} as $orderByField) {
                         $orderBy[(string)$orderByField['name']] = (string)$orderByField['direction'];
                     }
                     $mapping['orderBy'] = $orderBy;
@@ -368,10 +413,10 @@ class XmlDriver extends AbstractFileDriver
                 $joinColumns = array();
 
                 if (isset($manyToOneElement->{'join-column'})) {
-                    $joinColumns[] = $this->_getJoinColumnMapping($manyToOneElement->{'join-column'});
+                    $joinColumns[] = $this->joinColumnToArray($manyToOneElement->{'join-column'});
                 } else if (isset($manyToOneElement->{'join-columns'})) {
                     foreach ($manyToOneElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
-                        $joinColumns[] = $this->_getJoinColumnMapping($joinColumnElement);
+                        $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
                     }
                 }
 
@@ -398,7 +443,7 @@ class XmlDriver extends AbstractFileDriver
                 }
 
                 if (isset($manyToManyElement['orphan-removal'])) {
-                    $mapping['orphanRemoval'] = (bool)$manyToManyElement['orphan-removal'];
+                    $mapping['orphanRemoval'] = $this->evaluateBoolean($manyToManyElement['orphan-removal']);
                 }
 
                 if (isset($manyToManyElement['mapped-by'])) {
@@ -418,11 +463,11 @@ class XmlDriver extends AbstractFileDriver
                     }
 
                     foreach ($joinTableElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
-                        $joinTable['joinColumns'][] = $this->_getJoinColumnMapping($joinColumnElement);
+                        $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
                     }
 
                     foreach ($joinTableElement->{'inverse-join-columns'}->{'join-column'} as $joinColumnElement) {
-                        $joinTable['inverseJoinColumns'][] = $this->_getJoinColumnMapping($joinColumnElement);
+                        $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
                     }
 
                     $mapping['joinTable'] = $joinTable;
@@ -434,7 +479,7 @@ class XmlDriver extends AbstractFileDriver
 
                 if (isset($manyToManyElement->{'order-by'})) {
                     $orderBy = array();
-                    foreach ($manyToManyElement->{'order-by'}->{'order-by-field'} AS $orderByField) {
+                    foreach ($manyToManyElement->{'order-by'}->{'order-by-field'} as $orderByField) {
                         $orderBy[(string)$orderByField['name']] = (string)$orderByField['direction'];
                     }
                     $mapping['orderBy'] = $orderBy;
@@ -450,6 +495,62 @@ class XmlDriver extends AbstractFileDriver
             }
         }
 
+        // Evaluate association-overrides
+        if (isset($xmlRoot->{'attribute-overrides'})) {
+            foreach ($xmlRoot->{'attribute-overrides'}->{'attribute-override'} as $overrideElement) {
+                $fieldName = (string) $overrideElement['name'];
+                foreach ($overrideElement->field as $field) {
+                    $mapping = $this->columnToArray($field);
+                    $mapping['fieldName'] = $fieldName;
+                    $metadata->setAttributeOverride($fieldName, $mapping);
+                }
+            }
+        }
+
+        // Evaluate association-overrides
+        if (isset($xmlRoot->{'association-overrides'})) {
+            foreach ($xmlRoot->{'association-overrides'}->{'association-override'} as $overrideElement) {
+                $fieldName  = (string) $overrideElement['name'];
+                $override   = array();
+
+                // Check for join-columns
+                if (isset($overrideElement->{'join-columns'})) {
+                    $joinColumns = array();
+                    foreach ($overrideElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
+                        $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
+                    }
+                    $override['joinColumns'] = $joinColumns;
+                }
+
+                // Check for join-table
+                if ($overrideElement->{'join-table'}) {
+                    $joinTable          = null;
+                    $joinTableElement   = $overrideElement->{'join-table'};
+
+                    $joinTable = array(
+                        'name'      => (string) $joinTableElement['name'],
+                        'schema'    => (string) $joinTableElement['schema']
+                    );
+
+                    if (isset($joinTableElement->{'join-columns'})) {
+                        foreach ($joinTableElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
+                            $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
+                        }
+                    }
+
+                    if (isset($joinTableElement->{'inverse-join-columns'})) {
+                        foreach ($joinTableElement->{'inverse-join-columns'}->{'join-column'} as $joinColumnElement) {
+                            $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
+                        }
+                    }
+
+                    $override['joinTable'] = $joinTable;
+                }
+
+                $metadata->setAssociationOverride($fieldName, $override);
+            }
+        }
+
         // Evaluate <lifecycle-callbacks...>
         if (isset($xmlRoot->{'lifecycle-callbacks'})) {
             foreach ($xmlRoot->{'lifecycle-callbacks'}->{'lifecycle-callback'} as $lifecycleCallback) {
@@ -458,14 +559,44 @@ class XmlDriver extends AbstractFileDriver
         }
     }
 
+    /**
+     * Parses (nested) option elements.
+     *
+     * @param SimpleXMLElement $options the XML element.
+     * @return array The options array.
+     */
+    private function _parseOptions(SimpleXMLElement $options)
+    {
+        $array = array();
+
+        /* @var $option SimpleXMLElement */
+        foreach ($options as $option) {
+            if ($option->count()) {
+                $value = $this->_parseOptions($option->children());
+            } else {
+                $value = (string) $option;
+            }
+
+            $attr = $option->attributes();
+
+            if (isset($attr->name)) {
+                $array[(string) $attr->name] = $value;
+            } else {
+                $array[] = $value;
+            }
+        }
+
+        return $array;
+    }
+
     /**
      * Constructs a joinColumn mapping array based on the information
      * found in the given SimpleXMLElement.
      *
-     * @param $joinColumnElement The XML element.
+     * @param SimpleXMLElement $joinColumnElement the XML element.
      * @return array The mapping array.
      */
-    private function _getJoinColumnMapping(SimpleXMLElement $joinColumnElement)
+    private function joinColumnToArray(SimpleXMLElement $joinColumnElement)
     {
         $joinColumn = array(
             'name' => (string)$joinColumnElement['name'],
@@ -473,11 +604,11 @@ class XmlDriver extends AbstractFileDriver
         );
 
         if (isset($joinColumnElement['unique'])) {
-            $joinColumn['unique'] = ((string)$joinColumnElement['unique'] == "false") ? false : true;
+            $joinColumn['unique'] = $this->evaluateBoolean($joinColumnElement['unique']);
         }
 
         if (isset($joinColumnElement['nullable'])) {
-            $joinColumn['nullable'] = ((string)$joinColumnElement['nullable'] == "false") ? false : true;
+            $joinColumn['nullable'] = $this->evaluateBoolean($joinColumnElement['nullable']);
         }
 
         if (isset($joinColumnElement['on-delete'])) {
@@ -491,15 +622,71 @@ class XmlDriver extends AbstractFileDriver
         return $joinColumn;
     }
 
+     /**
+     * Parse the given field as array
+     *
+     * @param   SimpleXMLElement   $fieldMapping
+     * @return  array
+     */
+    private function columnToArray(SimpleXMLElement $fieldMapping)
+    {
+        $mapping = array(
+            'fieldName' => (string) $fieldMapping['name'],
+        );
+
+        if (isset($fieldMapping['type'])) {
+            $mapping['type'] = (string) $fieldMapping['type'];
+        }
+
+        if (isset($fieldMapping['column'])) {
+            $mapping['columnName'] = (string) $fieldMapping['column'];
+        }
+
+        if (isset($fieldMapping['length'])) {
+            $mapping['length'] = (int) $fieldMapping['length'];
+        }
+
+        if (isset($fieldMapping['precision'])) {
+            $mapping['precision'] = (int) $fieldMapping['precision'];
+        }
+
+        if (isset($fieldMapping['scale'])) {
+            $mapping['scale'] = (int) $fieldMapping['scale'];
+        }
+
+        if (isset($fieldMapping['unique'])) {
+            $mapping['unique'] = $this->evaluateBoolean($fieldMapping['unique']);
+        }
+
+        if (isset($fieldMapping['nullable'])) {
+            $mapping['nullable'] = $this->evaluateBoolean($fieldMapping['nullable']);
+        }
+
+        if (isset($fieldMapping['version']) && $fieldMapping['version']) {
+            $mapping['version'] = $this->evaluateBoolean($fieldMapping['version']);
+        }
+
+        if (isset($fieldMapping['column-definition'])) {
+            $mapping['columnDefinition'] = (string) $fieldMapping['column-definition'];
+        }
+
+        if (isset($fieldMapping->options)) {
+            $mapping['options'] = $this->_parseOptions($fieldMapping->options->children());
+        }
+
+        return $mapping;
+    }
+
     /**
      * Gathers a list of cascade options found in the given cascade element.
      *
-     * @param $cascadeElement The cascade element.
+     * @param SimpleXMLElement $cascadeElement the cascade element.
      * @return array The list of cascade options.
      */
     private function _getCascadeMappings($cascadeElement)
     {
         $cascades = array();
+        /* @var $action SimpleXmlElement */
         foreach ($cascadeElement->children() as $action) {
             // According to the JPA specifications, XML uses "cascade-persist"
             // instead of "persist". Here, both variations
@@ -512,9 +699,9 @@ class XmlDriver extends AbstractFileDriver
     }
 
     /**
-     * {@inheritdoc}
+     * {@inheritDoc}
      */
-    protected function _loadMappingFile($file)
+    protected function loadMappingFile($file)
     {
         $result = array();
         $xmlElement = simplexml_load_file($file);
@@ -533,4 +720,12 @@ class XmlDriver extends AbstractFileDriver
 
         return $result;
     }
+
+    protected function evaluateBoolean($element)
+    {
+        $flag = (string)$element;
+
+        return ($flag === true || $flag == "true" || $flag == "1");
+    }
 }
+

lib/Doctrine/ORM/Mapping/Driver/YamlDriver.php

@@ -13,14 +13,16 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
 namespace Doctrine\ORM\Mapping\Driver;
 
-use Doctrine\ORM\Mapping\ClassMetadataInfo,
-    Doctrine\ORM\Mapping\MappingException;
+use Doctrine\Common\Persistence\Mapping\ClassMetadata,
+    Doctrine\Common\Persistence\Mapping\Driver\FileDriver,
+    Doctrine\ORM\Mapping\MappingException,
+    Symfony\Component\Yaml\Yaml;
 
 /**
  * The YamlDriver reads the mapping metadata from yaml schema files.
@@ -31,18 +33,24 @@ use Doctrine\ORM\Mapping\ClassMetadataInfo,
  * @author Jonathan H. Wage <jonwage@gmail.com>
  * @author Roman Borschel <roman@code-factory.org>
  */
-class YamlDriver extends AbstractFileDriver
+class YamlDriver extends FileDriver
 {
-    /**
-     * {@inheritdoc}
-     */
-    protected $_fileExtension = '.dcm.yml';
+    const DEFAULT_FILE_EXTENSION = '.dcm.yml';
 
     /**
-     * {@inheritdoc}
+     * {@inheritDoc}
      */
-    public function loadMetadataForClass($className, ClassMetadataInfo $metadata)
+    public function __construct($locator, $fileExtension = self::DEFAULT_FILE_EXTENSION)
     {
+        parent::__construct($locator, $fileExtension);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function loadMetadataForClass($className, ClassMetadata $metadata)
+    {
+        /* @var $metadata \Doctrine\ORM\Mapping\ClassMetadataInfo */
         $element = $this->getElement($className);
 
         if ($element['type'] == 'entity') {
@@ -83,6 +91,68 @@ class YamlDriver extends AbstractFileDriver
             }
         }
 
+        // Evaluate named native queries
+        if (isset($element['namedNativeQueries'])) {
+            foreach ($element['namedNativeQueries'] as $name => $mappingElement) {
+                if (!isset($mappingElement['name'])) {
+                    $mappingElement['name'] = $name;
+                }
+                $metadata->addNamedNativeQuery(array(
+                    'name'              => $mappingElement['name'],
+                    'query'             => isset($mappingElement['query']) ? $mappingElement['query'] : null,
+                    'resultClass'       => isset($mappingElement['resultClass']) ? $mappingElement['resultClass'] : null,
+                    'resultSetMapping'  => isset($mappingElement['resultSetMapping']) ? $mappingElement['resultSetMapping'] : null,
+                ));
+            }
+        }
+
+        // Evaluate sql result set mappings
+        if (isset($element['sqlResultSetMappings'])) {
+            foreach ($element['sqlResultSetMappings'] as $name => $resultSetMapping) {
+                if (!isset($resultSetMapping['name'])) {
+                    $resultSetMapping['name'] = $name;
+                }
+
+                $entities = array();
+                $columns  = array();
+                if (isset($resultSetMapping['entityResult'])) {
+                    foreach ($resultSetMapping['entityResult'] as $entityResultElement) {
+                        $entityResult = array(
+                            'fields'                => array(),
+                            'entityClass'           => isset($entityResultElement['entityClass']) ? $entityResultElement['entityClass'] : null,
+                            'discriminatorColumn'   => isset($entityResultElement['discriminatorColumn']) ? $entityResultElement['discriminatorColumn'] : null,
+                        );
+
+                        if (isset($entityResultElement['fieldResult'])) {
+                            foreach ($entityResultElement['fieldResult'] as $fieldResultElement) {
+                                $entityResult['fields'][] = array(
+                                    'name'      => isset($fieldResultElement['name']) ? $fieldResultElement['name'] : null,
+                                    'column'    => isset($fieldResultElement['column']) ? $fieldResultElement['column'] : null,
+                                );
+                            }
+                        }
+
+                        $entities[] = $entityResult;
+                    }
+                }
+
+
+                if (isset($resultSetMapping['columnResult'])) {
+                    foreach ($resultSetMapping['columnResult'] as $columnResultAnnot) {
+                        $columns[] = array(
+                            'name' => isset($columnResultAnnot['name']) ? $columnResultAnnot['name'] : null,
+                        );
+                    }
+                }
+
+                $metadata->addSqlResultSetMapping(array(
+                    'name'          => $resultSetMapping['name'],
+                    'entities'      => $entities,
+                    'columns'       => $columns
+                ));
+            }
+        }
+
         /* not implemented specially anyway. use table = schema.table
         if (isset($element['schema'])) {
             $metadata->table['schema'] = $element['schema'];
@@ -96,9 +166,10 @@ class YamlDriver extends AbstractFileDriver
                 if (isset($element['discriminatorColumn'])) {
                     $discrColumn = $element['discriminatorColumn'];
                     $metadata->setDiscriminatorColumn(array(
-                        'name' => $discrColumn['name'],
-                        'type' => $discrColumn['type'],
-                        'length' => $discrColumn['length']
+                        'name' => isset($discrColumn['name']) ? (string)$discrColumn['name'] : null,
+                        'type' => isset($discrColumn['type']) ? (string)$discrColumn['type'] : null,
+                        'length' => isset($discrColumn['length']) ? (string)$discrColumn['length'] : null,
+                        'columnDefinition' => isset($discrColumn['columnDefinition']) ? (string)$discrColumn['columnDefinition'] : null
                     ));
                 } else {
                     $metadata->setDiscriminatorColumn(array('name' => 'dtype', 'type' => 'string', 'length' => 255));
@@ -127,6 +198,7 @@ class YamlDriver extends AbstractFileDriver
 
                 if (is_string($index['columns'])) {
                     $columns = explode(',', $index['columns']);
+                    $columns = array_map('trim', $columns);
                 } else {
                     $columns = $index['columns'];
                 }
@@ -146,6 +218,7 @@ class YamlDriver extends AbstractFileDriver
 
                 if (is_string($unique['columns'])) {
                     $columns = explode(',', $unique['columns']);
+                    $columns = array_map('trim', $columns);
                 } else {
                     $columns = $unique['columns'];
                 }
@@ -156,6 +229,10 @@ class YamlDriver extends AbstractFileDriver
             }
         }
 
+        if (isset($element['options'])) {
+            $metadata->table['options'] = $element['options'];
+        }
+
         $associationIds = array();
         if (isset($element['id'])) {
             // Evaluate identifier settings
@@ -195,6 +272,11 @@ class YamlDriver extends AbstractFileDriver
                 // Check for SequenceGenerator/TableGenerator definition
                 if (isset($idElement['sequenceGenerator'])) {
                     $metadata->setSequenceGeneratorDefinition($idElement['sequenceGenerator']);
+                } else if (isset($idElement['customIdGenerator'])) {
+                    $customGenerator = $idElement['customIdGenerator'];
+                    $metadata->setCustomGeneratorDefinition(array(
+                        'class' => (string) $customGenerator['class']
+                    ));
                 } else if (isset($idElement['tableGenerator'])) {
                     throw MappingException::tableIdGeneratorNotImplemented($className);
                 }
@@ -205,19 +287,7 @@ class YamlDriver extends AbstractFileDriver
         if (isset($element['fields'])) {
             foreach ($element['fields'] as $name => $fieldMapping) {
 
-                $mapping = array(
-                    'fieldName' => $name
-                );
-
-                if (isset($fieldMapping['type'])) {
-                    $e = explode('(', $fieldMapping['type']);
-                    $fieldMapping['type'] = $e[0];
-                    $mapping['type']      = $fieldMapping['type'];
-
-                    if (isset($e[1])) {
-                        $fieldMapping['length'] = substr($e[1], 0, strlen($e[1]) - 1);
-                    }
-                }
+                $mapping = $this->columnToArray($name, $fieldMapping);
 
                 if (isset($fieldMapping['id'])) {
                     $mapping['id'] = true;
@@ -226,32 +296,10 @@ class YamlDriver extends AbstractFileDriver
                                 . strtoupper($fieldMapping['generator']['strategy'])));
                     }
                 }
-                if (isset($fieldMapping['column'])) {
-                    $mapping['columnName'] = $fieldMapping['column'];
-                }
-                if (isset($fieldMapping['length'])) {
-                    $mapping['length'] = $fieldMapping['length'];
-                }
-                if (isset($fieldMapping['precision'])) {
-                    $mapping['precision'] = $fieldMapping['precision'];
-                }
-                if (isset($fieldMapping['scale'])) {
-                    $mapping['scale'] = $fieldMapping['scale'];
-                }
-                if (isset($fieldMapping['unique'])) {
-                    $mapping['unique'] = (bool)$fieldMapping['unique'];
-                }
-                if (isset($fieldMapping['options'])) {
-                    $mapping['options'] = $fieldMapping['options'];
-                }
-                if (isset($fieldMapping['nullable'])) {
-                    $mapping['nullable'] = $fieldMapping['nullable'];
-                }
-                if (isset($fieldMapping['version']) && $fieldMapping['version']) {
+
+                if (isset($mapping['version'])) {
                     $metadata->setVersionMapping($mapping);
-                }
-                if (isset($fieldMapping['columnDefinition'])) {
-                    $mapping['columnDefinition'] = $fieldMapping['columnDefinition'];
+                    unset($mapping['version']);
                 }
 
                 $metadata->mapField($mapping);
@@ -284,14 +332,14 @@ class YamlDriver extends AbstractFileDriver
                     $joinColumns = array();
 
                     if (isset($oneToOneElement['joinColumn'])) {
-                        $joinColumns[] = $this->_getJoinColumnMapping($oneToOneElement['joinColumn']);
+                        $joinColumns[] = $this->joinColumnToArray($oneToOneElement['joinColumn']);
                     } else if (isset($oneToOneElement['joinColumns'])) {
-                        foreach ($oneToOneElement['joinColumns'] as $name => $joinColumnElement) {
-                            if (!isset($joinColumnElement['name'])) {
-                                $joinColumnElement['name'] = $name;
+                        foreach ($oneToOneElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
+                            if ( ! isset($joinColumnElement['name'])) {
+                                $joinColumnElement['name'] = $joinColumnName;
                             }
 
-                            $joinColumns[] = $this->_getJoinColumnMapping($joinColumnElement);
+                            $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
                         }
                     }
 
@@ -366,14 +414,14 @@ class YamlDriver extends AbstractFileDriver
                 $joinColumns = array();
 
                 if (isset($manyToOneElement['joinColumn'])) {
-                    $joinColumns[] = $this->_getJoinColumnMapping($manyToOneElement['joinColumn']);
+                    $joinColumns[] = $this->joinColumnToArray($manyToOneElement['joinColumn']);
                 } else if (isset($manyToOneElement['joinColumns'])) {
-                    foreach ($manyToOneElement['joinColumns'] as $name => $joinColumnElement) {
-                        if (!isset($joinColumnElement['name'])) {
-                            $joinColumnElement['name'] = $name;
+                    foreach ($manyToOneElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
+                        if ( ! isset($joinColumnElement['name'])) {
+                            $joinColumnElement['name'] = $joinColumnName;
                         }
 
-                        $joinColumns[] = $this->_getJoinColumnMapping($joinColumnElement);
+                        $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
                     }
                 }
 
@@ -412,20 +460,20 @@ class YamlDriver extends AbstractFileDriver
                         $joinTable['schema'] = $joinTableElement['schema'];
                     }
 
-                    foreach ($joinTableElement['joinColumns'] as $name => $joinColumnElement) {
-                        if (!isset($joinColumnElement['name'])) {
-                            $joinColumnElement['name'] = $name;
+                    foreach ($joinTableElement['joinColumns'] as $joinColumnName => $joinColumnElement) {
+                        if ( ! isset($joinColumnElement['name'])) {
+                            $joinColumnElement['name'] = $joinColumnName;
                         }
 
-                        $joinTable['joinColumns'][] = $this->_getJoinColumnMapping($joinColumnElement);
+                        $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
                     }
 
-                    foreach ($joinTableElement['inverseJoinColumns'] as $name => $joinColumnElement) {
-                        if (!isset($joinColumnElement['name'])) {
-                            $joinColumnElement['name'] = $name;
+                    foreach ($joinTableElement['inverseJoinColumns'] as $joinColumnName => $joinColumnElement) {
+                        if ( ! isset($joinColumnElement['name'])) {
+                            $joinColumnElement['name'] = $joinColumnName;
                         }
 
-                        $joinTable['inverseJoinColumns'][] = $this->_getJoinColumnMapping($joinColumnElement);
+                        $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
                     }
 
                     $mapping['joinTable'] = $joinTable;
@@ -455,6 +503,68 @@ class YamlDriver extends AbstractFileDriver
             }
         }
 
+        // Evaluate associationOverride
+        if (isset($element['associationOverride']) && is_array($element['associationOverride'])) {
+
+            foreach ($element['associationOverride'] as $fieldName => $associationOverrideElement) {
+                $override   = array();
+
+                // Check for joinColumn
+                if (isset($associationOverrideElement['joinColumn'])) {
+                    $joinColumns = array();
+                    foreach ($associationOverrideElement['joinColumn'] as $name => $joinColumnElement) {
+                        if ( ! isset($joinColumnElement['name'])) {
+                            $joinColumnElement['name'] = $name;
+                        }
+                        $joinColumns[] = $this->joinColumnToArray($joinColumnElement);
+                    }
+                    $override['joinColumns'] = $joinColumns;
+                }
+
+                // Check for joinTable
+                if (isset($associationOverrideElement['joinTable'])) {
+
+                    $joinTableElement   = $associationOverrideElement['joinTable'];
+                    $joinTable          =  array(
+                        'name' => $joinTableElement['name']
+                    );
+
+                    if (isset($joinTableElement['schema'])) {
+                        $joinTable['schema'] = $joinTableElement['schema'];
+                    }
+
+                    foreach ($joinTableElement['joinColumns'] as $name => $joinColumnElement) {
+                        if ( ! isset($joinColumnElement['name'])) {
+                            $joinColumnElement['name'] = $name;
+                        }
+
+                        $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumnElement);
+                    }
+
+                    foreach ($joinTableElement['inverseJoinColumns'] as $name => $joinColumnElement) {
+                        if ( ! isset($joinColumnElement['name'])) {
+                            $joinColumnElement['name'] = $name;
+                        }
+
+                        $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumnElement);
+                    }
+
+                    $override['joinTable'] = $joinTable;
+                }
+
+                $metadata->setAssociationOverride($fieldName, $override);
+            }
+        }
+
+        // Evaluate associationOverride
+        if (isset($element['attributeOverride']) && is_array($element['attributeOverride'])) {
+
+            foreach ($element['attributeOverride'] as $fieldName => $attributeOverrideElement) {
+                $mapping = $this->columnToArray($fieldName, $attributeOverrideElement);
+                $metadata->setAttributeOverride($fieldName, $mapping);
+            }
+        }
+
         // Evaluate lifeCycleCallbacks
         if (isset($element['lifecycleCallbacks'])) {
             foreach ($element['lifecycleCallbacks'] as $type => $methods) {
@@ -469,15 +579,19 @@ class YamlDriver extends AbstractFileDriver
      * Constructs a joinColumn mapping array based on the information
      * found in the given join column element.
      *
-     * @param $joinColumnElement The array join column element
+     * @param array $joinColumnElement The array join column element
      * @return array The mapping array.
      */
-    private function _getJoinColumnMapping($joinColumnElement)
+    private function joinColumnToArray($joinColumnElement)
     {
-        $joinColumn = array(
-            'name' => $joinColumnElement['name'],
-            'referencedColumnName' => $joinColumnElement['referencedColumnName']
-        );
+        $joinColumn = array();
+        if (isset($joinColumnElement['referencedColumnName'])) {
+            $joinColumn['referencedColumnName'] = (string) $joinColumnElement['referencedColumnName'];
+        }
+
+        if (isset($joinColumnElement['name'])) {
+            $joinColumn['name'] = (string) $joinColumnElement['name'];
+        }
 
         if (isset($joinColumnElement['fieldName'])) {
             $joinColumn['fieldName'] = (string) $joinColumnElement['fieldName'];
@@ -503,10 +617,72 @@ class YamlDriver extends AbstractFileDriver
     }
 
     /**
-     * {@inheritdoc}
+     * Parse the given column as array
+     *
+     * @param   string  $fieldName
+     * @param   array   $column
+     * @return  array
      */
-    protected function _loadMappingFile($file)
+    private function columnToArray($fieldName, $column)
     {
-        return \Symfony\Component\Yaml\Yaml::parse($file);
+        $mapping = array(
+            'fieldName' => $fieldName
+        );
+
+        if (isset($column['type'])) {
+            $params = explode('(', $column['type']);
+            $column['type']  = $params[0];
+            $mapping['type'] = $column['type'];
+
+            if (isset($params[1])) {
+                $column['length'] = (integer) substr($params[1], 0, strlen($params[1]) - 1);
+            }
+        }
+
+        if (isset($column['column'])) {
+            $mapping['columnName'] = $column['column'];
+        }
+
+        if (isset($column['length'])) {
+            $mapping['length'] = $column['length'];
+        }
+
+        if (isset($column['precision'])) {
+            $mapping['precision'] = $column['precision'];
+        }
+
+        if (isset($column['scale'])) {
+            $mapping['scale'] = $column['scale'];
+        }
+
+        if (isset($column['unique'])) {
+            $mapping['unique'] = (bool)$column['unique'];
+        }
+
+        if (isset($column['options'])) {
+            $mapping['options'] = $column['options'];
+        }
+
+        if (isset($column['nullable'])) {
+            $mapping['nullable'] = $column['nullable'];
+        }
+
+        if (isset($column['version']) && $column['version']) {
+            $mapping['version'] = $column['version'];
+        }
+
+        if (isset($column['columnDefinition'])) {
+            $mapping['columnDefinition'] = $column['columnDefinition'];
+        }
+
+        return $mapping;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function loadMappingFile($file)
+    {
+        return Yaml::parse($file);
     }
 }

lib/Doctrine/ORM/Mapping/ElementCollection.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/Entity.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/EntityResult.php

@@ -0,0 +1,58 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * References an entity in the SELECT clause of a SQL query.
+ * If this annotation is used, the SQL statement should select all of the columns that are mapped to the entity object.
+ * This should include foreign key columns to related entities.
+ * The results obtained when insufficient data is available are undefined.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("ANNOTATION")
+ */
+final class EntityResult implements Annotation
+{
+
+    /**
+     * The class of the result
+     *
+     * @var string
+     */
+    public $entityClass;
+
+    /**
+     * Maps the columns specified in the SELECT list of the query to the properties or fields of the entity class.
+     *
+     * @var array<\Doctrine\ORM\Mapping\FieldResult>
+     */
+    public $fields = array();
+
+    /**
+     * Specifies the column name of the column in the SELECT list that is used to determine the type of the entity instance.
+     *
+     * @var string
+     */
+    public $discriminatorColumn;
+
+}

lib/Doctrine/ORM/Mapping/FieldResult.php

@@ -0,0 +1,48 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * Is used to map the columns specified in the SELECT list of the query to the properties or fields of the entity class.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("ANNOTATION")
+ */
+final class FieldResult implements Annotation
+{
+
+    /**
+     * Name of the column in the SELECT clause.
+     *
+     * @var string
+     */
+    public $name;
+
+    /**
+     *  Name of the persistent field or property of the class.
+     *
+     * @var string
+     */
+    public $column;
+
+}

lib/Doctrine/ORM/Mapping/GeneratedValue.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/HasLifecycleCallbacks.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/Id.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/Index.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/InheritanceType.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/JoinColumn.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/JoinColumns.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/JoinTable.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
@@ -21,7 +21,7 @@ namespace Doctrine\ORM\Mapping;
 
 /**
  * @Annotation
- * @Target("PROPERTY")
+ * @Target({"PROPERTY","ANNOTATION"})
  */
 final class JoinTable implements Annotation
 {

lib/Doctrine/ORM/Mapping/ManyToMany.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/ManyToOne.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/MappedSuperclass.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/MappingException.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.phpdoctrine.org>.
  */
 
@@ -34,8 +34,18 @@ class MappingException extends \Doctrine\ORM\ORMException
 
     public static function identifierRequired($entityName)
     {
-        return new self("No identifier/primary key specified for Entity '$entityName'."
-                . " Every Entity must have an identifier/primary key.");
+        if (false !== ($parent = get_parent_class($entityName))) {
+            return new self(sprintf(
+                'No identifier/primary key specified for Entity "%s" sub class of "%s". Every Entity must have an identifier/primary key.',
+                $entityName, $parent
+            ));
+        }
+
+        return new self(sprintf(
+            'No identifier/primary key specified for Entity "%s". Every Entity must have an identifier/primary key.',
+            $entityName
+        ));
+
     }
 
     public static function invalidInheritanceType($entityName, $type)
@@ -68,9 +78,26 @@ class MappingException extends \Doctrine\ORM\ORMException
         return new self("No mapping file found named '$fileName' for class '$entityName'.");
     }
 
-    public static function invalidMappingFile($entityName, $fileName)
+     /**
+     * Exception for invalid property name override.
+     *
+     * @param string $className The entity's name
+     * @param string $fieldName
+     */
+    public static function invalidOverrideFieldName($className, $fieldName)
     {
-        return new self("Invalid mapping file '$fileName' for class '$entityName'.");
+        return new self("Invalid field override named '$fieldName' for class '$className'.");
+    }
+
+    /**
+     * Exception for invalid property type override.
+     *
+     * @param string $className The entity's name
+     * @param string $fieldName
+     */
+    public static function invalidOverrideFieldType($className, $fieldName)
+    {
+        return new self("The column type of attribute '$fieldName' on class '$className' could not be changed.");
     }
 
     public static function mappingNotFound($className, $fieldName)
@@ -83,6 +110,41 @@ class MappingException extends \Doctrine\ORM\ORMException
         return new self("No query found named '$queryName' on class '$className'.");
     }
 
+    public static function resultMappingNotFound($className, $resultName)
+    {
+        return new self("No result set mapping found named '$resultName' on class '$className'.");
+    }
+
+    public static function emptyQueryMapping($entity, $queryName)
+    {
+        return new self('Query named "'.$queryName.'" in "'.$entity.'" could not be empty.');
+    }
+
+    public static function nameIsMandatoryForQueryMapping($className)
+    {
+        return new self("Query name on entity class '$className' is not defined.");
+    }
+
+    public static function missingQueryMapping($entity, $queryName)
+    {
+        return new self('Query named "'.$queryName.'" in "'.$entity.' requires a result class or result set mapping.');
+    }
+
+    public static function missingResultSetMappingEntity($entity, $resultName)
+    {
+        return new self('Result set mapping named "'.$resultName.'" in "'.$entity.' requires a entity class name.');
+    }
+
+    public static function missingResultSetMappingFieldName($entity, $resultName)
+    {
+        return new self('Result set mapping named "'.$resultName.'" in "'.$entity.' requires a field name.');
+    }
+
+    public static function nameIsMandatoryForSqlResultSetMapping($className)
+    {
+        return new self("Result set mapping name on entity class '$className' is not defined.");
+    }
+
     public static function oneToManyRequiresMappedBy($fieldName)
     {
         return new self("OneToMany mapping on field '$fieldName' requires the 'mappedBy' attribute.");
@@ -144,7 +206,17 @@ class MappingException extends \Doctrine\ORM\ORMException
 
     public static function classIsNotAValidEntityOrMappedSuperClass($className)
     {
-        return new self('Class '.$className.' is not a valid entity or mapped super class.');
+        if (false !== ($parent = get_parent_class($className))) {
+            return new self(sprintf(
+                'Class "%s" sub class of "%s" is not a valid entity or mapped super class.',
+                $className, $parent
+            ));
+        }
+
+        return new self(sprintf(
+            'Class "%s" is not a valid entity or mapped super class.',
+            $className
+        ));
     }
 
     public static function propertyTypeIsRequired($className, $propertyName)
@@ -158,27 +230,36 @@ class MappingException extends \Doctrine\ORM\ORMException
     }
 
     /**
-     *
      * @param string $entity The entity's name
      * @param string $fieldName The name of the field that was already declared
      */
-    public static function duplicateFieldMapping($entity, $fieldName) {
+    public static function duplicateFieldMapping($entity, $fieldName)
+    {
         return new self('Property "'.$fieldName.'" in "'.$entity.'" was already declared, but it must be declared only once');
     }
 
-    public static function duplicateAssociationMapping($entity, $fieldName) {
+    public static function duplicateAssociationMapping($entity, $fieldName)
+    {
         return new self('Property "'.$fieldName.'" in "'.$entity.'" was already declared, but it must be declared only once');
     }
 
-    public static function duplicateQueryMapping($entity, $queryName) {
+    public static function duplicateQueryMapping($entity, $queryName)
+    {
         return new self('Query named "'.$queryName.'" in "'.$entity.'" was already declared, but it must be declared only once');
     }
 
-    public static function singleIdNotAllowedOnCompositePrimaryKey($entity) {
+    public static function duplicateResultSetMapping($entity, $resultName)
+    {
+        return new self('Result set mapping named "'.$resultName.'" in "'.$entity.'" was already declared, but it must be declared only once');
+    }
+
+    public static function singleIdNotAllowedOnCompositePrimaryKey($entity)
+    {
         return new self('Single id is not allowed on composite primary key in entity '.$entity);
     }
 
-    public static function unsupportedOptimisticLockingType($entity, $fieldName, $unsupportedType) {
+    public static function unsupportedOptimisticLockingType($entity, $fieldName, $unsupportedType)
+    {
         return new self('Locking type "'.$unsupportedType.'" (specified in "'.$entity.'", field "'.$fieldName.'") '
                         .'is not supported by Doctrine.'
         );
@@ -204,13 +285,25 @@ class MappingException extends \Doctrine\ORM\ORMException
      * @param string $owningClass The class that declares the discriminator map.
      * @return self
      */
-    public static function invalidClassInDiscriminatorMap($className, $owningClass) {
+    public static function invalidClassInDiscriminatorMap($className, $owningClass)
+    {
         return new self(
             "Entity class '$className' used in the discriminator map of class '$owningClass' ".
             "does not exist."
         );
     }
 
+    public static function duplicateDiscriminatorEntry($className, array $entries, array $map)
+    {
+        return new self(
+            "The entries " . implode(', ',  $entries) . " in discriminator map of class '" . $className . "' is duplicated. " .
+            "If the discriminator map is automatically generated you have to convert it to an explicit discriminator map now. " .
+            "The entries of the current map are: @DiscriminatorMap({" . implode(', ', array_map(
+                function($a, $b) { return "'$a': '$b'"; }, array_keys($map), array_values($map)
+            )) . "})"
+        );
+    }
+
     public static function missingDiscriminatorMap($className)
     {
         return new self("Entity class '$className' is using inheritance but no discriminator map was defined.");
@@ -226,6 +319,11 @@ class MappingException extends \Doctrine\ORM\ORMException
         return new self("Discriminator column type on entity class '$className' is not allowed to be '$type'. 'string' or 'integer' type variables are suggested!");
     }
 
+    public static function nameIsMandatoryForDiscriminatorColumns($className)
+    {
+        return new self("Discriminator column name on entity class '$className' is not defined.");
+    }
+
     public static function cannotVersionIdField($className, $fieldName)
     {
         return new self("Setting Id field '$fieldName' as versionale in entity class '$className' is not supported.");
@@ -329,4 +427,27 @@ class MappingException extends \Doctrine\ORM\ORMException
     {
         return new self("The target-entity " . $targetEntity . " cannot be found in '" . $sourceEntity."#".$associationName."'.");
     }
+
+    public static function invalidCascadeOption(array $cascades, $className, $propertyName)
+    {
+        $cascades = implode(", ", array_map(function ($e) { return "'" . $e . "'"; }, $cascades));
+        return new self(sprintf(
+            "You have specified invalid cascade options for %s::$%s: %s; available options: 'remove', 'persist', 'refresh', 'merge', and 'detach'",
+            $className,
+            $propertyName,
+            $cascades
+        ));
+    }
+
+    /**
+     * @param string $className
+     *
+     * @return MappingException
+     */
+    public static function missingSequenceName($className)
+    {
+        return new self(
+            sprintf('Missing "sequenceName" attribute for sequence id generator definition on class "%s".', $className)
+        );
+    }
 }

lib/Doctrine/ORM/Mapping/NamedNativeQueries.php

@@ -0,0 +1,40 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * Is used to specify an array of native SQL named queries.
+ * The NamedNativeQueries annotation can be applied to an entity or mapped superclass.
+ *
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ * 
+ * @Annotation
+ * @Target("CLASS")
+ */
+final class NamedNativeQueries implements Annotation
+{
+    /**
+     * One or more NamedNativeQuery annotations.
+     *
+     * @var array<\Doctrine\ORM\Mapping\NamedNativeQuery>
+     */
+    public $value = array();
+}

lib/Doctrine/ORM/Mapping/NamedNativeQuery.php

@@ -1,7 +1,5 @@
 <?php
 /*
- *  $Id$
- *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -15,45 +13,51 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 
-namespace Doctrine\ORM\Mapping\Driver;
-
-use Doctrine\ORM\Mapping\ClassMetadataInfo;
+namespace Doctrine\ORM\Mapping;
 
 /**
- * Contract for metadata drivers.
+ * Is used to specify a native SQL named query.
+ * The NamedNativeQuery annotation can be applied to an entity or mapped superclass.
  *
- * @since 2.0
- * @author Jonathan H. Wage <jonwage@gmail.com>
- * @todo Rename: MetadataDriver or MappingDriver
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ * @since   2.3
+ *
+ * @Annotation
+ * @Target("ANNOTATION")
  */
-interface Driver
+final class NamedNativeQuery implements Annotation
 {
-    /**
-     * Loads the metadata for the specified class into the provided container.
-     *
-     * @param string $className
-     * @param ClassMetadataInfo $metadata
-     */
-    function loadMetadataForClass($className, ClassMetadataInfo $metadata);
 
     /**
-     * Gets the names of all mapped classes known to this driver.
+     * The name used to refer to the query with the EntityManager methods that create query objects.
      *
-     * @return array The names of all mapped classes known to this driver.
+     * @var string
      */
-    function getAllClassNames();
+    public $name;
 
     /**
-     * Whether the class with the specified name should have its metadata loaded.
-     * This is only the case if it is either mapped as an Entity or a
-     * MappedSuperclass.
+     * The SQL query string.
      *
-     * @param string $className
-     * @return boolean
+     * @var string 
      */
-    function isTransient($className);
-}
+    public $query;
+
+    /**
+     * The class of the result.
+     *
+     * @var string
+     */
+    public $resultClass;
+
+    /**
+     * The name of a SqlResultSetMapping, as defined in metadata.
+     * 
+     * @var string
+     */
+    public $resultSetMapping;
+
+}

lib/Doctrine/ORM/Mapping/NamedQueries.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/NamedQuery.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/NamingStrategy.php

@@ -0,0 +1,82 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * A set of rules for determining the physical column and table names
+ *
+ * 
+ * @link    www.doctrine-project.org
+ * @since   2.3
+ * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface NamingStrategy
+{
+    /**
+     * Return a table name for an entity class
+     *
+     * @param string $className The fully-qualified class name
+     * @return string A table name
+     */
+    function classToTableName($className);
+
+    /**
+     * Return a column name for a property
+     *
+     * @param string $propertyName A property
+     * @return string A column name
+     */
+    function propertyToColumnName($propertyName);
+
+    /**
+     * Return the default reference column name
+     *
+     * @return string A column name
+     */
+    function referenceColumnName();
+
+    /**
+     * Return a join column name for a property
+     *
+     * @param string $propertyName A property
+     * @return string A join column name
+     */
+    function joinColumnName($propertyName);
+
+    /**
+     * Return a join table name
+     *
+     * @param string $sourceEntity The source entity
+     * @param string $targetEntity The target entity
+     * @param string $propertyName A property
+     * @return string A join table name
+     */
+    function joinTableName($sourceEntity, $targetEntity, $propertyName = null);
+
+    /**
+     * Return the foreign key column name for the given parameters
+     *
+     * @param string $entityName A entity
+     * @param string $referencedColumnName A property
+     * @return string A join column name
+     */
+    function joinKeyColumnName($entityName, $referencedColumnName = null);
+}

lib/Doctrine/ORM/Mapping/OneToMany.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */
 

lib/Doctrine/ORM/Mapping/OneToOne.php

@@ -13,7 +13,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * This software consists of voluntary contributions made by many individuals
- * and is licensed under the LGPL. For more information, see
+ * and is licensed under the MIT license. For more information, see
  * <http://www.doctrine-project.org>.
  */