public CreateIndexOperation CreateCreateIndexOperation()
{
var columnNames = Columns.ToArray();
Debug.Assert(columnNames.Length > 0);
Debug.Assert(_index.Name != null || columnNames.Length == 1);
var operation = new CreateIndexOperation
{
Name = _index.Name ?? IndexOperation.BuildDefaultName(columnNames),
Table = _table
};
foreach (var columnName in columnNames)
{
operation.Columns.Add(columnName);
}
if (_index.IsClusteredConfigured)
{
operation.IsClustered = _index.IsClustered;
}
if (_index.IsUniqueConfigured)
{
operation.IsUnique = _index.IsUnique;
}
return(operation);
}
/// <inheritdoc />
public virtual void Apply(AssociationType item, DbModel model)
{
Check.NotNull(item, "item");
if (item.Constraint == null)
{
return;
}
var consolidatedIndexes
= ConsolidatedIndex.BuildIndexes(
item.Name,
item.Constraint.ToProperties.Select(p => Tuple.Create(p.Name, p)));
var dependentColumnNames = item.Constraint.ToProperties.Select(p => p.Name);
if (!consolidatedIndexes.Any(c => c.Columns.SequenceEqual(dependentColumnNames)))
{
var name = IndexOperation.BuildDefaultName(dependentColumnNames);
var order = 0;
foreach (var dependentColumn in item.Constraint.ToProperties)
{
var newAnnotation = new IndexAnnotation(new IndexAttribute(name, order++));
var existingAnnotation = dependentColumn.Annotations.GetAnnotation(XmlConstants.IndexAnnotationWithPrefix);
if (existingAnnotation != null)
{
newAnnotation = (IndexAnnotation)((IndexAnnotation)existingAnnotation).MergeWith(newAnnotation);
}
dependentColumn.AddAnnotation(XmlConstants.IndexAnnotationWithPrefix, newAnnotation);
}
}
}
/// <inheritdoc />
public virtual void Apply(AssociationType item, DbModel model)
{
Check.NotNull <AssociationType>(item, nameof(item));
if (item.Constraint == null)
{
return;
}
IEnumerable <ConsolidatedIndex> source = ConsolidatedIndex.BuildIndexes(item.Name, item.Constraint.ToProperties.Select <EdmProperty, Tuple <string, EdmProperty> >((Func <EdmProperty, Tuple <string, EdmProperty> >)(p => Tuple.Create <string, EdmProperty>(p.Name, p))));
IEnumerable <string> dependentColumnNames = item.Constraint.ToProperties.Select <EdmProperty, string>((Func <EdmProperty, string>)(p => p.Name));
if (source.Any <ConsolidatedIndex>((Func <ConsolidatedIndex, bool>)(c => c.Columns.SequenceEqual <string>(dependentColumnNames))))
{
return;
}
string name = IndexOperation.BuildDefaultName(dependentColumnNames);
int num = 0;
foreach (EdmProperty toProperty in item.Constraint.ToProperties)
{
IndexAnnotation indexAnnotation = new IndexAnnotation(new IndexAttribute(name, num++));
object annotation = toProperty.Annotations.GetAnnotation("http://schemas.microsoft.com/ado/2013/11/edm/customannotation:Index");
if (annotation != null)
{
indexAnnotation = (IndexAnnotation)((IndexAnnotation)annotation).MergeWith((object)indexAnnotation);
}
toProperty.AddAnnotation("http://schemas.microsoft.com/ado/2013/11/edm/customannotation:Index", (object)indexAnnotation);
}
}
private void ConfigureIndexes(DbDatabaseMapping mapping, EntityType entityType)
{
DebugCheck.NotNull(mapping);
DebugCheck.NotNull(entityType);
var entityTypeMappings = mapping.GetEntityTypeMappings(entityType);
if (_keyConfiguration != null)
{
entityTypeMappings
.SelectMany(etm => etm.Fragments)
.Each(f => _keyConfiguration.Configure(f.Table));
}
foreach (var indexConfiguration in _indexConfigurations)
{
foreach (var entityTypeMapping in entityTypeMappings)
{
var propertyMappings = indexConfiguration.Key
.ToDictionary(
icp => icp,
icp => entityTypeMapping.GetPropertyMapping(
entityType.GetDeclaredPrimitiveProperty(icp)));
if (indexConfiguration.Key.Count > 1 && string.IsNullOrEmpty(indexConfiguration.Value.Name))
{
indexConfiguration.Value.Name = IndexOperation.BuildDefaultName(
indexConfiguration.Key.Select(icp => propertyMappings[icp].ColumnProperty.Name));
}
int sortOrder = 0;
foreach (var indexConfigurationProperty in indexConfiguration.Key)
{
var propertyMapping = propertyMappings[indexConfigurationProperty];
indexConfiguration.Value.Configure(
propertyMapping.ColumnProperty,
(indexConfiguration.Key.Count != 1 ?
sortOrder :
-1));
++sortOrder;
}
}
}
}
public CreateIndexOperation CreateCreateIndexOperation()
{
string[] array = this.Columns.ToArray <string>();
CreateIndexOperation createIndexOperation1 = new CreateIndexOperation((object)null);
createIndexOperation1.Name = this._index.Name ?? IndexOperation.BuildDefaultName((IEnumerable <string>)array);
createIndexOperation1.Table = this._table;
CreateIndexOperation createIndexOperation2 = createIndexOperation1;
foreach (string str in array)
{
createIndexOperation2.Columns.Add(str);
}
if (this._index.IsClusteredConfigured)
{
createIndexOperation2.IsClustered = this._index.IsClustered;
}
if (this._index.IsUniqueConfigured)
{
createIndexOperation2.IsUnique = this._index.IsUnique;
}
return(createIndexOperation2);
}
static string BuildIndexName(IndexOperation indexOperation)
{
return(!indexOperation.HasDefaultName
? indexOperation.Name
: IndexOperation.BuildDefaultName(new[] { ExtractName(indexOperation.Table) }.Concat(indexOperation.Columns)));
}
public void Apply(EntityType item, DbModel model)
{
// Build index info, consolidating indexes with the same name
var indexInfo = new List <IndexInfo>();
foreach (var p in item.Properties)
{
foreach (var mp in p.MetadataProperties)
{
var a = mp.Value as IndexAnnotation;
if (a == null)
{
continue;
}
foreach (var index in a.Indexes)
{
var info = index.Name != null?indexInfo.FirstOrDefault(e => e.Name == index.Name) : null;
if (info == null)
{
info = new IndexInfo {
Name = index.Name
};
indexInfo.Add(info);
}
else
{
var other = info.Entries[0].Index;
if (index.IsUnique != other.IsUnique || index.IsClustered != other.IsClustered)
{
throw new Exception("Invalid index configuration.");
}
}
info.Entries.Add(new IndexEntry {
Column = p, Annotaion = mp, Index = index
});
}
}
}
if (indexInfo.Count == 0)
{
return;
}
// Generate new name where needed
var entitySet = model.StoreModel.Container.EntitySets.First(es => es.ElementType == item);
foreach (var info in indexInfo)
{
var columns = info.Entries.OrderBy(e => e.Index.Order).Select(e => e.Column.Name);
if (info.Name == null || info.Name == IndexOperation.BuildDefaultName(columns))
{
bool unique = info.Entries[0].Index.IsUnique;
var name = string.Format("{0}_{1}_{2}", unique ? "UX" : "IX", entitySet.Table, string.Join("_", columns));
if (name.Length > 128)
{
name = name.Substring(0, 128);
}
if (info.Name == name)
{
continue;
}
foreach (var entry in info.Entries)
{
var index = new IndexAttribute(name);
if (entry.Index.Order >= 0)
{
index.Order = entry.Index.Order;
}
if (entry.Index.IsUniqueConfigured)
{
index.IsUnique = entry.Index.IsUnique;
}
if (entry.Index.IsClusteredConfigured)
{
index.IsClustered = entry.Index.IsClustered;
}
entry.Index = index;
entry.Modified = true;
}
}
}
// Apply the changes
foreach (var g in indexInfo.SelectMany(e => e.Entries).GroupBy(e => e.Annotaion))
{
if (g.Any(e => e.Modified))
{
g.Key.Value = new IndexAnnotation(g.Select(e => e.Index));
}
}
}
/// <inheritdoc />
public void Apply(EntityType item, DbModel model)
{
var indexInfos = new List <IndexInfo>();
foreach (var property in item.Properties)
{
foreach (var metadataProperty in property.MetadataProperties)
{
if (!(metadataProperty.Value is IndexAnnotation annotation))
{
continue;
}
foreach (var index in annotation.Indexes)
{
var info = index.Name != null?indexInfos.FirstOrDefault(e => e.Name == index.Name) : null;
if (info == null)
{
info = new IndexInfo {
Name = index.Name
};
indexInfos.Add(info);
}
else
{
var other = info.Entries[0].Index;
if (index.IsUnique != other.IsUnique || index.IsClustered != other.IsClustered)
{
throw new Exception("Invalid index configuration.");
}
}
info.Entries.Add(new IndexEntry {
Column = property, Annotation = metadataProperty, Index = index
});
}
}
}
if (indexInfos.Count == 0)
{
return;
}
foreach (var indexInfo in indexInfos)
{
var columns = indexInfo.Entries.OrderBy(e => e.Index.Order).Select(e => e.Column.Name).ToList();
if (indexInfo.Name != null && indexInfo.Name != IndexOperation.BuildDefaultName(columns))
{
continue;
}
bool unique = indexInfo.Entries[0].Index.IsUnique;
string name = $"{(unique ? "UX" : "IX")}_{string.Join("_", columns.Select(column => column.Replace("_", string.Empty)))}";
if (name.Length > 128)
{
name = name.Substring(0, 128);
}
if (indexInfo.Name == name)
{
continue;
}
foreach (var entry in indexInfo.Entries)
{
var index = new IndexAttribute(name);
if (entry.Index.Order >= 0)
{
index.Order = entry.Index.Order;
}
if (entry.Index.IsUniqueConfigured)
{
index.IsUnique = entry.Index.IsUnique;
}
if (entry.Index.IsClusteredConfigured)
{
index.IsClustered = entry.Index.IsClustered;
}
entry.Index = index;
entry.Modified = true;
}
}
foreach (var indexInfo in indexInfos.SelectMany(ii => ii.Entries).GroupBy(e => e.Annotation))
{
if (indexInfo.Any(e => e.Modified))
{
indexInfo.Key.Value = new IndexAnnotation(indexInfo.Select(e => e.Index));
}
}
}
