/// <summary>
/// Gets the provider manifest for given provider manifest token.
/// </summary>
/// <param name="manifestToken">The provider manifest token.</param>
/// <returns><see cref="DbProviderManifest"/> for a given token.</returns>
protected override System.Data.Entity.Core.Common.DbProviderManifest GetDbProviderManifest(string manifestToken)
{
string providerInvariantName;
string realToken;
// check if the name of the wrapped provider is specified in the token
int p = manifestToken.IndexOf(';');
if (p < 0)
{
// wrapped provider is not in the token - use default one
realToken = manifestToken;
providerInvariantName = this.DefaultWrappedProviderName;
}
else
{
// extract provider name from the token
providerInvariantName = manifestToken.Substring(0, p);
realToken = manifestToken.Substring(p + 1);
}
// retrieve wrapped provider manifest
System.Data.Entity.Core.Common.DbProviderServices services = GetProviderServicesByName(providerInvariantName);
System.Data.Entity.Core.Common.DbProviderManifest wrappedProviderManifest = services.GetProviderManifest(realToken);
System.Data.Entity.Core.Common.DbProviderManifest wrapperManifest = this.CreateProviderManifest(providerInvariantName, wrappedProviderManifest);
return(wrapperManifest);
}
/// <summary>
/// Wraps the provided DbProviderServices class in a MiniProfiler profiled DbService and returns the wrapped service.
/// </summary>
/// <param name="services">The DbProviderServices service to wrap.</param>
/// <returns>A wrapped version of the DbProviderService service.</returns>
private static DbProviderServices WrapProviderService(DbProviderServices services)
{
// First let's check our cache.
if (ProviderCache.ContainsKey(services))
{
return ProviderCache[services];
}
// Then let's see if our type is already wrapped.
var serviceType = services.GetType();
while (serviceType != null)
{
if (serviceType.IsGenericType && serviceType.GetGenericTypeDefinition() == typeof(EFProfiledDbProviderServices<>))
{
// Add it to the cache and return it.
ProviderCache[services] = services;
return services;
}
serviceType = serviceType.BaseType;
}
// Finally let's wrap it.
var genericType = typeof(EFProfiledDbProviderServices<>);
Type[] typeArgs = { services.GetType() };
var createdType = genericType.MakeGenericType(typeArgs);
var instanceProperty = createdType.GetField("Instance", BindingFlags.Public | BindingFlags.Static);
var instance = instanceProperty.GetValue(null) as DbProviderServices;
ProviderCache[services] = instance;
return instance;
}
public NamedDbProviderService(string invariantName, DbProviderServices providerServices)
{
DebugCheck.NotEmpty(invariantName);
DebugCheck.NotNull(providerServices);
_invariantName = invariantName;
_providerServices = providerServices;
}
/// <summary>
/// Gets the provider manifest token.
/// </summary>
/// <param name="connection">The database connection.</param>
/// <returns>Provider Manfiest Token suitable for inclusion in SSDL file and connection string</returns>
/// <remarks>
/// The provider manifest token is created by concatenating wrapped provider invariant name and its
/// token separated by semicolon, for example when wrapping SqlClient for SQL Server 2005 the provider
/// manifest token will be "System.Data.SqlClient;2005"
/// </remarks>
protected override string GetDbProviderManifestToken(DbConnection connection)
{
DbConnectionWrapper wrapper = (DbConnectionWrapper)connection;
DbConnection wrappedConnection = wrapper.WrappedConnection;
System.Data.Entity.Core.Common.DbProviderServices services = System.Data.Entity.Core.Common.DbProviderServices.GetProviderServices(wrappedConnection);
string token = wrapper.WrappedProviderInvariantName + ";" + services.GetProviderManifestToken(wrappedConnection);
return(token);
}
public void ExpandDataDirectory_correctly_concatenates_paths_with_correct_number_of_slashes()
{
TestWithDataDirectory(
@"C:\MelancholyBlues",
() => Assert.Equal(@"C:\MelancholyBlues\", DbProviderServices.ExpandDataDirectory(@"|DataDirectory|")));
TestWithDataDirectory(
@"C:\MelancholyBlues\",
() => Assert.Equal(@"C:\MelancholyBlues\", DbProviderServices.ExpandDataDirectory(@"|DataDirectory|")));
TestWithDataDirectory(
null,
() => Assert.Equal(@"\SheerHeartAttack", DbProviderServices.ExpandDataDirectory(@"|DataDirectory|SheerHeartAttack")));
TestWithDataDirectory(
null,
() => Assert.Equal(@"\SheerHeartAttack", DbProviderServices.ExpandDataDirectory(@"|DataDirectory|\SheerHeartAttack")));
TestWithDataDirectory(
@"C:\MelancholyBlues",
() =>
Assert.Equal(
@"C:\MelancholyBlues\SheerHeartAttack", DbProviderServices.ExpandDataDirectory(@"|DataDirectory|SheerHeartAttack")));
TestWithDataDirectory(
@"C:\MelancholyBlues",
() =>
Assert.Equal(
@"C:\MelancholyBlues\SheerHeartAttack", DbProviderServices.ExpandDataDirectory(@"|DataDirectory|\SheerHeartAttack")));
TestWithDataDirectory(
@"C:\MelancholyBlues\",
() =>
Assert.Equal(
@"C:\MelancholyBlues\SheerHeartAttack", DbProviderServices.ExpandDataDirectory(@"|DataDirectory|SheerHeartAttack")));
TestWithDataDirectory(
@"C:\MelancholyBlues\",
() =>
Assert.Equal(
@"C:\MelancholyBlues\SheerHeartAttack", DbProviderServices.ExpandDataDirectory(@"|DataDirectory|\SheerHeartAttack")));
}
public void GetSpatialServices_with_EntityConnection_uses_provider_from_store_connection_if_resolver_returns_null()
{
var mockItemCollection = new Mock <StoreItemCollection>();
mockItemCollection.Setup(m => m.ProviderInvariantName).Returns("I'm.So.Free");
mockItemCollection.Setup(m => m.ProviderManifestToken).Returns("2008");
var mockWorkspace = new Mock <MetadataWorkspace>();
mockWorkspace.Setup(m => m.GetItemCollection(DataSpace.SSpace)).Returns(mockItemCollection.Object);
var mockConnection = new Mock <EntityConnection>();
mockConnection.Setup(m => m.GetMetadataWorkspace()).Returns(mockWorkspace.Object);
mockConnection.Setup(m => m.StoreConnection).Returns(new SqlConnection());
Assert.Same(
SqlSpatialServices.Instance,
DbProviderServices.GetSpatialServices(new Mock <IDbDependencyResolver>().Object, mockConnection.Object));
}
public void Static_method_dispatches_to_interceptors()
{
var dbConnectionInterceptorMock = new Mock <IDbConnectionInterceptor>();
var model = EdmModel.CreateStoreModel(
new DbProviderInfo("System.Data.FakeSqlClient", "2008"),
new SqlProviderManifest("2008"));
var storeItemCollectionMock = new Mock <StoreItemCollection>(model)
{
CallBase = true
};
var metadataWorkspaceMock = new Mock <MetadataWorkspace>();
metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.SSpace)).Returns(storeItemCollectionMock.Object);
var connectionMock = new Mock <DbConnection>();
var entityConnection = new EntityConnection(
workspace: null, connection: connectionMock.Object, skipInitialization: true, entityConnectionOwnsStoreConnection: false);
DbInterception.Add(dbConnectionInterceptorMock.Object);
try
{
DbProviderServices.GetExecutionStrategy(entityConnection, metadataWorkspaceMock.Object);
}
finally
{
DbInterception.Remove(dbConnectionInterceptorMock.Object);
}
dbConnectionInterceptorMock.Verify(
m => m.DataSourceGetting(It.IsAny <DbConnection>(), It.IsAny <DbConnectionInterceptionContext <string> >()),
Times.Once());
dbConnectionInterceptorMock.Verify(
m => m.DataSourceGot(It.IsAny <DbConnection>(), It.IsAny <DbConnectionInterceptionContext <string> >()),
Times.Once());
}
private Func <System.Data.Entity.Core.Common.DbProviderManifest, System.Data.Entity.Core.Common.CommandTrees.DbCommandTree, System.Data.Entity.Core.Common.DbCommandDefinition> GetCreateDbCommandDefinitionFunction(string providerInvariantName)
{
Func <System.Data.Entity.Core.Common.DbProviderManifest, System.Data.Entity.Core.Common.CommandTrees.DbCommandTree, System.Data.Entity.Core.Common.DbCommandDefinition> result;
lock (this.createDbCommandDefinitionFunctions)
{
if (!this.createDbCommandDefinitionFunctions.TryGetValue(providerInvariantName, out result))
{
System.Data.Entity.Core.Common.DbProviderServices ps = GetProviderServicesByName(providerInvariantName);
// create a delegate to call CreateDbCommandDefinition using reflection
// (method is protected, but part of public API)
MethodInfo createCommandDefinitionMethodInfo = ps.GetType().GetMethod("CreateDbCommandDefinition", BindingFlags.NonPublic | BindingFlags.Instance);
result = (Func <System.Data.Entity.Core.Common.DbProviderManifest, System.Data.Entity.Core.Common.CommandTrees.DbCommandTree, System.Data.Entity.Core.Common.DbCommandDefinition>)Delegate.CreateDelegate(
typeof(Func <System.Data.Entity.Core.Common.DbProviderManifest, System.Data.Entity.Core.Common.CommandTrees.DbCommandTree, System.Data.Entity.Core.Common.DbCommandDefinition>),
ps,
createCommandDefinitionMethodInfo);
this.createDbCommandDefinitionFunctions[providerInvariantName] = result;
}
}
return(result);
}
/// <summary>
/// Gets provider services object given provider invariant name.
/// </summary>
/// <param name="providerInvariantName">Provider invariant name.</param>
/// <returns><see cref="DbProviderServices"/> object for a given invariant name.</returns>
private static System.Data.Entity.Core.Common.DbProviderServices GetProviderServicesByName(string providerInvariantName)
{
DbProviderFactory factory = DbProviderFactories.GetFactory(providerInvariantName);
if (factory == null)
{
throw new ArgumentException("Invalid provider factory: " + providerInvariantName);
}
IServiceProvider serviceProvider = factory as IServiceProvider;
if (serviceProvider == null)
{
throw new ArgumentException("Provider does not support Entity Framework - IServiceProvider is not supported");
}
System.Data.Entity.Core.Common.DbProviderServices providerServices = (System.Data.Entity.Core.Common.DbProviderServices)serviceProvider.GetService(typeof(System.Data.Entity.Core.Common.DbProviderServices));
if (providerServices == null)
{
throw new ArgumentException("Provider does not support Entity Framework - DbProviderServices is not supported");
}
return(providerServices);
}
public void GetProviderServices_returns_provider_registered_in_app_config()
{
Assert.Same(
FakeSqlProviderServices.Instance,
DbProviderServices.GetProviderServices(new FakeSqlConnection()));
}
public void GetProviderServices_returns_SQL_Server_provider_by_convention()
{
Assert.Same(
SqlProviderServices.Instance,
DbProviderServices.GetProviderServices(new SqlConnection()));
}
/// <summary>
/// Gets the <see cref="T:System.Data.Entity.Infrastructure.IDbExecutionStrategy" /> that will be used to execute methods that use the specified connection.
/// This overload should be used by the derived classes for compatability with wrapping providers.
/// </summary>
/// <param name="connection">The database connection</param>
/// <param name="providerInvariantName">The provider invariant name</param>
/// <returns>
/// A new instance of <see cref="T:System.Data.Entity.Infrastructure.DbExecutionStrategy" />
/// </returns>
protected static IDbExecutionStrategy GetExecutionStrategy(
DbConnection connection,
string providerInvariantName)
{
return(DbProviderServices.GetExecutionStrategy(connection, DbProviderServices.GetProviderFactory(connection), providerInvariantName));
}
/// <summary>
/// Initializes a new instance of the DbProviderFactoryBase class.
/// </summary>
/// <param name="providerServices">The provider services.</param>
protected DbProviderFactoryBase(System.Data.Entity.Core.Common.DbProviderServices providerServices)
{
this.services = providerServices;
}
internal static DbSpatialServices GetSpatialServices(
IDbDependencyResolver resolver,
EntityConnection connection)
{
StoreItemCollection itemCollection = (StoreItemCollection)connection.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace);
DbProviderInfo key = new DbProviderInfo(itemCollection.ProviderInvariantName, itemCollection.ProviderManifestToken);
return(DbProviderServices.GetSpatialServices(resolver, key, (Func <DbProviderServices>)(() => DbProviderServices.GetProviderServices(connection.StoreConnection))));
}
public void Static_method_returns_the_ExecutionStrategy_from_resolver()
{
var connectionMock = new Mock <DbConnection>();
connectionMock.Setup(m => m.DataSource).Returns("FooSource");
var model = EdmModel.CreateStoreModel(
new DbProviderInfo("System.Data.FakeSqlClient", "2008"),
new SqlProviderManifest("2008"));
var storeItemCollectionMock = new Mock <StoreItemCollection>(model)
{
CallBase = true
};
var metadataWorkspaceMock = new Mock <MetadataWorkspace>();
metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.SSpace)).Returns(storeItemCollectionMock.Object);
var entityConnection = new EntityConnection(
workspace: null, connection: connectionMock.Object, skipInitialization: true, entityConnectionOwnsStoreConnection: false);
var mockExecutionStrategy = new Mock <IDbExecutionStrategy>().Object;
MutableResolver.AddResolver <Func <IDbExecutionStrategy> >(
k =>
{
var key = k as ExecutionStrategyKey;
Assert.Equal("System.Data.FakeSqlClient", key.ProviderInvariantName);
Assert.Equal("FooSource", key.ServerName);
return((Func <IDbExecutionStrategy>)(() => mockExecutionStrategy));
});
var providerFactoryServiceMock = new Mock <IDbProviderFactoryResolver>();
providerFactoryServiceMock.Setup(m => m.ResolveProviderFactory(It.IsAny <DbConnection>()))
.Returns(FakeSqlProviderFactory.Instance);
var dbConnectionInterceptorMock = new Mock <IDbConnectionInterceptor>();
DbInterception.Add(dbConnectionInterceptorMock.Object);
MutableResolver.AddResolver <IDbProviderFactoryResolver>(k => providerFactoryServiceMock.Object);
try
{
Assert.Same(mockExecutionStrategy, DbProviderServices.GetExecutionStrategy(connectionMock.Object));
Assert.Same(
mockExecutionStrategy, DbProviderServices.GetExecutionStrategy(entityConnection, metadataWorkspaceMock.Object));
}
finally
{
MutableResolver.ClearResolvers();
DbInterception.Remove(dbConnectionInterceptorMock.Object);
}
dbConnectionInterceptorMock.Verify(
m => m.DataSourceGetting(It.IsAny <DbConnection>(), It.IsAny <DbConnectionInterceptionContext <string> >()),
Times.Exactly(2));
dbConnectionInterceptorMock.Verify(
m => m.DataSourceGot(It.IsAny <DbConnection>(), It.IsAny <DbConnectionInterceptionContext <string> >()),
Times.Exactly(2));
connectionMock.Verify(m => m.DataSource, Times.Exactly(2));
}
/// <summary>Gets the spatial services for the <see cref="T:System.Data.Entity.Core.Common.DbProviderServices" />.</summary>
/// <returns>The spatial services.</returns>
/// <param name="key">Information about the database that the spatial services will be used for.</param>
public DbSpatialServices GetSpatialServices(DbProviderInfo key)
{
return(DbProviderServices.GetSpatialServices(this._resolver.Value, key, (Func <DbProviderServices>)(() => this)));
}
/// <summary>
/// Gets the <see cref="T:System.Data.Entity.Infrastructure.IDbExecutionStrategy" /> that will be used to execute methods that use the specified connection.
/// </summary>
/// <param name="connection">The database connection</param>
/// <returns>
/// A new instance of <see cref="T:System.Data.Entity.Infrastructure.DbExecutionStrategy" />
/// </returns>
public static IDbExecutionStrategy GetExecutionStrategy(
DbConnection connection)
{
return(DbProviderServices.GetExecutionStrategy(connection, DbProviderServices.GetProviderFactory(connection), (string)null));
}
public void ExpandDataDirectory_returns_the_given_string_if_it_does_not_start_with_DataDirectory_ident()
{
Assert.Null(DbProviderServices.ExpandDataDirectory(null));
Assert.Equal("", DbProviderServices.ExpandDataDirectory(""));
Assert.Equal("It's Late", DbProviderServices.ExpandDataDirectory("It's Late"));
}
/// <summary>Returns providers given a connection.</summary>
/// <returns>
/// The <see cref="T:System.Data.Entity.Core.Common.DbProviderServices" /> instanced based on the specified connection.
/// </returns>
/// <param name="connection">Connection to provider.</param>
public static DbProviderServices GetProviderServices(DbConnection connection)
{
return(DbProviderServices.GetProviderFactory(connection).GetProviderServices());
}
protected internal void AddProvider(string providerInvariantName, DbProviderServices provider)
{
Contract.Requires(!string.IsNullOrWhiteSpace(providerInvariantName));
Contract.Requires(provider != null);
CheckNotLocked("AddProvider");
AddDependencyResolver(new SingletonDependencyResolver<DbProviderServices>(provider, providerInvariantName));
}
/// <summary>
/// Return an XML reader which represents the CSDL description
/// </summary>
/// <param name="csdlName">The name of the CSDL description.</param>
/// <returns> An XmlReader that represents the CSDL description </returns>
public static XmlReader GetConceptualSchemaDefinition(string csdlName)
{
Check.NotEmpty(csdlName, nameof(csdlName));
return(DbProviderServices.GetXmlResource("System.Data.Resources.DbProviderServices." + csdlName + ".csdl"));
}
public void ExpandDataDirectory_uses_empty_string_if_DataDirectory_is_not_set()
{
TestWithDataDirectory(
null,
() => Assert.Equal(@"\", DbProviderServices.ExpandDataDirectory("|DataDirectory|")));
}
// internal for testing
internal static string CreateDefiningQuery(EntitySet entitySet, MetadataWorkspace workspace, DbProviderServices providerServices)
{
Debug.Assert(entitySet != null, "entitySet != null");
Debug.Assert(workspace != null, "workspace != null");
Debug.Assert(providerServices != null, "providerServices != null");
var inputBinding = entitySet.Scan().BindAs(entitySet.Name);
var projectList = new List<KeyValuePair<string, DbExpression>>(entitySet.ElementType.Members.Count);
foreach (var member in entitySet.ElementType.Members)
{
Debug.Assert(member.BuiltInTypeKind == BuiltInTypeKind.EdmProperty, "Every member must be a edmproperty");
var propertyInfo = (EdmProperty)member;
projectList.Add(
new KeyValuePair<string, DbExpression>(
member.Name,
inputBinding.Variable.Property(propertyInfo)));
}
var query = inputBinding.Project(DbExpressionBuilder.NewRow(projectList));
var dbCommandTree = new DbQueryCommandTree(workspace, DataSpace.SSpace, query);
return providerServices.CreateCommandDefinition(dbCommandTree).CreateCommand().CommandText;
}
