public static IForeignKey <TDatabase, TTable> ForeignKey <TDatabase, TTable, TReference>(this IForeignKeyBuilder <TDatabase, TTable> @this, Expression <Func <TTable, object> > keyColumns, Expression <Func <TDatabase, IEnumerable <TReference> > > referenceTable, Expression <Func <TReference, object> > referenceColumns, ForeignKeyAction updateAction = ForeignKeyAction.Cascade, ForeignKeyAction deleteAction = ForeignKeyAction.Cascade, string name = null) { var builder = @this as InternalTableBuilder <TDatabase, TTable>; var tempKeyColumns = ExpressionHelpers.ParseMultiPropertySelector(keyColumns ?? throw ModelBuilderError.ArgumentNull(nameof(keyColumns)).AsException()).MatchColumns(builder.Name, builder.Columns); var tempReferenceTable = ExpressionHelpers.ParseSelector(referenceTable ?? throw ModelBuilderError.ArgumentNull(nameof(referenceTable)).AsException()); var tempReferenceColumns = ExpressionHelpers.ParseMultiPropertySelector(referenceColumns ?? throw ModelBuilderError.ArgumentNull(nameof(referenceColumns)).AsException()); if (tempKeyColumns.Length != tempReferenceColumns.Length) { throw ModelBuilderError.ForeignKeyColumnCountsDontMatch().AsException(); } builder.ForeignKeys.Add(new ForeignKeyModel(name: name, keyColumns: tempKeyColumns.ToImmutableArray(), referenceTable: tempReferenceTable, referenceColumns: tempReferenceColumns.ToImmutableArray(), updateAction: updateAction, deleteAction: deleteAction)); return(builder); }
public static ITable <TDatabase, TTable> Table <TDatabase, TTable>(this ITableBuilder <TDatabase> @this, Expression <Func <TDatabase, IEnumerable <TTable> > > table, string name = null, string schema = null) { var builder = new InternalTableBuilder <TDatabase, TTable>((@this as TableBuilder <TDatabase>).DatabaseBuilder) { Property = ExpressionHelpers.ParsePropertySelector(table ?? throw ModelBuilderError.ArgumentNull(nameof(table)).AsException()), Schema = schema }; builder.Name = name ?? builder.Property.Name; { var priorTable = builder.DatabaseBuilder.Tables.FirstOrDefault(t => t.Property.Name == builder.Property.Name); if (priorTable != null) { throw ModelBuilderError.TableRepeatedSelector(database: typeof(TDatabase).Name, property: builder.Property.Name, otherTable: BuilderHelper.GetTableName(priorTable.Schema, priorTable.Name)).AsException(); } } if (builder.DatabaseBuilder.Tables.Any(t => t.Schema == builder.Schema && t.Name == builder.Name)) { throw ModelBuilderError.TableRepeatedName(BuilderHelper.GetTableName(builder.Schema, builder.Name)).AsException(); } return(builder); }
public async void Column__Error_On_Identity_Column_Nullable(string errorLocation, string column) { var mb = @"mb.Database(nameof(Database)) .Table(d => d.Table(t => t.Users) " + string.Format(column, errorLocation) + @" .Build()) .Build();"; await VerifyErrorRaised(mb, ModelBuilderError.ColumnIdentityNullable(), errorLocation); }
public async void Error_On_Enum_Max_Length_Bigger_Than_String_Size(string errorLocation, string column) { var mb = @"mb.Database(nameof(Database)) .Table(d => d.Table(t => t.Users) " + string.Format(column, errorLocation) + @" .Build()) .Build();"; await VerifyErrorRaised(mb, ModelBuilderError.ColumnEnumLongerThanMaxStringSize("UserType.Winner", 2), errorLocation); }
public async void Error_On_Enum_Backed_Column_Not_String_Or_Integral_Type(string errorLocation, string column) { var mb = @"mb.Database(nameof(Database)) .Table(d => d.Table(t => t.Users) " + string.Format(column, errorLocation) + @" .Build()) .Build();"; await VerifyErrorRaised(mb, ModelBuilderError.ColumnEnumNotStringOrIntegralType(), errorLocation); }
public async void Column__Error_On_Repeated_Column_Name(string errorLocation, string column) { var mb = @"mb.Database(nameof(Database)) .Table(d => d.Table(t => t.Users) .Column(t => t.UserId, SqlType.Int, name: ""FirstName"") " + string.Format(column, errorLocation) + @" .Build()) .Build();"; await VerifyErrorRaised(mb, ModelBuilderError.ColumnRepeatedName("Users", "FirstName"), errorLocation); }
public async void Column__Error_On_Repeated_Column_Selector() { var selector = "t => t.UserId"; var mb = @"mb.Database(nameof(Database)) .Table(d => d.Table(t => t.Users) .Column(" + selector + @", SqlType.Int, name: ""A"") .Column(" + selector + @", SqlType.Int) .Build()) .Build();"; await VerifyErrorRaised(mb, ModelBuilderError.ColumnRepeatedSelector("User", "UserId", "A"), selector); }
static FuzzyTableModel ParseTableTable(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax expression, FuzzyDatabaseModel partialDatabase) { var arguments = AH.ParseArguments(context, expression); var tableArg = arguments["table"]; var nameArg = arguments["name"]; var schemaArg = arguments["schema"]; if (AH.IsNull(context, tableArg)) { context.ReportDiagnostic(BuilderError.ArgumentNull("table").MakeDiagnostic(tableArg.Expression.GetLocation())); } var property = AH.ParseSelector(context, tableArg); var fuzzyTableModel = new FuzzyTableModel() { Property = property, Columns = new List <FuzzyColumnModel>(), Indexes = new List <FuzzyIndexModel>(), ForeignKeys = new List <FuzzyForeignKeyModel>(), Schema = AH.ParseConstantArgument(context, schemaArg, () => AH.Just(null as string)), Name = AH.ParseConstantArgument(context, nameArg, () => property.HasValue ? AH.Just(property.Value?.Name) : new Optional <string>()) }; if (fuzzyTableModel.Property.HasValue) { var priorTable = partialDatabase.Tables.FirstOrDefault(t => t.Property.HasValue && t.Property.Value.Name == fuzzyTableModel.Property.Value.Name); if (priorTable != null) { context.ReportDiagnostic(ModelBuilderError.TableRepeatedSelector(ToString(partialDatabase.Name), ToString(fuzzyTableModel.Property), ToString(priorTable)).MakeDiagnostic(tableArg.GetLocation())); } } if (fuzzyTableModel.Name.HasValue && fuzzyTableModel.Schema.HasValue) { var priorTable = partialDatabase.Tables.FirstOrDefault(t => t.Name.HasValue && t.Schema.HasValue && t.Name.Value == fuzzyTableModel.Name.Value && t.Schema.Value == fuzzyTableModel.Schema.Value); if (priorTable != null) { context.ReportDiagnostic(ModelBuilderError.TableRepeatedName(ToString(priorTable)).MakeDiagnostic(nameArg != null ? nameArg.GetLocation() : tableArg.GetLocation(), schemaArg != null ? new List <Location>() { schemaArg.GetLocation() } : null)); } } return(fuzzyTableModel); }
public static IIndex <TDatabase, TTable> Index <TDatabase, TTable>(this IIndexBuilder <TDatabase, TTable> @this, Expression <Func <IOrderFilter <TTable>, object> > keyColumns, bool unique = false, string name = null, bool clustered = false, Expression <Func <TTable, object> > includedColumns = null) { var builder = @this as InternalTableBuilder <TDatabase, TTable>; var indexKeyColumns = ExpressionHelpers.ParseOrderedMultiPropertySelector(keyColumns ?? throw ModelBuilderError.ArgumentNull(nameof(keyColumns)).AsException()).MatchColumns(builder.Name, builder.Columns); var indexIncludedColumns = includedColumns == null?ImmutableArray.Create <ColumnModel>() : ExpressionHelpers.ParseMultiPropertySelector(includedColumns).MatchColumns(builder.Name, builder.Columns); var indexName = name ?? BuilderHelper.GenerateKeyName("IX", builder.Schema, builder.Name, indexKeyColumns.Select(c => c.Name)); if (clustered) { var priorClustered = builder.PrimaryKey?.IsClustered == true ? builder.PrimaryKey.Name : builder.Indexes.FirstOrDefault(i => i.IsClustered)?.Name; if (priorClustered != null) { throw ModelBuilderError.IndexClusteredAlreadySpecified(priorClustered).AsException(); } } { var column = indexIncludedColumns.FirstOrDefault(i => indexKeyColumns.Any(k => k.Property.Name == i.Property.Name)); if (column != null) { throw ModelBuilderError.IndexIncludedColumnAlreadyInKeyColumns(column.Name).AsException(); } } builder.Indexes.Add(new IndexModel(name: indexName, keyColumns: indexKeyColumns.ToImmutableArray(), isUnique: unique, isClustered: clustered, includedColumns: indexIncludedColumns.ToImmutableArray())); return(builder); }
static void ParseDatabaseBuild(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax expression) { var innerModel = ParseDatabaseChain(context, expression); foreach (var table in innerModel.Tables) { foreach (var foreignKey in table.ForeignKeys) { if (foreignKey.ReferenceTableSelector.HasValue) { var referenceTable = innerModel.Tables.FirstOrDefault(t => t.Property.HasValue && t.Property.Value.Name == foreignKey.ReferenceTableSelector.Value.Item1.Name); if (referenceTable == null) { context.ReportDiagnostic(BuilderError.SelectorNotMappedToTable(foreignKey.ReferenceTableSelector.Value.Item1.Name, ToString(innerModel.Name)).MakeDiagnostic(foreignKey.ReferenceTableSelector.Value.Item2)); foreignKey.ReferenceTable = new Optional <FuzzyTableModel>(); break; } else { foreignKey.ReferenceTable = new Optional <FuzzyTableModel>(referenceTable); } foreignKey.ReferenceColumns = AH.MatchColumns(context, foreignKey.ReferenceColumnSelectors.Value, referenceTable.Columns, ToString(referenceTable.Name)); if (!foreignKey.Name.HasValue && table.Schema.HasValue && table.Name.HasValue && foreignKey.KeyColumns.HasValue && foreignKey.KeyColumns.Value.All(k => k.Model.Name.HasValue) && foreignKey.ReferenceTable.HasValue && foreignKey.ReferenceTable.Value.Schema.HasValue && foreignKey.ReferenceTable.Value.Name.HasValue) { foreignKey.Name = BuilderHelper.GenerateForeignKeyName(table.Schema.Value, table.Name.Value, foreignKey.KeyColumns.Value.Select(k => k.Model.Name.Value), foreignKey.ReferenceTable.Value.Schema.Value, foreignKey.ReferenceTable.Value.Name.Value); } if (foreignKey.KeyColumns.HasValue) { foreach (var columnPair in foreignKey.KeyColumns.Value.Zip(foreignKey.ReferenceColumns.Value, (l, r) => (l, r))) { if (columnPair.Item1.Model.Type.HasValue && columnPair.Item2.Model.Type.HasValue && columnPair.Item1.Model.Type.Value != columnPair.Item2.Model.Type.Value) { context.ReportDiagnostic(ModelBuilderError.ForeignKeyColumnTypesDontMatch(foreignKeyName: ToString(foreignKey.Name), keyColumnName: ToString(columnPair.Item1.Model.Name), keyColumnType: columnPair.Item1.Model.Type.Value.ToString(), referenceColumnName: ToString(columnPair.Item2.Model.Name), referenceColumnType: columnPair.Item2.Model.Type.Value.ToString()).MakeDiagnostic(columnPair.Item1.Location, new List <Location>() { columnPair.Item2.Location })); } } } } } } }
static FuzzyTableModel ParseTableIndex(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax expression, FuzzyDatabaseModel partialDatabase) { var innerModel = ParseTableChain(context, expression, partialDatabase); var arguments = AH.ParseArguments(context, expression); var keyColumnsArg = arguments["keyColumns"]; var uniqueArg = arguments["unique"]; var nameArg = arguments["name"]; var clusteredArg = arguments["clustered"]; var includedColumnsArg = arguments["includedColumns"]; var keyColumns = new Optional <ImmutableArray <(SortOrder, FuzzyColumnModel)> >(); if (AH.IsNull(context, keyColumnsArg)) { context.ReportDiagnostic(BuilderError.ArgumentNull("keyColumns").MakeDiagnostic(keyColumnsArg.GetLocation())); } else { var props = AH.ParseOrderedMultiProperty(context, keyColumnsArg); if (props.HasValue) { keyColumns = AH.MatchColumns(context, props.Value, innerModel.Columns, ToString(innerModel.Name)); } } var includedColumns = new Optional <ImmutableArray <FuzzyColumnModel> >(); if (!AH.IsNull(context, includedColumnsArg)) { var props = AH.ParseMultiProperty(context, includedColumnsArg); if (props.HasValue) { var match = AH.MatchColumns(context, props.Value, innerModel.Columns, ToString(innerModel.Name)); includedColumns = match.HasValue ? AH.Just(match.Value.Select(m => m.Item1).ToImmutableArray()) : new Optional <ImmutableArray <FuzzyColumnModel> >(); if (keyColumns.HasValue) { var column = props.Value.Select(v => ((FuzzyProperty, Location)?)v) .FirstOrDefault(i => keyColumns.Value.Any(k => k.Item2.Property.HasValue && k.Item2.Property.Value.Name == i.Value.Item1.Name)); if (column != null) { context.ReportDiagnostic(ModelBuilderError.IndexIncludedColumnAlreadyInKeyColumns(column.Value.Item1.Name).MakeDiagnostic(column.Value.Item2)); } } } } var fuzzyIndex = new FuzzyIndexModel() { KeyColumns = keyColumns, IsUnique = AH.ParseConstantArgument(context, uniqueArg, () => AH.Just(false)), IsClustered = AH.ParseConstantArgument(context, clusteredArg, () => AH.Just(false)), IncludedColumns = includedColumns, Name = AH.ParseConstantArgument(context, nameArg, () => (!innerModel.Name.HasValue || !innerModel.Schema.HasValue || !keyColumns.HasValue || keyColumns.Value.Any(c => !c.Item2.Name.HasValue)) ? new Optional <string>() : AH.Just(BuildDefaultKeyName("IX", innerModel.Schema.Value, innerModel.Name.Value, keyColumns.Value.Select(c => c.Item2.Name.Value)))) }; if (fuzzyIndex.IsClustered.HasValue && fuzzyIndex.IsClustered.Value == true) { var priorClustered = (innerModel.PrimaryKey?.IsClustered)?.HasValue == true && innerModel.PrimaryKey.IsClustered.Value ? innerModel.PrimaryKey.Name.Value : innerModel.Indexes.FirstOrDefault(i => i.IsClustered.HasValue && i.IsClustered.Value)?.Name.Value; if (priorClustered != null) { context.ReportDiagnostic(ModelBuilderError.IndexClusteredAlreadySpecified(priorClustered).MakeDiagnostic(clusteredArg.Expression.GetLocation())); } } innerModel.Indexes.Add(fuzzyIndex); return(innerModel); }
public async void Error_On_Column_Counts_Not_Matching(string location1, string location2, string foreignKey) { await VerifyForeignKeyErrorRaised(ModelBuilderError.ForeignKeyColumnCountsDontMatch(), foreignKey, location1, location2); }
public async void Error_On_Clustered_When_Previous_Index_Or_Primary_Key_Clustered(string location, string indexName, string index) { await VerifyIndexErrorRaised(ModelBuilderError.IndexClusteredAlreadySpecified(indexName), location, index); }
public async void Error_On_IncludedColumn_Already_In_KeyColumns(string location, string index) { await VerifyIndexErrorRaised(ModelBuilderError.IndexIncludedColumnAlreadyInKeyColumns("UserId"), location, index); }
public static IColumn <TDatabase, TTable> Column <TDatabase, TTable, TColumn>(this IColumnBuilder <TDatabase, TTable> @this, Expression <Func <TTable, TColumn> > column, SqlType type, bool nullable = false, int?maxLength = null, string name = null, TColumn defaultValue = default(TColumn), bool identity = false, IDatabaseTypeConverter <TColumn> converter = null) { var builder = @this as InternalTableBuilder <TDatabase, TTable>; var property = ExpressionHelpers.ParsePropertySelector(column ?? throw ModelBuilderError.ArgumentNull(nameof(column)).AsException()); { var priorColumn = builder.Columns.FirstOrDefault(c => c.Property.Name == property.Name); if (priorColumn != null) { throw ModelBuilderError.ColumnRepeatedSelector(typeof(TTable).Name, property.Name, priorColumn.Name).AsException(); } } var columnName = name ?? property.Name; if (builder.Columns.Any(t => t.Name == columnName)) { throw ModelBuilderError.ColumnRepeatedName(builder.Name, columnName).AsException(); } if (nullable && identity) { throw ModelBuilderError.ColumnIdentityNullable().AsException(); } if (property.Type.GetTypeInfo().IsEnum) { if (!(type == SqlType.String || SqlTypeHelpers.IsIntegral(type))) { throw ModelBuilderError.ColumnEnumNotStringOrIntegralType().AsException(); } var values = Enum.GetValues(property.Type); if (type == SqlType.String) { var maxValue = values.Cast <object>() .Select(e => e.ToString()) .OrderByDescending(e => e.Length) .First(); if (maxLength != null && maxValue.Length > maxLength) { throw ModelBuilderError.ColumnEnumLongerThanMaxStringSize($"{property.Type.ToString()}.{maxValue}", (int)maxLength).AsException(); } } else { } } builder.Columns.Add(new ColumnModel(name: columnName, property: property, sqlType: type, isNullable: nullable, isIdentity: identity, defaultValue: defaultValue)); return(builder); }
static FuzzyTableModel ParseTableColumn(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax expression, FuzzyDatabaseModel partialDatabase) { var innerModel = ParseTableChain(context, expression, partialDatabase); var arguments = AH.ParseArguments(context, expression); var columnArg = arguments["column"]; var typeArg = arguments["type"]; var nullableArg = arguments["nullable"]; var maxLengthArg = arguments["maxLength"]; var nameArg = arguments["name"]; var defaultValueArg = arguments["defaultValue"]; var identityArg = arguments["identity"]; var converterArg = arguments["converter"]; if (AH.IsNull(context, columnArg)) { context.ReportDiagnostic(BuilderError.ArgumentNull("column").MakeDiagnostic(columnArg.GetLocation())); } var property = AH.ParseSelector(context, columnArg); var fuzzyColumnModel = new FuzzyColumnModel() { Property = property, MaxLength = AH.ParseConstantArgument(context, maxLengthArg, () => AH.Just(null as int?)), IsIdentity = AH.ParseConstantArgument(context, identityArg, () => AH.Just(false)), IsNullable = AH.ParseConstantArgument(context, nullableArg, () => AH.Just(false)), Type = AH.ParseConstantArgument(context, typeArg, () => new Optional <SqlType>()), Name = AH.ParseConstantArgument(context, nameArg, () => !property.HasValue ? new Optional <string>() : AH.Just(property.Value?.Name)) }; if (fuzzyColumnModel.Property.HasValue) { var otherColumn = innerModel.Columns.FirstOrDefault(t => t.Property.HasValue && t.Property.Value.Name == fuzzyColumnModel.Property.Value.Name); if (otherColumn != null) { context.ReportDiagnostic(ModelBuilderError.ColumnRepeatedSelector(ToTypeString(innerModel.Property), ToString(fuzzyColumnModel.Property), ToString(otherColumn.Name)).MakeDiagnostic(columnArg.GetLocation())); } } if (fuzzyColumnModel.Name.HasValue) { if (innerModel.Columns.Any(c => c.Name.HasValue && c.Name.Value == fuzzyColumnModel.Name.Value)) { context.ReportDiagnostic(ModelBuilderError.ColumnRepeatedName(ToString(innerModel.Name), ToString(fuzzyColumnModel.Name)).MakeDiagnostic(nameArg == null ? columnArg.GetLocation() : nameArg.GetLocation())); } } if (fuzzyColumnModel.Property.HasValue && fuzzyColumnModel.Type.HasValue) { if (fuzzyColumnModel.Property.Value.Type.TypeKind == TypeKind.Enum) { if (!(fuzzyColumnModel.Type.Value == SqlType.String || SqlTypeHelpers.IsIntegral(fuzzyColumnModel.Type.Value))) { context.ReportDiagnostic(ModelBuilderError.ColumnEnumNotStringOrIntegralType().MakeDiagnostic(typeArg.GetLocation())); } if (fuzzyColumnModel.Type.Value == SqlType.String && fuzzyColumnModel.MaxLength.HasValue) { var namedType = fuzzyColumnModel.Property.Value.Type as INamedTypeSymbol; var longestEnum = namedType.MemberNames.OrderByDescending(n => n.Length).First(); if (fuzzyColumnModel.MaxLength.Value != null && longestEnum.Length > fuzzyColumnModel.MaxLength.Value) { context.ReportDiagnostic(ModelBuilderError.ColumnEnumLongerThanMaxStringSize($"{namedType.Name}.{longestEnum}", (int)fuzzyColumnModel.MaxLength.Value).MakeDiagnostic(maxLengthArg.GetLocation())); } } } else if (fuzzyColumnModel.Property.Value.Type.Name == "DateTimeOffset" || fuzzyColumnModel.Property.Value.Type.Name == "Guid") { //if ((fuzzyColumnModel.Property.Value.Type.Name == "DateTimeOffset" && fuzzyColumnModel.Type.Value != SqlType.DateTimeOffset) || // (fuzzyColumnModel.Property.Value.Type.Name == "Guid" && fuzzyColumnModel.Type.Value != SqlType.Guid)) // context.ReportDiagnostic(Diagnostic.Create(_descriptors[InvalidSqlType], typeArg.GetLocation())); } else { var propertyType = fuzzyColumnModel.Property.Value.Type.SpecialType; //if (!_defaultTypeMappings[propertyType].Contains(fuzzyColumnModel.Type.Value)) // context.ReportDiagnostic(Diagnostic.Create(_descriptors[InvalidSqlType], typeArg.GetLocation())); } } if (fuzzyColumnModel.Type.HasValue && fuzzyColumnModel.IsIdentity.HasValue && fuzzyColumnModel.IsIdentity.Value == true) { var nonIdentityTypes = new List <SqlType>() { SqlType.String, SqlType.Bit, SqlType.Date, SqlType.Time, SqlType.DateTime, SqlType.DateTimeOffset, SqlType.Single, SqlType.Double, SqlType.Guid }; //if (nonIdentityTypes.Contains(fuzzyColumnModel.Type.Value)) // context.ReportDiagnostic(Diagnostic.Create(_descriptors[InvalidSqlTypeForIdentity], identityArg.GetLocation())); } if (fuzzyColumnModel.IsIdentity.HasValue && fuzzyColumnModel.IsIdentity.Value == true && fuzzyColumnModel.IsNullable.HasValue && fuzzyColumnModel.IsNullable.Value == true) { context.ReportDiagnostic(ModelBuilderError.ColumnIdentityNullable().MakeDiagnostic(nullableArg.GetLocation())); } innerModel.Columns.Add(fuzzyColumnModel); return(innerModel); }
public async void Error_On_Column_Types_Not_Matching(string location1, string location2, string foreignKey) { await VerifyForeignKeyErrorRaised(ModelBuilderError.ForeignKeyColumnTypesDontMatch("FK_Users__UserType__Addresses", "UserType", "String", "AddressId", "Int"), foreignKey, location1, location2); }
static FuzzyTableModel ParseTableForeignKey(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax expression, FuzzyDatabaseModel partialDatabase) { var innerModel = ParseTableChain(context, expression, partialDatabase); var arguments = AH.ParseArguments(context, expression); var keyColumnsArg = arguments["keyColumns"]; var referenceTableArg = arguments["referenceTable"]; var referenceColumnsArg = arguments["referenceColumns"]; var updateActionArg = arguments["updateAction"]; var deleteActionArg = arguments["deleteAction"]; var nameArg = arguments["name"]; var fuzzyForeignKey = new FuzzyForeignKeyModel(); if (AH.IsNull(context, keyColumnsArg)) { context.ReportDiagnostic(BuilderError.ArgumentNull("keyColumns").MakeDiagnostic(keyColumnsArg.Expression.GetLocation())); fuzzyForeignKey.KeyColumns = new Optional <ImmutableArray <(FuzzyColumnModel, Location)> >(); } else { var keyColumns = AH.ParseMultiProperty(context, keyColumnsArg); if (keyColumns.HasValue) { fuzzyForeignKey.KeyColumns = AH.MatchColumns(context, keyColumns.Value, innerModel.Columns, ToString(innerModel.Name)); } } if (AH.IsNull(context, referenceTableArg)) { context.ReportDiagnostic(BuilderError.ArgumentNull("referenceTable").MakeDiagnostic(referenceTableArg.Expression.GetLocation())); fuzzyForeignKey.ReferenceTableSelector = new Optional <(FuzzyProperty, Location)>(); } else { var selector = AH.ParseSelector(context, referenceTableArg); fuzzyForeignKey.ReferenceTableSelector = selector.HasValue ? AH.Just((selector.Value, (referenceTableArg.Expression as LambdaExpressionSyntax).Body.GetLocation())) : new Optional <(FuzzyProperty, Location)>(); } if (AH.IsNull(context, referenceColumnsArg)) { context.ReportDiagnostic(BuilderError.ArgumentNull("referenceColumns").MakeDiagnostic(referenceColumnsArg.Expression.GetLocation())); fuzzyForeignKey.ReferenceColumnSelectors = new Optional <ImmutableArray <(FuzzyProperty, Location)> >(); } else { fuzzyForeignKey.ReferenceColumnSelectors = AH.ParseMultiProperty(context, referenceColumnsArg); } if (fuzzyForeignKey.KeyColumns.HasValue && fuzzyForeignKey.ReferenceColumnSelectors.HasValue && fuzzyForeignKey.KeyColumns.Value.Length != fuzzyForeignKey.ReferenceColumnSelectors.Value.Length) { context.ReportDiagnostic(ModelBuilderError.ForeignKeyColumnCountsDontMatch().MakeDiagnostic(AH.DeconstructLambda(keyColumnsArg).Body.GetLocation(), new List <Location>() { AH.DeconstructLambda(referenceColumnsArg).Body.GetLocation() })); } fuzzyForeignKey.UpdateAction = AH.ParseConstantArgument(context, updateActionArg, () => AH.Just(ForeignKeyAction.Cascade)); fuzzyForeignKey.DeleteAction = AH.ParseConstantArgument(context, deleteActionArg, () => AH.Just(ForeignKeyAction.Cascade)); innerModel.ForeignKeys.Add(fuzzyForeignKey); return(innerModel); }
public async void Table__Error_On_Repeated_Table_Name(string error, string additionalLocation, string name, string mb) { await VerifyErrorRaised(mb, ModelBuilderError.TableRepeatedName(name), error, additionalLocation); }
public async void Table__Error_On_Repeated_Table_Selector(string error, string mb) { await VerifyErrorRaised(mb, ModelBuilderError.TableRepeatedSelector("Database", "Users", "Users"), error); }
public static IPrimaryKey <TDatabase, TTable> PrimaryKey <TDatabase, TTable>(this IPrimaryKeyBuilder <TDatabase, TTable> @this, Expression <Func <IOrderFilter <TTable>, object> > keyColumns, string name = null, bool clustered = true) { var builder = @this as InternalTableBuilder <TDatabase, TTable>; var columns = ExpressionHelpers.ParseOrderedMultiPropertySelector(keyColumns ?? throw ModelBuilderError.ArgumentNull(nameof(keyColumns)).AsException()) .MatchColumns(builder.Name, builder.Columns); var primaryKeyName = name ?? BuilderHelper.GenerateKeyName("PK", builder.Schema, builder.Name, columns.Select(c => c.Name)); builder.PrimaryKey = new PrimaryKeyModel(primaryKeyName, columns.ToImmutableArray(), clustered); return(builder); }