public void Apply(BuildContext context, BuildStep buildStep, SqlEntityConfiguration sqlEntityConfiguration,
SqlDataModelBuilder sqlDataModelBuilder)
{
if (buildStep != BuildStep.DefineFields)
{
return;
}
sqlDataModelBuilder.ModelledFields.Add(FieldConfiguration);
}
public DataSchemaBuilder AddSqlEntity(SqlEntityConfiguration entityConfiguration)
{
var entityType = entityConfiguration.EntityType;
if (_sqlEntityConfigurations.ContainsKey(entityType))
{
throw new InvalidOperationException("Entity type already registered.");
}
_sqlEntityConfigurations.Add(entityType, entityConfiguration);
return(this);
}
public void Apply(BuildContext context, BuildStep buildStep, SqlEntityConfiguration sqlEntityConfiguration,
SqlDataModelBuilder sqlDataModelBuilder)
{
if (buildStep != BuildStep.DefineRelationships)
{
return;
}
var typeModel = TypeModel.GetModelOf(sqlEntityConfiguration.EntityType);
ModelFields(typeModel.Fields, new string[0]);
void ModelFields(IReadOnlyList <PropertyField> fields, string[] parentPath)
{
foreach (var field in fields)
{
var fieldGraphPath = new FieldGraphPath <PropertyField>(
parentPath.Concat(new[] { field.FieldName }).ToArray(),
field
);
if (SqlTypeHelper.GetDataType(field.FieldType.Type) == null)
{
if (!IsRegisteredEntity(context, field.FieldType.Type))
{
ModelFields(field.FieldModel.Fields, fieldGraphPath.Path);
}
else
{
// build a fk relationship
var model = context.SqlBuilders.First(q => q.EntityType == field.FieldType.Type);
var foreignKeyField = model.ModelledFields.FirstOrDefault(q => q.Options.IsPrimaryKey);
if (foreignKeyField == null)
{
throw new Exception("Referenced entity missing primary key field.");
}
var fieldConfig = SqlFieldConfiguration.Create(field)
.ColumnName($"{string.Join("_", fieldGraphPath.Path)}_{foreignKeyField.Options.ColumnName}")
.DataType(foreignKeyField.Options.SqlDataType)
.IsNullable(true)
.ForeignKey(foreignKeyField.PropertyPath);
fieldConfig.PropertyPath = fieldGraphPath;
sqlDataModelBuilder.ModelledFields.Add(fieldConfig);
}
}
}
}
}
public StorageModelConverter(
SqlEntityConfiguration sqlEntityConfiguration,
BuildContext buildContext
)
{
_currentPath = new List <string>();
_sqlEntityConfiguration = sqlEntityConfiguration;
_buildContext = buildContext;
_modelStateStack = new Stack <IModelState>();
_modelStateStack.Push(new ModelState <TEntity>(
buildContext.SqlBuilders.First(q => q.EntityType == typeof(TEntity)),
new string[0]
));
}
public DataSchemaBuilder AddSqlEntity <TEntity>(
Action <SqlEntityConfiguration <TEntity> > configure = null)
where TEntity : class
{
var entityType = typeof(TEntity);
if (_sqlEntityConfigurations.ContainsKey(entityType))
{
throw new InvalidOperationException("Entity type already registered.");
}
var configuration = new SqlEntityConfiguration <TEntity>();
configure?.Invoke(configuration);
_sqlEntityConfigurations.Add(entityType, configuration);
return(this);
}
public void Apply(BuildContext context, BuildStep buildStep, SqlEntityConfiguration sqlEntityConfiguration,
SqlDataModelBuilder sqlDataModelBuilder)
{
if (buildStep != BuildStep.DefineFields)
{
return;
}
var typeModel = TypeModel.GetModelOf(sqlEntityConfiguration.EntityType);
ModelFields(typeModel.Fields, new string[0]);
void ModelFields(IReadOnlyList <PropertyField> fields, string[] parentPath)
{
foreach (var field in fields)
{
var fieldGraphPath = new FieldGraphPath <PropertyField>(
parentPath.Concat(new[] { field.FieldName }).ToArray(),
field
);
if (FieldAlreadyModelled(sqlDataModelBuilder.ModelledFields, fieldGraphPath))
{
continue;
}
if (SqlTypeHelper.GetDataType(field.FieldType.Type) == null)
{
// not an SQL primitive type, if it's not defined in builder auto-config sub properties
if (IsRegisteredEntity(context, field.FieldType.Type))
{
continue;
}
ModelFields(field.FieldModel.Fields, fieldGraphPath.Path);
}
else
{
sqlDataModelBuilder.ModelledFields.Add(CreateFieldConfiguration(field, fieldGraphPath));
}
}
}
}
public static DataSchema CreateSchemaFromDataContextType(Type dataContextType)
{
if (dataContextType.IsAbstract)
{
throw new InvalidOperationException("Cannot create schema from abstract data context type.");
}
var schemaBuilder = new DataSchemaBuilder();
foreach (var property in dataContextType.GetDataSetProperties())
{
if (property.PropertyType.IsGenericType)
{
var genericArgs = property.PropertyType.GetGenericArguments();
if (property.PropertyType.IsSqlDataSetWithEntityAndBusinessTypes())
{
var sqlEntityConfiguration = SqlEntityConfiguration.Create(
genericArgs[0], genericArgs[1]);
sqlEntityConfiguration.DefaultTableName = property.Name;
AutoConfigureEntityType(sqlEntityConfiguration);
schemaBuilder.AddSqlEntity(sqlEntityConfiguration);
}
else if (property.PropertyType.IsSqlDataSetWithEntityType())
{
var sqlEntityConfiguration = SqlEntityConfiguration.Create(
genericArgs[0]);
sqlEntityConfiguration.DefaultTableName = property.Name;
AutoConfigureEntityType(sqlEntityConfiguration);
schemaBuilder.AddSqlEntity(sqlEntityConfiguration);
}
}
}
AttemptCallConfigure(dataContextType, schemaBuilder);
return(schemaBuilder.Build());
}
public void Apply(BuildContext context, BuildStep buildStep, SqlEntityConfiguration sqlEntityConfiguration,
SqlDataModelBuilder sqlDataModelBuilder)
{
if (buildStep != BuildStep.DefineFields)
{
return;
}
if (sqlDataModelBuilder.ModelledFields.Any(q => q.Options.IsPrimaryKey))
{
return;
}
var idField = sqlDataModelBuilder.ModelledFields.FirstOrDefault(
q => q.PropertyPath.Path.SequenceEqual(new[] { "Id" })
);
if (idField == null)
{
return;
}
idField.PrimaryKey();
}
private static void AutoConfigureEntityType(SqlEntityConfiguration entityConfiguration)
{
}
