private void CreateServices()
{
using (BuildLog.InfoRegion(Strings.LogCreatingX, typeof(IServiceContainer).GetShortName())) {
var domain = context.Domain;
var configuration = domain.Configuration;
var userContainerType = configuration.ServiceContainerType ?? typeof(ServiceContainer);
var registrations = CreateServiceRegistrations(configuration)
.Concat(KeyGeneratorFactory.GetRegistrations(context));
var systemContainer = domain.CreateSystemServices();
var userContainer = ServiceContainer.Create(userContainerType, systemContainer);
domain.Services = new ServiceContainer(registrations, userContainer);
}
}
private static bool IsSequenceBacked(KeyInfo key)
{
var valueType = key.SingleColumnType;
return(valueType != null && KeyGeneratorFactory.IsSequenceBacked(valueType));
}
private KeyInfo BuildKeyInfo(TypeInfo root, HierarchyDef hierarchyDef)
{
var keyFields = root.Fields
.Where(field => field.IsPrimaryKey)
.OrderBy(field => field.MappingInfo.Offset)
.ToList();
var keyColumns = keyFields
.Where(field => field.Column != null)
.Select(field => field.Column)
.ToList();
var keyTupleDescriptor = TupleDescriptor.Create(
keyColumns.Select(c => c.ValueType).ToArray(keyColumns.Count));
var typeIdColumnIndex = -1;
if (hierarchyDef.IncludeTypeId)
{
for (var i = 0; i < keyColumns.Count; i++)
{
if (keyColumns[i].Field.IsTypeId)
{
typeIdColumnIndex = i;
}
}
}
var key = new KeyInfo(root.Name, keyFields, keyColumns, keyTupleDescriptor, typeIdColumnIndex);
var generatorKind = hierarchyDef.KeyGeneratorKind;
// Force absence of key generator if key is a reference.
if (key.ContainsForeignKeys)
{
generatorKind = KeyGeneratorKind.None;
}
if (generatorKind == KeyGeneratorKind.Default)
{
var canBeHandled = key.SingleColumnType != null && KeyGeneratorFactory.IsSupported(key.SingleColumnType);
// Force absence of key generator if key can not be handled by standard keygen.
if (!canBeHandled)
{
generatorKind = KeyGeneratorKind.None;
}
}
if (generatorKind == KeyGeneratorKind.None)
{
// No key generator is attached.
// Each hierarchy has it's own equality identifier.
key.IsFirstAmongSimilarKeys = true;
key.EqualityIdentifier = new object();
return(key);
}
// Hierarchy has key generator.
// Setup key generator name.
key.GeneratorKind = generatorKind;
key.GeneratorBaseName = context.NameBuilder.BuildKeyGeneratorBaseName(key, hierarchyDef);
key.GeneratorName = context.NameBuilder.BuildKeyGeneratorName(key, hierarchyDef);
var generatorIdentity = context.Configuration.MultidatabaseKeys
? key.GeneratorBaseName
: key.GeneratorName;
// Equality identifier is the same if and only if key generator names match.
key.IsFirstAmongSimilarKeys = !processedKeyGenerators.Contains(key.GeneratorName);
if (key.IsFirstAmongSimilarKeys)
{
_ = processedKeyGenerators.Add(key.GeneratorName);
}
if (keyEqualityIdentifiers.TryGetValue(generatorIdentity, out var equalityIdentifier))
{
key.EqualityIdentifier = equalityIdentifier;
}
else
{
key.EqualityIdentifier = new object();
keyEqualityIdentifiers.Add(generatorIdentity, key.EqualityIdentifier);
}
// Don't create sequences for user key generators
// and for key generators that are not sequence-backed (such as GuidGenerator).
if (key.GeneratorKind == KeyGeneratorKind.Custom || !IsSequenceBacked(key))
{
return(key);
}
// Generate backing sequence.
if (sequences.TryGetValue(key.GeneratorName, out var sequence))
{
key.Sequence = sequence;
}
else
{
var newSequence = BuildSequence(hierarchyDef, key);
if (context.Configuration.MultidatabaseKeys)
{
EnsureSequenceSeedIsUnique(newSequence);
}
key.Sequence = newSequence;
sequences.Add(key.GeneratorName, key.Sequence);
}
return(key);
}
