internal static bool CanCreateAndOpenConnection(
StoreSchemaConnectionFactory connectionFactory, string providerInvariantName, string designTimeInvariantName,
string designTimeConnectionString)
{
Debug.Assert(connectionFactory != null, "connectionFactory != null");
Debug.Assert(
!string.IsNullOrWhiteSpace(designTimeInvariantName),
"designTimeInvariantName must not be null or empty");
Debug.Assert(
!string.IsNullOrWhiteSpace(designTimeConnectionString),
"designTimeConnectionString must not be null or empty");
EntityConnection entityConnection = null;
try
{
// attempt to create a DbConnection using the provider connection string we have. This will
// throw an exception if the connection cannot be made, for example, if the credentials aren't
// set. This has to be done using DDEX-based APIs since the SchemaGenerator is based off of
// DbConnection, and DDEX will save the password whereas DbConnection will not.
Version _;
entityConnection = connectionFactory.Create(
DependencyResolver.Instance,
providerInvariantName,
designTimeConnectionString,
EntityFrameworkVersion.Latest,
out _);
entityConnection.Open();
}
catch
{
return(false);
}
finally
{
// Close the EntityConnection
if (entityConnection != null)
{
VsUtils.SafeCloseDbConnection(entityConnection, designTimeInvariantName, designTimeConnectionString);
}
}
return(true);
}
// internal virtual for testing
internal virtual StoreSchemaDetails GetStoreSchemaDetails(StoreSchemaConnectionFactory connectionFactory)
{
Version storeSchemaModelVersion;
var connection =
connectionFactory
.Create(
DependencyResolver.Instance,
_settings.RuntimeProviderInvariantName,
_settings.DesignTimeConnectionString,
_settings.TargetSchemaVersion,
out storeSchemaModelVersion);
var facadeFilters =
_settings.DatabaseObjectFilters ?? Enumerable.Empty <EntityStoreSchemaFilterEntry>();
return
(CreateDbSchemaLoader(connection, storeSchemaModelVersion)
.LoadStoreSchemaDetails(facadeFilters.ToList()));
}
private static ICollection <EntityStoreSchemaFilterEntry> ExecuteDatabaseMetadataQuery(
string esqlQuery, EntityStoreSchemaFilterObjectTypes types, ModelBuilderSettings settings, DoWorkEventArgs args)
{
var filterEntries = new List <EntityStoreSchemaFilterEntry>();
EntityConnection ec = null;
try
{
Version actualEntityFrameworkConnectionVersion;
ec = new StoreSchemaConnectionFactory().Create(
DependencyResolver.Instance,
settings.RuntimeProviderInvariantName,
settings.DesignTimeConnectionString,
settings.TargetSchemaVersion,
out actualEntityFrameworkConnectionVersion);
// if the provider does not support V3 and we are querying for Functions then switch to the pre-V3 query
if (actualEntityFrameworkConnectionVersion < EntityFrameworkVersion.Version3 &&
SelectFunctionsESqlQuery.Equals(esqlQuery, StringComparison.Ordinal))
{
esqlQuery = SelectFunctionsESqlQueryBeforeV3;
}
using (var command = new EntityCommand(null, ec, DependencyResolver.Instance))
{
// NOTE: DO NOT set the command.CommandTimeout value. Some providers don't support a non-zero value, and will throw (eg, SqlCE provider).
// The System.Data.SqlClient's default value is 15, so we will still get a timeout for sql server.
command.CommandType = CommandType.Text;
command.CommandText = esqlQuery;
ec.Open();
DbDataReader reader = null;
try
{
reader = command.ExecuteReader(CommandBehavior.SequentialAccess);
while (reader.Read())
{
if (args != null &&
args.Cancel)
{
break;
}
if (reader.FieldCount == 3)
{
// the types coming back through the reader may not be a string
// (eg, SqlCE returns System.DbNull for catalogName & schemaName), so cast carefully
var catalogName = reader.GetValue(0) as String;
var schemaName = reader.GetValue(1) as String;
var name = reader.GetValue(2) as String;
if (String.IsNullOrEmpty(name) == false)
{
filterEntries.Add(
new EntityStoreSchemaFilterEntry(
catalogName, schemaName, name, types, EntityStoreSchemaFilterEffect.Allow));
}
}
else
{
Debug.Fail("Unexpected field count in reader");
}
}
}
finally
{
if (reader != null)
{
try
{
reader.Close();
reader.Dispose();
}
catch (Exception)
{
Debug.Fail(
"Could not close the DbDataReader in ExecuteDatabaseMetadataQuery(). If this is the result of a connection to a database file, it will leave a read lock on the file.");
}
}
}
}
}
finally
{
if (ec != null)
{
try
{
ec.Close();
ec.Dispose();
}
catch (Exception)
{
Debug.Fail(
"Could not close the EntityConnection in ExecuteDatabaseMetadataQuery(). If this is a connection to a database file, it will leave a read lock on the file.");
}
}
}
return(filterEntries);
}
public bool InvokeCanCreateAndOpenConnection(StoreSchemaConnectionFactory connectionFactory,
string providerInvariantName, string designTimeInvariantName, string designTimeConnectionString)
{
return(CanCreateAndOpenConnection(
connectionFactory, providerInvariantName, designTimeInvariantName, designTimeConnectionString));
}
