Vendor update && Started using DoctrineMigrations

vendor/doctrine/orm/UPGRADE_TO_2_2

@@ -0,0 +1,81 @@
+# 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.
+