public ModelScalarType SuggestType(IModelScalarTypeFacade modelScalarTypeFacade)
{
var result = new ModelScalarType();
if (modelScalarTypeFacade.Nullable.GetValueOrDefault(true))
{
if (this.Type.IsValueType)
{
result.Type = typeof(Nullable <>).MakeGenericType(new Type[] { this.Type });
}
else
{
result.Type = this.Type;
}
}
else
{
result.Type = this.Type;
}
result.Nullable = modelScalarTypeFacade.Nullable;
result.MaxLength = modelScalarTypeFacade.MaxLength;
result.FixedLength = modelScalarTypeFacade.FixedLength;
result.Precision = modelScalarTypeFacade.Precision;
result.Scale = modelScalarTypeFacade.Scale;
result.Unicode = modelScalarTypeFacade.Unicode;
return(result);
}
public ModelScalarType SuggestType(MetaModelBuilder metaModelBuilder)
{
//ModelTypeScalar scalarType = this.Type?.GetScalarType();
ModelSematicScalarType scalarType = this.SqlType.GetScalarType();
var result = new ModelScalarType {
Name = scalarType.Name.GetQFullName("[", 2),
ExternalName = scalarType.GetCondensed(),
MaxLength = this.MaxLength,
Scale = this.Scale,
Precision = this.Precision,
Nullable = this.Nullable,
Type = scalarType.GetClrType()
};
return(result);
}
public ModelScalarType BuildScalarType(EdmxModel edmxModel, ModelSchema modelSchema, CsdlScalarTypeModel scalarTypeModel, MetaModelBuilder metaModelBuilder, ModelErrors errors)
{
if (string.Equals(scalarTypeModel.Namespace, "Edm", StringComparison.Ordinal))
{
return(null);
}
//
#warning BuildScalarType - when does this happen?
var name = scalarTypeModel.Name;
var fullName = scalarTypeModel.FullName;
ModelScalarType result = new ModelScalarType {
Name = name,
ExternalName = fullName
};
modelSchema.ScalarTypes.Add(result);
return(result);
}
public override List <string> Build()
{
var resultErrors = new List <string>();
var modelDefinition = this.ModelDefinition;
var modelSchema = this.ModelSchema ?? (this.ModelSchema = new ModelSchema());
this.EdmModel = null;
IEdmModel edmModel;
using (var reader = new System.IO.StringReader(modelDefinition.MetaData)) {
using (var xmlReader = System.Xml.XmlReader.Create(reader)) {
IEnumerable <EdmError> edmErrors;
var parseResult = Microsoft.Data.Edm.Csdl.EdmxReader.TryParse(xmlReader, out edmModel, out edmErrors);
if (!parseResult)
{
resultErrors.AddRange(edmErrors.Select(_ => _.ErrorMessage));
//throw new InvalidOperationException("Failed to load model : " + string.Join(Environment.NewLine, errors.Select(e => e.ErrorMessage)));
return(resultErrors);
}
}
}
this.EdmModel = edmModel;
// this.Rules.
var lstTypeDefinition = edmModel.SchemaElements.Where(schemaElement => schemaElement.SchemaElementKind == Microsoft.Data.Edm.EdmSchemaElementKind.TypeDefinition).ToList();
var lstValueTerm = edmModel.SchemaElements.Where(schemaElement => schemaElement.SchemaElementKind == Microsoft.Data.Edm.EdmSchemaElementKind.ValueTerm).ToList();
var lstEntityContainer = edmModel.SchemaElements.Where(schemaElement => schemaElement.SchemaElementKind == Microsoft.Data.Edm.EdmSchemaElementKind.EntityContainer).ToList();
var typeDefinitionsByName = new Dictionary <ModelEntityName, ModelTableType>(ModelUtility.Instance.ModelEntityNameEqualityComparer);
var entityByName = new Dictionary <ModelEntityName, ModelEntity>(ModelUtility.Instance.ModelEntityNameEqualityComparer);
foreach (var typeDefinition in lstTypeDefinition)
{
// typeDefinition.FullName
if (typeDefinition is Microsoft.Data.Edm.IEdmStructuredType structuredType)
{
var modelTableType = new ModelTableType();
modelTableType.Name = ConvertToModelEntityName(typeDefinition);
modelSchema.TableTypes.Add(modelTableType);
typeDefinitionsByName[modelTableType.Name] = modelTableType;
var declaredStructuralProperties = structuredType.DeclaredStructuralProperties().ToArray();
var declaredProperties = structuredType.DeclaredProperties.ToArray();
foreach (var declaredProperty in declaredProperties)
{
if (declaredProperty.PropertyKind == EdmPropertyKind.None)
{
var modelProperty = new ModelProperty();
modelProperty.Name = declaredProperty.Name;
// modelProperty.Type
var declaredPropertyType = declaredProperty.Type;
modelTableType.Properties.Add(modelProperty);
}
else if (declaredProperty.PropertyKind == EdmPropertyKind.Structural)
{
var modelProperty = new ModelProperty();
modelProperty.Name = declaredProperty.Name;
// modelProperty.Type
var declaredPropertyType = declaredProperty.Type;
if (declaredPropertyType is IEdmPrimitiveTypeReference primitiveTypeReference)
{
var modelScalarType = new ModelScalarType();
var definition = primitiveTypeReference.Definition;
if (definition is Microsoft.Data.Edm.IEdmSchemaElement definitionAsSchemaElement)
{
var definitionName = ConvertToModelEntityName(definitionAsSchemaElement);
modelScalarType.Name = definitionName;
}
else
{
throw new InvalidOperationException();
}
modelScalarType.IsNullable = primitiveTypeReference.IsNullable;
modelProperty.Type = modelScalarType;
}
else
{
}
modelTableType.Properties.Add(modelProperty);
}
else if (declaredProperty.PropertyKind == EdmPropertyKind.Navigation)
{
var modelProperty = new ModelProperty();
modelProperty.Name = declaredProperty.Name;
modelTableType.Properties.Add(modelProperty);
}
}
}
}
foreach (IEdmSchemaElement schemaElement in lstEntityContainer)
{
if (schemaElement is Microsoft.Data.Edm.IEdmEntityContainer entityContainer)
{
bool isDefaultEntityContainer = false;
var annoIsDefaultEntityContainer = edmModel.DirectValueAnnotationsManager.GetDirectValueAnnotations(entityContainer).FirstOrDefault(_ => _.NamespaceUri == "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" && _.Name == "IsDefaultEntityContainer");
if (annoIsDefaultEntityContainer?.Value is Microsoft.Data.Edm.Library.Values.EdmStringConstant stringConstant)
{
if (string.Equals(stringConstant.Value, "true", StringComparison.OrdinalIgnoreCase) || stringConstant.Value == "1")
{
isDefaultEntityContainer = true;
}
}
else if (annoIsDefaultEntityContainer?.Value is Microsoft.Data.Edm.Library.Values.EdmBooleanConstant booleanConstant)
{
if (booleanConstant.Value)
{
isDefaultEntityContainer = true;
}
}
if (isDefaultEntityContainer)
{
var entityName = ConvertToModelEntityName(entityContainer);
modelSchema.RootEntityName = entityName;
//if (modelSchema.Name == null) {
// modelSchema.Name = entityName;
//}
}
var modelEntityContainer = new ModelEntity();
modelEntityContainer.Name = ConvertToModelEntityName(entityContainer);
modelEntityContainer.Kind = ModelEntityKind.Container;
modelSchema.Entities.Add(modelEntityContainer);
var modelEntityContainerTableType = new ModelTableType();
modelEntityContainerTableType.Name = ConvertToModelEntityName(entityContainer);
modelEntityContainer.TableType = modelEntityContainerTableType;
var elements = entityContainer.Elements;
var entitySets = entityContainer.EntitySets();
foreach (var entitySet in entitySets)
{
var modelEntitySet = new ModelEntity();
modelEntitySet.Name = ConvertToModelEntityName(entitySet, entityContainer);
modelEntitySet.Kind = ModelEntityKind.EntitySet;
var elementTypeName = ConvertToModelEntityName(entitySet.ElementType);
modelEntitySet.TableType = typeDefinitionsByName.GetValueOrDefault(elementTypeName);
modelSchema.Entities.Add(modelEntitySet);
entityByName[modelEntitySet.Name] = modelEntitySet;
//var property = new ModelProperty();
//property.Name = entitySet.Name;
//property.Type = new ModelT;
//modelEntityContainerTableType.Properties.Add(property);
//var modelRelation = new ModelRelation();
//modelRelation.Name = entitySet.Name;
//modelRelation.Master = modelEntityContainer;
//modelRelation.Child = modelEntitySet;
//modelSchema.Relations.Add(modelRelation);
// entitySet.ContainerElementKind== EdmContainerElementKind.EntitySet
// entitySet.ContainerElementKind == EdmContainerElementKind.FunctionImport
}
foreach (var entitySet in entitySets)
{
var entitySetName = ConvertToModelEntityName(entitySet, entityContainer);
var modelEntitySet = entityByName.GetValueOrDefault(entitySetName);
var navigationTargets = entitySet.NavigationTargets;
foreach (var navigationTarget in navigationTargets)
{
var navigationProperty = navigationTarget.NavigationProperty;
var targetEntitySet = navigationTarget.TargetEntitySet;
var targetEntitySetName = targetEntitySet.Name;
var dependentProperties = navigationProperty.DependentProperties;
var partner = navigationProperty.Partner;
var partnerName = partner.Name;
var modelRelation = new ModelRelation();
modelRelation.Name = navigationTarget.NavigationProperty.Name;
modelRelation.Master = modelEntitySet;
modelRelation.Child = null;
//if (targetEntitySet.ElementType is IEdmSchemaElement elementType) {
// modelRelation.Child = entityByName.GetValueOrDefault(ConvertToModelEntityName(elementType));
//}
modelSchema.Relations.Add(modelRelation);
#warning here
}
//- [0] {Microsoft.Data.Edm.Library.EdmNavigationTargetMapping} Microsoft.Data.Edm.IEdmNavigationTargetMapping {Microsoft.Data.Edm.Library.EdmNavigationTargetMapping}
}
}
}
return(resultErrors);
}
public ModelSchema ConvertSchema(IEdmModel edmModel)
{
var entityContainers = edmModel.EntityContainers().ToArray();
var defaultEntityContainer = entityContainers.First(_ => edmModel.IsDefaultEntityContainer(_));
var entitySets = defaultEntityContainer.EntitySets().ToArray();
var modelSchema = new ModelSchema();
var modelEntityRoot = new ModelEntity();
var complexTypeRoot = new ModelComplexType();
// TODO: add ns
modelEntityRoot.Name = new ModelEntityName(defaultEntityContainer.Namespace, null, defaultEntityContainer.Name);
complexTypeRoot.Name = new ModelEntityName(defaultEntityContainer.Namespace, null, defaultEntityContainer.Name);
modelEntityRoot.EntityType = complexTypeRoot;
modelSchema.Entities.Add(modelEntityRoot);
modelEntityRoot.Kind = ModelEntityKind.Container;
foreach (var entitySet in entitySets)
{
var elementType = entitySet.ElementType;
var complexType = new ModelComplexType();
var modelEntity = new ModelEntity();
complexType.Name = new ModelEntityName(elementType.Namespace, null, elementType.Name);
modelEntity.Name = new ModelEntityName(null, null, entitySet.Name);
modelEntity.EntityType = complexType;
modelEntity.Kind = ModelEntityKind.EntitySet;
modelSchema.ComplexTypes.Add(complexType);
modelSchema.Entities.Add(modelEntity);
var declaredStructuralProperties = elementType.DeclaredStructuralProperties().ToArray();
foreach (var declaredStructuralProperty in declaredStructuralProperties)
{
var declaredStructuralPropertyType = declaredStructuralProperty.Type;
var declaredStructuralPropertyTypeDefinition = declaredStructuralPropertyType.Definition;
var modelProperty = new ModelProperty();
modelProperty.Name = declaredStructuralProperty.Name;
if (declaredStructuralPropertyType.IsPrimitive())
{
var modelPropertyType = new ModelScalarType();
var vas = declaredStructuralProperty.VocabularyAnnotations(edmModel).ToArray();
if (declaredStructuralPropertyTypeDefinition is IEdmSchemaElement edmSchemaElement)
{
modelPropertyType.Name = new ModelEntityName(edmSchemaElement.Namespace, null, edmSchemaElement.Name);
}
else
{
modelPropertyType.Name = new ModelEntityName(null, null, declaredStructuralPropertyType.FullName());
}
modelPropertyType.IsNullable = declaredStructuralPropertyType.IsNullable;
modelProperty.Type = modelPropertyType;
}
else
{
throw new NotImplementedException();
}
complexType.Properties.Add(modelProperty);
}
//complexType.Properties
}
foreach (var entitySet in entitySets)
{
var entityName = new ModelEntityName(null, null, entitySet.Name);
var modelEntity = modelSchema.Entities.FirstOrDefault(_ => _.Name == entityName);
var navigationTargets = entitySet.NavigationTargets.ToArray();
foreach (var navigationTarget in navigationTargets)
{
//
var navigationProperty = navigationTarget.NavigationProperty;
if (navigationProperty is IEdmNavigationProperty edmNavigationProperty)
{
if (navigationProperty.ContainsTarget)
{
}
}
var navigationPropertyPartner = navigationProperty.Partner;
var targetEntitySet = navigationTarget.TargetEntitySet;
//
var naviFromProperties = navigationProperty.DependentProperties?.ToArray();
var naviToProperties = navigationPropertyPartner.DependentProperties?.ToArray();
var modelRelation = new ModelRelation();
var targetEntityName = new ModelEntityName(null, null, targetEntitySet.Name);
var targetModelEntity = modelSchema.Entities.FirstOrDefault(_ => _.Name == targetEntityName);
modelRelation.Name = navigationTarget.TargetEntitySet.Name;
//modelRelation.MasterEntity =
//modelRelation.ForeignEntity = targetModelEntity;
modelRelation.ForeignName = targetEntityName;
modelSchema.Relations.Add(modelRelation);
}
}
return(modelSchema);
}
public ModelComplexType BuildComplexType(EdmxModel edmxModel, ModelSchema modelSchema, CsdlEntityTypeModel entityTypeModel, MetaModelBuilder metaModelBuilder, ModelErrors errors)
{
var entityTypeModelName = entityTypeModel.Name;
var entityTypeModelFullName = entityTypeModel.FullName;
var lstFound = modelSchema.ComplexTypes.FindByKey2(entityTypeModelFullName ?? entityTypeModelName);
if (lstFound.Count == 1)
{
return(lstFound[0]);
}
else if (lstFound.Count > 1)
{
errors.AddErrorOrThrow(new ModelErrorInfo($"found key {entityTypeModelFullName ?? entityTypeModelName} #{lstFound.Count} times.", entityTypeModelFullName ?? entityTypeModelName));
return(lstFound[0]);
}
var modelComplexType = metaModelBuilder.CreateModelComplexType(
entityTypeModelName,
entityTypeModelFullName,
errors);
if (modelComplexType.Owner == null)
{
modelSchema.ComplexTypes.Add(modelComplexType);
}
foreach (var property in entityTypeModel.Property)
{
ModelScalarType modelScalarType = null;
ModelScalarType suggestedType = property.SuggestType(metaModelBuilder);
// TODO: thinkof EdmxModelBuilder Build ScalarType
//if (property.ScalarType != null) {
// property.ScalarType.FullName
//}
modelScalarType = metaModelBuilder.CreateModelScalarType(
entityTypeModelName,
entityTypeModelFullName,
property.Name,
null,
property.TypeName,
suggestedType,
property.MaxLength,
property.FixedLength,
property.Nullable,
property.Precision,
property.Scale,
errors
);
var modelProperty = metaModelBuilder.CreateModelProperty(
entityTypeModelName,
entityTypeModelFullName,
property.Name,
null,
errors
);
if (modelProperty.Type == null)
{
modelProperty.Type = modelScalarType;
}
if (modelProperty.Owner == null)
{
modelComplexType.Properties.Add(modelProperty);
}
}
var primaryKey = entityTypeModel.Keys;
if (primaryKey.Count > 0)
{
var modelIndex = metaModelBuilder.CreateModelIndex(
entityTypeModelName,
entityTypeModelFullName,
"PrimaryKey",
null,
errors
);
modelIndex.IsPrimaryKey = true;
if (modelIndex.Owner == null)
{
modelComplexType.Indexes.Add(modelIndex);
}
foreach (var keyModel in entityTypeModel.Keys)
{
var modelIndexProperty = metaModelBuilder.CreateModelIndexProperty(
entityTypeModelName,
entityTypeModelFullName,
modelIndex.Name,
modelIndex.ExternalName,
keyModel.Name,
null,
//keyModel.Property,
errors
);
if (modelIndexProperty.Owner == null)
{
modelIndex.Properties.Add(modelIndexProperty);
}
}
}
return(modelComplexType);
}
public void BuildModelSchema(
ModelSqlDatabase modelDatabase,
ModelSchema modelSchema,
MetaModelBuilder metaModelBuilder,
ModelErrors errors)
{
if (modelSchema == null)
{
modelSchema = new ModelSchema();
}
if (metaModelBuilder == null)
{
metaModelBuilder = new MetaModelBuilder();
}
// modelDatabase.Freeze();
foreach (var table in modelDatabase.Tables)
{
var entityTypeModelName = table.Name.GetQFullName(null, 2);
var entityTypeModelFullName = table.Name.GetQFullName("[", 2);
var modelComplexType = metaModelBuilder.CreateModelComplexType(
entityTypeModelName,
entityTypeModelFullName,
errors);
if (modelComplexType.Owner == null)
{
modelSchema.ComplexTypes.Add(modelComplexType);
}
foreach (var column in table.Columns)
{
ModelScalarType modelScalarType = null;
ModelScalarType suggestedType = column.SuggestType(metaModelBuilder);
modelScalarType = metaModelBuilder.CreateModelScalarType(
entityTypeModelName,
entityTypeModelFullName,
column.Name.GetQName(),
null,
column.SqlType.Name.GetQFullName(),
suggestedType,
column.MaxLength,
column.FixedLength,
column.Nullable,
column.Precision,
column.Scale,
errors
);
var columnName = column.Name.GetQFullName(null, 1);
var columnExternalName = column.Name.GetQFullName("[", 1);
var modelProperty = metaModelBuilder.CreateModelProperty(
entityTypeModelName,
entityTypeModelFullName,
columnName,
columnExternalName,
errors
);
if (modelProperty.Type == null)
{
modelProperty.Type = modelScalarType;
}
if (modelProperty.Owner == null)
{
modelComplexType.Properties.Add(modelProperty);
}
}
var tableIndexes = table.Indexes.ToList();
var lstPrimaryIndex = tableIndexes.Where(sqlIndex => sqlIndex.IsPrimaryKey).ToList();
var primaryIndex = lstPrimaryIndex.FirstOrDefault();
if (lstPrimaryIndex.Count == 1)
{
//var sqlIndex = lstPrimaryIndex[0];
// OK
}
else if (lstPrimaryIndex.Count > 1)
{
errors.AddErrorOrThrow($"More than one ({lstPrimaryIndex.Count}) primary key.", table.NameSql);
}
else
{
#warning think of no primary key
}
foreach (var sqlIndex in tableIndexes)
{
#warning have indexes a schema??
var modelIndex = metaModelBuilder.CreateModelIndex(entityTypeModelName, entityTypeModelFullName, sqlIndex.Name.Name, sqlIndex.Name.Name, errors);
//modelIndex.IsPrimaryKey = sqlIndex.IsPrimaryKey;
modelIndex.IsPrimaryKey = ReferenceEquals(sqlIndex, primaryIndex);
modelComplexType.Indexes.Add(modelIndex);
foreach (var column in sqlIndex.Columns)
{
var modelIndexProperty = metaModelBuilder.CreateModelIndexProperty(
entityTypeModelName,
entityTypeModelFullName,
sqlIndex.Name.Name,
sqlIndex.Name.Name,
column.Name.Name,
null,
errors
);
modelIndex.Properties.Add(modelIndexProperty);
}
}
var entitySetName = table.Name.GetQFullName(null, 2);
var modelEntity = metaModelBuilder.CreateModelEntity(
entitySetName,
ModelEntityKind.EntitySet,
errors);
if (modelEntity.Owner == null)
{
modelSchema.Entities.Add(modelEntity);
}
modelEntity.EntityType = modelComplexType;
}
}
