public DatabaseExistenceState AnyModelTableExists(
InternalContext internalContext)
{
if (!internalContext.DatabaseOperations.Exists(internalContext.Connection, internalContext.CommandTimeout, new Lazy <StoreItemCollection>((Func <StoreItemCollection>)(() => DatabaseTableChecker.CreateStoreItemCollection(internalContext)))))
{
return(DatabaseExistenceState.DoesNotExist);
}
using (ClonedObjectContext contextForDdlOps = internalContext.CreateObjectContextForDdlOps())
{
try
{
if (internalContext.CodeFirstModel == null)
{
return(DatabaseExistenceState.Exists);
}
TableExistenceChecker service = DbConfiguration.DependencyResolver.GetService <TableExistenceChecker>((object)internalContext.ProviderName);
if (service == null)
{
return(DatabaseExistenceState.Exists);
}
List <EntitySet> list = this.GetModelTables(internalContext).ToList <EntitySet>();
if (!list.Any <EntitySet>() || this.QueryForTableExistence(service, contextForDdlOps, list))
{
return(DatabaseExistenceState.Exists);
}
return(internalContext.HasHistoryTableEntry() ? DatabaseExistenceState.Exists : DatabaseExistenceState.ExistsConsideredEmpty);
}
catch (Exception ex)
{
return(DatabaseExistenceState.Exists);
}
}
}
public virtual bool IsMigrationsConfigured(InternalContext internalContext, Func <bool> databaseExists)
{
DebugCheck.NotNull(internalContext);
try
{
if (!_finder(internalContext))
{
return(false);
}
}
catch (Exception ex)
{
Debug.Fail("Exception ignored while attempting to create migration configuration: " + ex);
return(false);
}
if (databaseExists())
{
return(true);
}
throw new InvalidOperationException(
Strings.DatabaseInitializationStrategy_MigrationsEnabled(internalContext.Owner.GetType().Name));
}
// <summary>
// Creates a database using the core provider (i.e. ObjectContext.CreateDatabase) or
// by using Code First Migrations <see cref="DbMigrator" /> to create an empty database
// and the perform an automatic migration to the current model.
// </summary>
public virtual void CreateDatabase(
InternalContext internalContext,
Func <DbMigrationsConfiguration, DbContext, MigratorBase> createMigrator,
ObjectContext objectContext)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(createMigrator);
// objectContext may be null when testing.
if (internalContext.CodeFirstModel != null &&
_resolver.GetService <Func <MigrationSqlGenerator> >(internalContext.ProviderName) != null)
{
createMigrator(
internalContext.MigrationsConfiguration,
internalContext.Owner).Update();
}
else
{
internalContext.DatabaseOperations.Create(objectContext);
internalContext.SaveMetadataToDatabase();
}
// If the database is created explicitly, then this is treated as overriding the
// database initialization strategy, so make it as already run.
internalContext.MarkDatabaseInitialized();
}
public DatabaseExistenceState AnyModelTableExists(InternalContext internalContext)
{
var exists = internalContext.DatabaseOperations.Exists(
internalContext.Connection,
internalContext.CommandTimeout,
new Lazy <StoreItemCollection>(() => CreateStoreItemCollection(internalContext)));
if (!exists)
{
return(DatabaseExistenceState.DoesNotExist);
}
using (var clonedObjectContext = internalContext.CreateObjectContextForDdlOps())
{
try
{
if (internalContext.CodeFirstModel == null)
{
// If not Code First, then assume tables created in some other way
return(DatabaseExistenceState.Exists);
}
var checker = DbConfiguration.DependencyResolver.GetService <TableExistenceChecker>(internalContext.ProviderName);
if (checker == null)
{
// If we can't check for tables, then assume they exist as we did in older versions
return(DatabaseExistenceState.Exists);
}
var modelTables = GetModelTables(internalContext).ToList();
if (!modelTables.Any())
{
// If this is an empty model, then all tables that can exist (0) do exist
return(DatabaseExistenceState.Exists);
}
if (QueryForTableExistence(checker, clonedObjectContext, modelTables))
{
// If any table exists, then assume that this is a non-empty database
return(DatabaseExistenceState.Exists);
}
// At this point we know no model tables exist. If the history table exists and has an entry
// for this context, then treat this as a non-empty database, otherwise treat is as existing
// but empty.
return(internalContext.HasHistoryTableEntry()
? DatabaseExistenceState.Exists
: DatabaseExistenceState.ExistsConsideredEmpty);
}
catch (Exception ex)
{
Debug.Fail(ex.Message, ex.ToString());
// Revert to previous behavior on error
return(DatabaseExistenceState.Exists);
}
}
}
public virtual bool CompatibleWithModel(
InternalContext internalContext,
ModelHashCalculator modelHashCalculator,
bool throwIfNoMetadata,
DatabaseExistenceState existenceState = DatabaseExistenceState.Unknown)
{
if (internalContext.CodeFirstModel == null)
{
if (throwIfNoMetadata)
{
throw Error.Database_NonCodeFirstCompatibilityCheck();
}
return(true);
}
VersionedModel model = internalContext.QueryForModel(existenceState);
if (model != null)
{
return(internalContext.ModelMatches(model));
}
string a = internalContext.QueryForModelHash();
if (a != null)
{
return(string.Equals(a, modelHashCalculator.Calculate(internalContext.CodeFirstModel), StringComparison.Ordinal));
}
if (throwIfNoMetadata)
{
throw Error.Database_NoDatabaseMetadata();
}
return(true);
}
public InternalEntityEntry(InternalContext internalContext, IEntityStateEntry stateEntry)
{
this._internalContext = internalContext;
this._stateEntry = stateEntry;
this._entity = stateEntry.Entity;
this._entityType = ObjectContextTypeCache.GetObjectType(this._entity.GetType());
}
internal InternalSqlNonSetQuery(
InternalContext internalContext,
Type elementType,
string sql,
object[] parameters)
: this(internalContext, elementType, sql, new bool?(), parameters)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="DbDataRecordPropertyValues" /> class.
/// </summary>
/// <param name="internalContext"> The internal context. </param>
/// <param name="type"> The type. </param>
/// <param name="dataRecord"> The data record. </param>
/// <param name="isEntity">
/// If set to <c>true</c> this is a dictionary for an entity, otherwise it is a dictionary for a complex object.
/// </param>
internal DbDataRecordPropertyValues(
InternalContext internalContext, Type type, DbUpdatableDataRecord dataRecord, bool isEntity)
: base(internalContext, type, isEntity)
{
DebugCheck.NotNull(dataRecord);
_dataRecord = dataRecord;
}
private static StoreItemCollection CreateStoreItemCollection(InternalContext internalContext)
{
using (var clonedObjectContext = internalContext.CreateObjectContextForDdlOps())
{
var entityConnection = ((EntityConnection)clonedObjectContext.ObjectContext.Connection);
return((StoreItemCollection)entityConnection.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace));
}
}
public EdmMetadataRepository(
InternalContext usersContext,
string connectionString,
DbProviderFactory providerFactory)
: base(usersContext, connectionString, providerFactory)
{
this._existingTransaction = usersContext.TryGetCurrentStoreTransaction();
}
private InternalSqlNonSetQuery(InternalContext internalContext, Type elementType, string sql, bool?streaming, object[] parameters)
: base(sql, streaming, parameters)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(elementType);
_internalContext = internalContext;
_elementType = elementType;
}
/// <summary>
/// Initializes a new instance of the <see cref="InternalPropertyValues" /> class.
/// </summary>
/// <param name="internalContext"> The internal context with which the entity of complex object is associated. </param>
/// <param name="type"> The type of the entity or complex object. </param>
/// <param name="isEntityValues">
/// If set to <c>true</c> this is a dictionary for an entity, otherwise it is a dictionary for a complex object.
/// </param>
protected InternalPropertyValues(InternalContext internalContext, Type type, bool isEntityValues)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(type);
_internalContext = internalContext;
_type = type;
_isEntityValues = isEntityValues;
}
protected InternalPropertyValues(
InternalContext internalContext,
Type type,
bool isEntityValues)
{
this._internalContext = internalContext;
this._type = type;
this._isEntityValues = isEntityValues;
}
internal DbDataRecordPropertyValues(
InternalContext internalContext,
Type type,
DbUpdatableDataRecord dataRecord,
bool isEntity)
: base(internalContext, type, isEntity)
{
this._dataRecord = dataRecord;
}
protected RepositoryBase(InternalContext usersContext, string connectionString, DbProviderFactory providerFactory)
{
DebugCheck.NotNull(usersContext);
DebugCheck.NotEmpty(connectionString);
DebugCheck.NotNull(providerFactory);
_usersContext = usersContext;
_connectionString = connectionString;
_providerFactory = providerFactory;
}
private InternalSqlNonSetQuery(
InternalContext internalContext,
Type elementType,
string sql,
bool?streaming,
object[] parameters)
: base(sql, streaming, parameters)
{
this._internalContext = internalContext;
this._elementType = elementType;
}
// <summary>
// Initializes a new instance of the <see cref="InternalEntityEntry" /> class.
// </summary>
// <param name="internalContext"> The internal context. </param>
// <param name="stateEntry"> The state entry. </param>
public InternalEntityEntry(InternalContext internalContext, IEntityStateEntry stateEntry)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(stateEntry);
Debug.Assert(stateEntry.Entity != null);
_internalContext = internalContext;
_stateEntry = stateEntry;
_entity = stateEntry.Entity;
_entityType = ObjectContextTypeCache.GetObjectType(_entity.GetType());
}
public virtual IEnumerable <EntitySet> GetModelTables(
InternalContext internalContext)
{
return(internalContext.ObjectContext.MetadataWorkspace.GetItemCollection(DataSpace.SSpace).GetItems <EntityContainer>().Single <EntityContainer>().BaseEntitySets.OfType <EntitySet>().Where <EntitySet>((Func <EntitySet, bool>)(s =>
{
if (s.MetadataProperties.Contains("Type"))
{
return (string)s.MetadataProperties["Type"].Value == "Tables";
}
return true;
})));
}
public InternalEntityEntry(InternalContext internalContext, object entity)
{
this._internalContext = internalContext;
this._entity = entity;
this._entityType = ObjectContextTypeCache.GetObjectType(this._entity.GetType());
this._stateEntry = this._internalContext.GetStateEntry(entity);
if (this._stateEntry != null)
{
return;
}
this._internalContext.Set(this._entityType).InternalSet.Initialize();
}
protected RepositoryBase(
InternalContext usersContext,
string connectionString,
DbProviderFactory providerFactory)
{
DbConnection connection = usersContext.Connection;
if (connection != null && connection.State == ConnectionState.Open)
{
this._existingConnection = connection;
}
this._connectionString = connectionString;
this._providerFactory = providerFactory;
}
protected RepositoryBase(InternalContext usersContext, string connectionString, DbProviderFactory providerFactory)
{
DebugCheck.NotNull(usersContext);
DebugCheck.NotEmpty(connectionString);
DebugCheck.NotNull(providerFactory);
var existingConnection = usersContext.Connection;
if (existingConnection != null)
{
_existingConnection = existingConnection;
}
_connectionString = connectionString;
_providerFactory = providerFactory;
}
private void UpdateEntitySetMappingsForType(Type entityType)
{
if (this.TryUpdateEntitySetMappingsForType(entityType))
{
return;
}
if (this.IsComplexType(entityType))
{
throw Error.DbSet_DbSetUsedWithComplexType((object)entityType.Name);
}
if (InternalContext.IsPocoTypeInNonPocoAssembly(entityType))
{
throw Error.DbSet_PocoAndNonPocoMixedInSameAssembly((object)entityType.Name);
}
throw Error.DbSet_EntityTypeNotInModel((object)entityType.Name);
}
public virtual void CreateDatabase(
InternalContext internalContext,
Func <DbMigrationsConfiguration, DbContext, MigratorBase> createMigrator,
ObjectContext objectContext)
{
if (internalContext.CodeFirstModel != null && this._resolver.GetService <Func <MigrationSqlGenerator> >((object)internalContext.ProviderName) != null)
{
createMigrator(internalContext.MigrationsConfiguration, internalContext.Owner).Update();
}
else
{
internalContext.DatabaseOperations.Create(objectContext);
internalContext.SaveMetadataToDatabase();
}
internalContext.MarkDatabaseInitialized();
}
public static PropertyEntryMetadata ValidateNameAndGetMetadata(
InternalContext internalContext,
Type declaringType,
Type requestedType,
string propertyName)
{
Type type;
DbHelpers.GetPropertyTypes(declaringType).TryGetValue(propertyName, out type);
MetadataWorkspace metadataWorkspace = internalContext.ObjectContext.MetadataWorkspace;
StructuralType structuralType = metadataWorkspace.GetItem <StructuralType>(declaringType.FullNameWithNesting(), DataSpace.OSpace);
bool isMapped = false;
bool isComplex = false;
EdmMember edmMember;
structuralType.Members.TryGetValue(propertyName, false, out edmMember);
if (edmMember != null)
{
EdmProperty edmProperty = edmMember as EdmProperty;
if (edmProperty == null)
{
return((PropertyEntryMetadata)null);
}
if (type == (Type)null)
{
PrimitiveType edmType = edmProperty.TypeUsage.EdmType as PrimitiveType;
type = edmType == null ? ((ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace)).GetClrType((StructuralType)edmProperty.TypeUsage.EdmType) : edmType.ClrEquivalentType;
}
isMapped = true;
isComplex = edmProperty.TypeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType;
}
else
{
IDictionary <string, Func <object, object> > propertyGetters = DbHelpers.GetPropertyGetters(declaringType);
IDictionary <string, Action <object, object> > propertySetters = DbHelpers.GetPropertySetters(declaringType);
if (!propertyGetters.ContainsKey(propertyName) && !propertySetters.ContainsKey(propertyName))
{
return((PropertyEntryMetadata)null);
}
}
if (!requestedType.IsAssignableFrom(type))
{
throw Error.DbEntityEntry_WrongGenericForProp((object)propertyName, (object)declaringType.Name, (object)requestedType.Name, (object)type.Name);
}
return(new PropertyEntryMetadata(declaringType, type, propertyName, isMapped, isComplex));
}
public static DbMigrationsConfiguration GetMigrationsConfiguration(InternalContext internalContext)
{
DebugCheck.NotNull(internalContext);
var contextType = internalContext.Owner.GetType();
return(new DbMigrationsConfiguration
{
ContextType = contextType,
AutomaticMigrationsEnabled = true,
MigrationsAssembly = contextType.Assembly,
MigrationsNamespace = contextType.Namespace,
ContextKey = internalContext.ContextKey,
TargetDatabase = new DbConnectionInfo(internalContext.OriginalConnectionString, internalContext.ProviderName),
CommandTimeout = internalContext.CommandTimeout
});
}
// <summary>
// Initializes a new instance of the <see cref="InternalEntityEntry" /> class for an
// entity which may or may not be attached to the context.
// </summary>
// <param name="internalContext"> The internal context. </param>
// <param name="entity"> The entity. </param>
public InternalEntityEntry(InternalContext internalContext, object entity)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(entity);
_internalContext = internalContext;
_entity = entity;
_entityType = ObjectContextTypeCache.GetObjectType(_entity.GetType());
_stateEntry = _internalContext.GetStateEntry(entity);
if (_stateEntry == null)
{
// This will cause the context and model to be initialized and will throw an exception
// if the entity type is not part of the model.
_internalContext.Set(_entityType).InternalSet.Initialize();
}
}
internal DbLocalView(InternalContext internalContext)
{
this._internalContext = internalContext;
try
{
this._inStateManagerChanged = true;
foreach (TEntity localEntity in this._internalContext.GetLocalEntities <TEntity>())
{
this.Add(localEntity);
}
}
finally
{
this._inStateManagerChanged = false;
}
this._internalContext.RegisterObjectStateManagerChangedEvent(new CollectionChangeEventHandler(this.StateManagerChangedHandler));
}
public virtual bool CompatibleWithModel(
InternalContext internalContext, ModelHashCalculator modelHashCalculator,
bool throwIfNoMetadata, DatabaseExistenceState existenceState = DatabaseExistenceState.Unknown)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(modelHashCalculator);
if (internalContext.CodeFirstModel == null)
{
if (throwIfNoMetadata)
{
throw Error.Database_NonCodeFirstCompatibilityCheck();
}
return(true);
}
var model = internalContext.QueryForModel(existenceState);
if (model != null)
{
return(internalContext.ModelMatches(model));
}
// Migrations history was not found in the database so fall back to doing a model hash compare
// to deal with databases created using EF 4.1 and 4.2.
var databaseModelHash = internalContext.QueryForModelHash();
if (databaseModelHash == null)
{
if (throwIfNoMetadata)
{
throw Error.Database_NoDatabaseMetadata();
}
return(true);
}
return(String.Equals(
databaseModelHash, modelHashCalculator.Calculate(internalContext.CodeFirstModel),
StringComparison.Ordinal));
}
/// <summary>
/// Creates a database using the core provider (i.e. ObjectContext.CreateDatabase) or
/// by using Code First Migrations <see cref="DbMigrator" /> to create an empty database
/// and the perform an automatic migration to the current model.
/// Migrations is used if Code First is being used and the EF provider is for SQL Server
/// or SQL Compact. The core is used for non-Code First models and for other providers even
/// when using Code First.
/// </summary>
public virtual void CreateDatabase(
InternalContext internalContext,
Func <DbMigrationsConfiguration, DbContext, MigratorBase> createMigrator,
ObjectContext objectContext)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(createMigrator);
// objectContext may be null when testing.
if (internalContext.CodeFirstModel != null &&
_resolver.GetService <MigrationSqlGenerator>(internalContext.ProviderName) != null)
{
var contextType = internalContext.Owner.GetType();
var migrator = createMigrator(
new DbMigrationsConfiguration
{
ContextType = contextType,
AutomaticMigrationsEnabled = true,
MigrationsAssembly = contextType.Assembly,
MigrationsNamespace = contextType.Namespace,
ContextKey = internalContext.ContextKey,
TargetDatabase =
new DbConnectionInfo(
internalContext.OriginalConnectionString, internalContext.ProviderName)
},
internalContext.Owner);
migrator.Update();
}
else
{
internalContext.DatabaseOperations.Create(objectContext);
internalContext.SaveMetadataToDatabase();
}
// If the database is created explicitly, then this is treated as overriding the
// database initialization strategy, so make it as already run.
internalContext.MarkDatabaseInitialized();
}
/// <summary>
/// Initializes a new instance of the <see cref="DbLocalView{TEntity}" /> class for entities
/// of the given generic type in the given internal context.
/// </summary>
/// <param name="internalContext"> The internal context. </param>
internal DbLocalView(InternalContext internalContext)
{
DebugCheck.NotNull(internalContext);
_internalContext = internalContext;
try
{
// Set a flag to prevent changes we're making to the ObservableCollection based on the
// contents of the state manager from being pushed back to the state manager.
_inStateManagerChanged = true;
foreach (var entity in _internalContext.GetLocalEntities <TEntity>())
{
Add(entity);
}
}
finally
{
_inStateManagerChanged = false;
}
_internalContext.RegisterObjectStateManagerChangedEvent(StateManagerChangedHandler);
}