public static int ExtractTypeId(TypeInfo type, TypeIdRegistry typeIdRegistry, Tuple tuple, int typeIdIndex, out TypeReferenceAccuracy accuracy) { accuracy = TypeReferenceAccuracy.Hierarchy; if (type.IsInterface) { accuracy = TypeReferenceAccuracy.BaseType; } if (typeIdIndex < 0) { if (type.IsLeaf) { accuracy = TypeReferenceAccuracy.ExactType; } return(typeIdRegistry.GetTypeId(type)); } accuracy = TypeReferenceAccuracy.ExactType; TupleFieldState state; var value = tuple.GetValue <int>(typeIdIndex, out state); if (type.IsLeaf) { return(state.HasValue() ? typeIdRegistry.GetTypeId(type) : TypeInfo.NoTypeId); } // Hack here: 0 (default) = TypeInfo.NoTypeId return(value); }
public void BuildTypeIds(TypeIdRegistry registry) { // Import static type identifiers. // Static types are system types, which don't change their type identifiers. // User types are not static by default. foreach (var type in GetTypesWithStaticTypeIds()) { registry.Register(type.TypeId, type); } // Load old type identifiers from database foreach (var type in GetTypesWithoutTypeId(registry)) { var typeId = typeIdProvider.GetTypeId(type.UnderlyingType); if (typeId != TypeInfo.NoTypeId) { registry.Register(typeId, type); } } // Generate type identifiers for remaining types var typeGroups = GetTypesWithoutTypeId(registry) .GroupBy(t => t.MappingDatabase ?? string.Empty) .OrderBy(g => g.Key); foreach (var group in typeGroups) { var sequence = GetTypeIdSequence(registry, group.Key); foreach (var type in group.OrderBy(i => i.Name)) { registry.Register(sequence.GetNextValue(), type); } } }
public static Tuple DeserializeKeyFields(TypeInfo entityType, TypeIdRegistry registry, SerializationInfo info, StreamingContext context) { var keyTuple = Tuple.Create(entityType.Hierarchy.Key.TupleDescriptor); foreach (FieldInfo keyField in entityType.Fields.Where(f => f.IsPrimaryKey && f.Parent == null)) { if (keyField.IsTypeId) { keyTuple.SetValue(keyField.MappingInfo.Offset, registry[entityType]); } else { var value = info.GetValue(keyField.Name, keyField.ValueType); if (keyField.IsEntity) { var referencedEntity = (Entity)value; if (!IsInitialized(referencedEntity)) { DeserializationContext.Demand().InitializeEntity(referencedEntity); } var referencedTuple = referencedEntity.Key.Value; referencedTuple.CopyTo(keyTuple, keyField.MappingInfo.Offset); } else { keyTuple.SetValue(keyField.MappingInfo.Offset, value); } } } return(keyTuple); }
public void SetDefaultTypeIds(TypeIdRegistry registry) { foreach (var type in GetTypesWithoutTypeId()) { type.TypeId = registry[type]; } domain.Model.Types.TypeIdRegistry = registry; }
// ReSharper restore UnusedMember.Global // Constructors public ItemMaterializationContext(MaterializationContext materializationContext, Session session) { MaterializationContext = materializationContext; Session = session; typeIdRegistry = session.StorageNode.TypeIdRegistry; entities = new Entity[materializationContext.EntitiesInRow]; }
// ReSharper restore UnusedMember.Global // Constructors public ItemMaterializationContext(MaterializationContext materializationContext, ParameterContext parameterContext) { ParameterContext = parameterContext; MaterializationContext = materializationContext; Session = materializationContext.Session; typeIdRegistry = Session.StorageNode.TypeIdRegistry; entities = new Entity[materializationContext.EntitiesInRow]; }
private TypeIdSequence GetTypeIdSequence(TypeIdRegistry registry, int minTypeId, int maxTypeId, string mappingDatabase) { var current = registry.TypeIdentifiers .Where(id => id >= minTypeId && id <= maxTypeId) .DefaultIfEmpty(minTypeId - 1) .Max(); return(new TypeIdSequence(current, minTypeId, maxTypeId, mappingDatabase)); }
private TypeIdSequence GetTypeIdSequence(TypeIdRegistry registry, string mappingDatabase) { if (domain.Model.Databases.Count == 0) { // Multidatabase mode is not enabled, use default range return(GetTypeIdSequence(registry, TypeInfo.MinTypeId, int.MaxValue, Strings.NA)); } // Query configuration for a particular database var configurationEntry = domain.Model.Databases[mappingDatabase].Configuration; return(GetTypeIdSequence(registry, configurationEntry.MinTypeId, configurationEntry.MaxTypeId, configurationEntry.Name)); }
// Constructors internal StorageNode(NodeConfiguration configuration, ModelMapping mapping, TypeIdRegistry typeIdRegistry) { ArgumentValidator.EnsureArgumentNotNull(configuration, "configuration"); ArgumentValidator.EnsureArgumentNotNull(mapping, "mapping"); ArgumentValidator.EnsureArgumentNotNull(typeIdRegistry, "typeIdRegistry"); Configuration = configuration; Mapping = mapping; TypeIdRegistry = typeIdRegistry; KeySequencesCache = new ConcurrentDictionary <SequenceInfo, object>(); PersistRequestCache = new ConcurrentDictionary <PersistRequestBuilderTask, ICollection <PersistRequest> >(); InternalQueryCache = new ConcurrentDictionary <object, object>(); }
public StoredDomainModel Convert(DomainModel model, TypeIdRegistry typeIdRegistry, Func <TypeInfo, bool> filter) { processedAssociations = new HashSet <string>(); var typesToProcess = model.Types.AsEnumerable(); if (filter != null) { typesToProcess = typesToProcess.Where(filter); } registry = typeIdRegistry; var processedTypes = typesToProcess.Select(ConvertType).ToArray(); return(new StoredDomainModel { Types = processedTypes }); }
private Dictionary <string, MetadataSet> BuildMetadata(Domain domain, TypeIdRegistry registry) { var model = domain.Model; var metadataGroups = model.Databases.ToDictionary(db => db.Name, db => new MetadataSet()); if (metadataGroups.Count == 0) { metadataGroups.Add(string.Empty, new MetadataSet()); } foreach (var group in metadataGroups) { var database = group.Key; var metadata = group.Value; Func <TypeInfo, bool> filter = t => t.MappingDatabase == database; var types = model.Types.Where(filter).ToList(); var typeMetadata = GetTypeMetadata(types, registry); var assemblies = types.Select(t => t.UnderlyingType.Assembly).ToHashSet(); var assemblyMetadata = GetAssemblyMetadata(assemblies); var storedModel = model.ToStoredModel(registry, filter); // Since we support storage nodes, stored domain model and real model of a node // must be synchronized. So we must update types' mappings storedModel.UpdateMappings(UpgradeContext.NodeConfiguration); var serializedModel = storedModel.Serialize(); var modelExtension = new ExtensionMetadata(WellKnown.DomainModelExtensionName, serializedModel); var indexesExtension = GetPartialIndexes(domain, types); metadata.Assemblies.AddRange(assemblyMetadata); metadata.Types.AddRange(typeMetadata); metadata.Extensions.Add(modelExtension); if (indexesExtension != null) { metadata.Extensions.Add(indexesExtension); } } return(metadataGroups); }
private IEnumerable <TypeInfo> GetTypesWithoutTypeId(TypeIdRegistry registry) { return(domain.Model.Types.Where(t => t.IsEntity && !registry.Contains(t))); }
private void SaveFullTypeMap(TypeIdRegistry registry) { UpgradeContext.FullTypeMap = registry.Types.ToDictionary(t => t.UnderlyingType.GetFullName(), t => registry[t]); }
private static IEnumerable <TypeMetadata> GetTypeMetadata(IEnumerable <TypeInfo> types, TypeIdRegistry registry) { return(types .Where(t => t.IsEntity && registry.Contains(t)) .Select(type => new TypeMetadata(registry[type], type.UnderlyingType.GetFullName()))); }