public static void Ctor_GivenChildKeysWithNullValue_ThrowsArgumentNullException()
{
Identifier tableName = "test_table";
var columns = new[] { Mock.Of <IDatabaseColumn>() };
var primaryKey = Option <IDatabaseKey> .None;
var uniqueKeys = Array.Empty <IDatabaseKey>();
var parentKeys = Array.Empty <IDatabaseRelationalKey>();
var childKeys = new IDatabaseRelationalKey[] { null };
var indexes = Array.Empty <IDatabaseIndex>();
var checks = Array.Empty <IDatabaseCheckConstraint>();
var triggers = Array.Empty <IDatabaseTrigger>();
Assert.That(() => new RelationalDatabaseTable(tableName, columns, primaryKey, uniqueKeys, parentKeys, childKeys, indexes, checks, triggers), Throws.ArgumentNullException);
}
public Constraints.ForeignKey MapForeignKey(IDatabaseRelationalKey foreignKey)
{
if (foreignKey == null)
{
throw new ArgumentNullException(nameof(foreignKey));
}
var childKeyName = foreignKey.ChildKey.Name.Match(fkName => fkName.LocalName, () => string.Empty);
var childColumnNames = foreignKey.ChildKey.Columns.Select(c => c.Name.LocalName).ToList();
var parentKeyName = foreignKey.ParentKey.Name.Match(pkName => pkName.LocalName, () => string.Empty);
var parentColumnNames = foreignKey.ParentKey.Columns.Select(c => c.Name.LocalName).ToList();
return(new Constraints.ForeignKey(
foreignKey.ChildTable,
childKeyName,
childColumnNames,
foreignKey.ParentTable,
parentKeyName,
parentColumnNames,
foreignKey.DeleteAction,
foreignKey.UpdateAction
));
}
private static SyntaxTriviaList BuildChildKeyComment(IDatabaseRelationalKey relationalKey)
{
if (relationalKey == null)
{
throw new ArgumentNullException(nameof(relationalKey));
}
var hasChildKeyName = relationalKey.ChildKey.Name.IsSome;
var foreignKeyNameNode = relationalKey.ChildKey.Name.Match(
name => XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(name.LocalName))),
() => XmlText(string.Empty) as XmlNodeSyntax
);
return(SyntaxUtilities.BuildCommentTrivia(new XmlNodeSyntax[]
{
XmlText("The" + (hasChildKeyName ? " " : string.Empty)),
foreignKeyNameNode,
XmlText(" child key. Navigates from "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(relationalKey.ParentTable.LocalName))),
XmlText(" to "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(relationalKey.ChildTable.LocalName))),
XmlText(".")
}));
}
private static SyntaxTriviaList BuildForeignKeyComment(IDatabaseRelationalKey relationalKey, Option <IRelationalDatabaseTableComments> comment)
{
if (relationalKey == null)
{
throw new ArgumentNullException(nameof(relationalKey));
}
var hasChildKeyName = relationalKey.ChildKey.Name.IsSome;
return(comment
.Bind(c => relationalKey.ChildKey.Name
.Match(
ckName => c.ForeignKeyComments.TryGetValue(ckName, out var fkc) ? fkc : Option <string> .None,
() => Option <string> .None))
.Match(
SyntaxUtilities.BuildCommentTrivia,
() =>
{
var foreignKeyNameNode = relationalKey.ChildKey.Name.Match(
name => XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(name.LocalName))),
() => XmlText(string.Empty) as XmlNodeSyntax
);
return SyntaxUtilities.BuildCommentTrivia(new XmlNodeSyntax[]
{
XmlText("The" + (hasChildKeyName ? " " : string.Empty)),
foreignKeyNameNode,
XmlText(" foreign key. Navigates from "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(relationalKey.ChildTable.LocalName))),
XmlText(" to "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(relationalKey.ParentTable.LocalName))),
XmlText(".")
});
}
));
}
private InvocationExpressionSyntax BuildTableChildKeyForBuilder(IRelationalDatabaseTable table, IDatabaseRelationalKey relationalKey)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
if (relationalKey == null)
{
throw new ArgumentNullException(nameof(relationalKey));
}
var schemaNamespace = NameTranslator.SchemaToNamespace(table.Name);
var className = NameTranslator.TableToClassName(table.Name);
var qualifiedClassName = !schemaNamespace.IsNullOrWhiteSpace()
? schemaNamespace + "." + className
: className;
var childSetName = className.Pluralize();
var childKey = relationalKey.ChildKey;
var parentPropertyName = NameTranslator.TableToClassName(relationalKey.ParentTable);
var entity = GetEntityBuilder(qualifiedClassName);
var parentKeyBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
entity,
IdentifierName(nameof(EntityTypeBuilder.HasOne))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
SimpleLambdaExpression(
Parameter(
Identifier(EntityLambdaParameterName)),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(EntityLambdaParameterName),
IdentifierName(parentPropertyName)))))));
parentKeyBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
parentKeyBuilder,
IdentifierName(nameof(ReferenceNavigationBuilder.WithMany))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
SimpleLambdaExpression(
Parameter(
Identifier(EntityLambdaParameterName)),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
PostfixUnaryExpression(
SyntaxKind.SuppressNullableWarningExpression,
IdentifierName(EntityLambdaParameterName)),
IdentifierName(childSetName)))))));
parentKeyBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
parentKeyBuilder,
IdentifierName(nameof(ReferenceCollectionBuilder.HasForeignKey))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
GenerateColumnSet(className, childKey.Columns, false)))));
parentKeyBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
parentKeyBuilder,
IdentifierName(nameof(ReferenceCollectionBuilder.HasPrincipalKey))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
GenerateColumnSet(className, relationalKey.ParentKey.Columns, true)))));
relationalKey.ChildKey.Name.IfSome(childKeyName =>
{
parentKeyBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
parentKeyBuilder,
IdentifierName(nameof(RelationalForeignKeyBuilderExtensions.HasConstraintName))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(childKeyName.LocalName))))));
});
return(parentKeyBuilder);
}
private PropertyDeclarationSyntax BuildChildKey(IEnumerable <IRelationalDatabaseTable> tables, IDatabaseRelationalKey relationalKey, string className, string propertyName)
{
if (tables == null)
{
throw new ArgumentNullException(nameof(tables));
}
if (relationalKey == null)
{
throw new ArgumentNullException(nameof(relationalKey));
}
if (className.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(className));
}
if (propertyName.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(propertyName));
}
var childTableName = relationalKey.ChildTable;
var childSchemaName = NameTranslator.SchemaToNamespace(childTableName);
var childClassName = NameTranslator.TableToClassName(childTableName);
var qualifiedChildName = !childSchemaName.IsNullOrWhiteSpace()
? childSchemaName + "." + childClassName
: childClassName;
var childTable = tables.FirstOrDefault(t => t.Name == relationalKey.ChildTable);
var childKeyIsUnique = childTable != null && IsChildKeyUnique(childTable, relationalKey.ChildKey);
if (childKeyIsUnique)
{
var property = PropertyDeclaration(
NullableType(ParseTypeName(qualifiedChildName)),
Identifier(propertyName)
);
return(property
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.VirtualKeyword)))
.WithAccessorList(SyntaxUtilities.PropertyGetSetDeclaration)
.WithLeadingTrivia(BuildChildKeyComment(relationalKey)));
}
else
{
var columnTypeSyntax = GenericName(
Identifier(nameof(ICollection <object>)),
TypeArgumentList(
SingletonSeparatedList(
ParseTypeName(qualifiedChildName))));
var property = PropertyDeclaration(
columnTypeSyntax,
Identifier(propertyName)
);
var hashsetInstance = EqualsValueClause(
ObjectCreationExpression(
GenericName(
Identifier(nameof(System.Collections.Generic.HashSet <object>)),
TypeArgumentList(
SingletonSeparatedList(ParseTypeName(qualifiedChildName)))))
.WithArgumentList(ArgumentList())
);
return(property
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.VirtualKeyword)))
.WithAccessorList(SyntaxUtilities.PropertyGetSetDeclaration)
.WithInitializer(hashsetInstance)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken))
.WithLeadingTrivia(BuildChildKeyComment(relationalKey)));
}
}
private PropertyDeclarationSyntax BuildParentKey(IEnumerable <IRelationalDatabaseTable> tables, IDatabaseRelationalKey relationalKey, Option <IRelationalDatabaseTableComments> comment, string className, string propertyName)
{
if (tables == null)
{
throw new ArgumentNullException(nameof(tables));
}
if (relationalKey == null)
{
throw new ArgumentNullException(nameof(relationalKey));
}
if (className.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(className));
}
if (propertyName.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(propertyName));
}
var parentTable = relationalKey.ParentTable;
var parentSchemaName = NameTranslator.SchemaToNamespace(parentTable);
var parentClassName = NameTranslator.TableToClassName(parentTable);
var qualifiedParentName = !parentSchemaName.IsNullOrWhiteSpace()
? parentSchemaName + "." + parentClassName
: parentClassName;
var foreignKeyIsNotNull = relationalKey.ChildKey.Columns.All(c => !c.IsNullable);
var parentTypeName = foreignKeyIsNotNull
? ParseTypeName(qualifiedParentName)
: NullableType(ParseTypeName(qualifiedParentName));
var property = PropertyDeclaration(
parentTypeName,
Identifier(propertyName)
);
var foreignKey = property
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.VirtualKeyword)))
.WithAccessorList(SyntaxUtilities.PropertyGetSetDeclaration)
.WithLeadingTrivia(BuildForeignKeyComment(relationalKey, comment));
if (!foreignKeyIsNotNull)
{
return(foreignKey);
}
return(foreignKey
.WithInitializer(SyntaxUtilities.NotNullDefault)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
}
