OpennessFactor(ies) - adding factory methods to enable creating functions publicly
Functional and unit tests for AsStreaming methods.
Converting value of @@IDENTITY from numeric to int/bigint to avoid table scans
ACompactPull (Pull request from ErikEJ to fix SQL Compact perf issue: CodePlex 857)

The actual fix submitted is a one line change to the SQL Compact provider to add a cast as described in the bug. I verified that we have functional coverage for this code path and then also did a little bit of refactoring so that I could add unit tests.
Adding ExecutionStrategySupport to DatabaseTableChecker
Revert "Removing references to internal bug databases"

This reverts commit 1baa92bd26268f777d25f946a8ee93cfb45daf74.
Fix for #902: General performance regression introduced by changeset f15fb3b6614e

Problem: In fixing #849, perf regressed because certain metadata collections never go read-only and so the fast-lookup-by-identity dictionary was no longer being built.

Solution: Revert the fix for #849 and change MetadataCollection so that it invalidates the internal cache when, either:
1) An item is removed.
2) An item identity is changed (currently we only need to worry about EntitySet and EdmMember).

The identity cache is now built lazily so that it is only built/rebuilt the first time it is needed.

Verification: David has tested this change with various regressed perf tests and determined that we are now either as fast or faster than before the regression.
Adding AddExecutionStrategy sugar methods to DbConfiguration.
Two of the overloads don't need the provider invariant name as they use DbProviderNameAttribute on the types implementing IExecutionStrategy.
Also added this type of overloads to other sugar methods that use provider invariant name for consistency.
This makes SqlAzureDbConfiguration redundant.
Renamed ExecutionStrategyResolver to DefaultExecutionStrategyResolver
Fixed property naming on ExecutionStrategyKey
GoingOutOfBusinessSale (Ensure related ends are available to change tracking proxies following Code First o/c loading changes)

There exists something that is known as the "expensive" o-space loading mechanism. This is code that uses a CLR type in order to attempt to reverse-lookup metadata information for relationships when such metadata cannot be looked up in any other way. This is primarily intended for use with entities that derive from EntityObject, and may still be needed for this. However, the code was used from public APIs that are available to any type of entity. This change tries to ensure that these APIs will still work even though they are probably not used much, if at all.

It is not possible to get a usable RelationshipManager for POCOs or lazy loading proxies that are not associated with any context. Therefore, the interesting case here is change tracking proxies that are not associated with a context. These proxies store relationship type information in their metadata and this can be used to do the required lookup without executing the expensive paths. This metadata was previously only stored for relationships with nav props and contained both relationship type info and end info. The end info was never used, so this has now been removed, and the metadata generation has been updated to get relationships even when the type as no navigation property on its end. Also, the expensive code paths would sometimes be used before using proxy metadata, or the proxy metadata would never be used at all; this has been fixed.
Issue 901. Updating DbContextTransaction to always pass on Commit/Rollback
to underlying transaction plus added tests for that
Added functional tests for query generation of Spatial data types
Code First: Adds EDM function validation required by Sproc mapping.

- Adds duplicate function parameter name validation rule.
- Enables name validation for functions.
- Removed marker interface and fixed bug in EDM type name validation.
EvenMorePublicity - opening TypeUsage and EdmProperty
- enabling creating EdmProperties with an arbitrary TypeUsage
- making TypeUsage.GetModelType method public
ISwearIHaveTheReference - fix for: Null Reference Exception thrown when creating model with entity splitting and table splitting

When configuring relationships we modify AssociationType KeyMembers collection. However to get AssociationEndMember from
AssociationSet we were using AssociationType Members collection. Members collection cannot be modified so KeyMembers and
Members collection can get out of synch when configuring relationships. It "worked" before #c8dc315 since we had accessed
ends using their index however we would return a stale end. With #c8dc315 we no longer accessed ends by their index but by
name and since Members collection was not modifed it did not have the end we were looking for and hence NRE. The fix is
to use KeyMembers instead of Members since they are updated when configuring relationships.

Also fixing AssociationType to return AssociationEndMembers based on KeyMembers and not on Members. Otherwise the returned
ends might not be correct (stale).

WorkItem: 867
Code First: Fix for #887 - Improve fluency of entity configuration APIs

- Fixed some places where we weren't allowing fluent method chaining.

work item: 887
Adding concurrency guards to async methods.
Async methods that mutate shared state will now take a lock.
Methods that use shared state will throw if it's locked.
Some of the async methods were reimplemented without async keyword to allow the concurrency exceptions to be thrown synchronously.

WorkItem: 390
Added public Create methods to AssociationType, AssociationSet and AssociationEndMember in order to be used by the EF designer.
FlyingTheNest (Enable Code First to use nested types)

This change allows nested entity, complex, and enum types to be mapped when using Code First. This change builds on the o/c mapping changes for Code First that have already be made. It adds support for nested types by taking the CLR nested type name and transforming it into an o-space model namespace and name such that the o-space namespace consists of the CLR namespace combined with the outer type name(s) and the o-space type name is the simple CLR type name. For example, "My.Namespace.OuterType+NestedType1+NestedType2" will become "My.Namespace.OuterType.NestedType1" "NestedType2" in o-space.

Note that the c-space namespace name is still the same for all types in the model and the c-space type name is still taken from the simple type of the CLR type. This means that only a single type with a given simple name can be used in a single model. It is however fine to have types in the same assembly that have the same simple name so long as they are used in different models.

This change also introduces a new model builder version for EF6. Nested types will be discovered with this model builder version or with the 'Latest' version, but will not be discovered with earlier model builder versions. Explicitly mapping nested types is allowed when using older versions since there is nothing in the schema that limits this.

EdmModel has been changed to use model builder version instead of schema version because it must now handle models that build differently even though the generated schema version will be the same.
JustBecauseYouAreAHighCharacter... (Regression test for CodePlex 190)

This was a bug about using a TVF in ESQL with an SSDL namespace that has high byte characters. This appears to work in the EF6 code base, either because it was fixed since the bug was filed (probably before the move to Git) or because it was actually a test issue with Taupo rather than a real bug.
Moving EF.xunit.targets to tools directory