protected override void WriteDeleteRule(ForeignKeyRule deleteRule) { if (deleteRule != ForeignKeyRule.Cascade) { return; } Write(" ON DELETE CASCADE"); }
public ForeignKeyConstraint(Db2SourceContext context, string owner, string schema, string name, string tableSchema, string tableName, string refSchema, string refConstraint, ForeignKeyRule updateRule, ForeignKeyRule deleteRule, bool isNoName, bool deferrable, bool deferred) : base(context, owner, schema, name, tableSchema, tableName, isNoName, deferrable, deferred) { ReferenceSchemaName = refSchema; ReferenceConstraintName = refConstraint; UpdateRule = updateRule; DeleteRule = deleteRule; }
internal ForeignKeyConstraint(ObjectName name, Table table, ConstraintType constraintType, IEnumerable<Column> keyColumns, TableConstraint uniqueConstraint, ForeignKeyRule updateRule, ForeignKeyRule deleteRule, bool? isDisabled) : base(name, table, constraintType, keyColumns) { _uniqueConstraint = uniqueConstraint; _updateRule = updateRule; _deleteRule = deleteRule; _isDisabled = isDisabled; }
public ForeignKey(Table childTable, string[] childFieldNames, Table parentTable, string[] parentFieldNames, ForeignKeyRule foreignKeyRule) { this.childTable = childTable; this.childFieldNames = childFieldNames; this.parentTable = parentTable; this.parentFieldNames = parentFieldNames; this.foreignKeyRule = foreignKeyRule; }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (!(value is ForeignKeyRule)) { return(null); } ForeignKeyRule rule = (ForeignKeyRule)value; return(_ruleToText[rule]); }
private async Task<Document> AddRelationshipAsync(IPropertySymbol dbTable, string name, IPropertySymbol foreignKey, IPropertySymbol refTable, string description, ForeignKeyRule deleteRule, ForeignKeyRule updateRule, CancellationToken ct = default(CancellationToken)) { var editor = await DocumentEditor.CreateAsync(Document, ct); var g = editor.Generator; var declarationAttributeType = Compilation.GetKnownType(KnownTypes.RelationshipAttribute); var ruleType = deleteRule != ForeignKeyRule.None || updateRule != ForeignKeyRule.None ? Compilation.GetKnownType(KnownTypes.ForeignKeyRule) : null; var implementationAttributeType = Compilation.GetKnownType(KnownTypes._RelationshipAttribute); var modelType = dbTable.GetModelType(); var keyMappingType = Compilation.GetKnownType(KnownTypes.KeyMapping); var imports = new NamespaceSet { declarationAttributeType, implementationAttributeType, modelType, keyMappingType }; if (ruleType != null) imports.Add(ruleType); var paramName = ModelParamName; var methodBody = GenerateImplementationMethodBody(); var method = g.MethodDeclaration(name, new SyntaxNode[] { g.ParameterDeclaration(paramName, g.IdentifierName(modelType.Name)) }, null, g.IdentifierName(keyMappingType.Name), Accessibility.Private, default(DeclarationModifiers), statements: new SyntaxNode[] { methodBody }); method = GenerateAttribute(method, implementationAttributeType.Name.ToAttributeName()).WithAdditionalAnnotations(Formatter.Annotation); editor.AddMember(DbClass, method); var argument = g.NameOfExpression(g.IdentifierName(name)); var arguments = g.AttributeArgument(argument).Concat(GenerateAdditionalArguments()).ToArray(); var dbTableNode = GetSyntaxNode(dbTable); editor.ReplaceNode(dbTableNode, GenerateAttribute(dbTableNode, declarationAttributeType.Name.ToAttributeName(), GetLeadingWhitespaceTrivia(dbTableNode), arguments)); await AddMissingNamespaces(editor, imports, ct); return await editor.FormatAsync(ct); IEnumerable<SyntaxNode> GenerateAdditionalArguments() { if (!string.IsNullOrWhiteSpace(description)) yield return g.AttributeArgument("Description", g.LiteralExpression(description)); if (deleteRule != ForeignKeyRule.None) yield return g.AttributeArgument("DeleteRule", g.DottedName(string.Format("{0}.{1}", ruleType.Name, deleteRule))); if (updateRule != ForeignKeyRule.None) yield return g.AttributeArgument("UpdateRule", g.DottedName(string.Format("{0}.{1}", ruleType.Name, updateRule))); } SyntaxNode GenerateImplementationMethodBody() { var fkExpr = g.DottedName(string.Format("{0}.{1}", paramName, foreignKey.Name)); var joinParam = dbTable == refTable ? g.IdentifierName(paramName) : GenerateJoinParam(g, refTable); return g.ReturnStatement(g.InvocationExpression(g.MemberAccessExpression(fkExpr, "Join"), joinParam)); } }
internal DbForeignKeyConstraint(string name, string description, CandidateKey foreignKey, CandidateKey referencedKey, ForeignKeyRule deleteRule, ForeignKeyRule updateRule) : base(name, description) { Debug.Assert(foreignKey != null); Debug.Assert(referencedKey != null); Debug.Assert(foreignKey.GetType() == referencedKey.GetType()); ForeignKey = foreignKey; ReferencedKey = referencedKey; DeleteRule = deleteRule; UpdateRule = updateRule; }
public ForeignKey(Table table, string name, IEnumerable <string> columnNames, string relatedTableName, string[] relatedColumnNames, ForeignKeyRule updateRule, ForeignKeyRule deleteRule) : base(table, name, columnNames) { RelatedTableName = relatedTableName; RelatedColumnNames = relatedColumnNames; UpdateRule = updateRule; DeleteRule = deleteRule; foreach (Column column in Columns) { column.SetAttribute(ColumnAttribute.FKColumn); } }
private static string GetRuleText(ForeignKeyRule rule) { switch (rule) { case ForeignKeyRule.Cascade: return("CASCADE"); case ForeignKeyRule.SetDefault: return("SET DEFAULT"); case ForeignKeyRule.SetNull: return("SET NULL"); default: return(string.Empty); } }
private static void GenerateForeignKeyRule(this ForeignKeyRule rule, IndentedStringBuilder sqlBuilder, string changeType) { Debug.Assert(changeType == "DELETE" || changeType == "UPDATE"); sqlBuilder.Append("ON "); sqlBuilder.Append(changeType); if (rule == ForeignKeyRule.None) { sqlBuilder.Append(" NO ACTION"); } else if (rule == ForeignKeyRule.Cascade) { sqlBuilder.Append(" CASCADE"); } else if (rule == ForeignKeyRule.SetNull) { sqlBuilder.Append(" SET NULL"); } else { sqlBuilder.Append(" SET DEFAULT"); } }
protected virtual string GetForeignKeyRuleText(ForeignKeyRule rule) { switch (rule) { case ForeignKeyRule.None: return("NO ACTION"); case ForeignKeyRule.Restrict: return("RESTRICT"); case ForeignKeyRule.Cascade: return("CASCADE"); case ForeignKeyRule.SetDefault: return("SET DEFAULT"); case ForeignKeyRule.SetNull: return("SET NULL"); default: return(string.Empty); } }
private static void CheckForeignKey(ForeignKeySchema foreignKey, string foreignKeyName, ForeignKeyRule rule) { foreignKey.Name.Should().Be(foreignKeyName, "Meno cudzieho kľúča musí byť správne."); foreignKey.PrimaryKeyTableName.Should().Be("ParentTable", "Meno tabuľky s primárnym kľúčom musí byť správne."); foreignKey.PrimaryKeyTableColumns.Should().Equal(new string[] { "Id" }); foreignKey.ForeignKeyTableColumns.Should().Equal(new string[] { "ParentId" }); foreignKey.DeleteRule.Should().Be(rule, "Pravidlo pri vymazaní (DELETE RULE) musí byť správne."); foreignKey.UpdateRule.Should().Be(rule, "Pravidlo pri vymazaní (UPDATE RULE) musí byť správne."); }
protected override void WriteUpdateRule(ForeignKeyRule updateRule) { }
private void AddRelationship(string name, IPropertySymbol foreignKey, IPropertySymbol refTable, string description, ForeignKeyRule deleteRule, ForeignKeyRule updateRule) { var document = CurrentNode.AddRelationship(name, foreignKey, refTable, description, deleteRule, updateRule); TryApplyChanges(document); NavigatableMarker = DbMapper.CreateTableMarker(CurrentNode.Name); }
private static DbForeignKeyConstraint CreateForeignKeyConstraint <TKey>(string name, string description, TKey foreignKey, Model <TKey> refTableModel, ForeignKeyRule deleteRule, ForeignKeyRule updateRule) where TKey : CandidateKey { Debug.Assert(foreignKey != null); Debug.Assert(refTableModel != null); var model = foreignKey.ParentModel; var foreignKeyConstraint = new DbForeignKeyConstraint(name, description, foreignKey, refTableModel.PrimaryKey, deleteRule, updateRule); Debug.Assert(!(refTableModel != model && string.IsNullOrEmpty(foreignKeyConstraint.ReferencedTableName))); return(foreignKeyConstraint); }
protected virtual void WriteDeleteRule(ForeignKeyRule deleteRule) { Write(" ON DELETE " + GetForeignKeyRuleText(deleteRule)); }
protected virtual void WriteUpdateRule(ForeignKeyRule updateRule) { Write(" ON UPDATE " + GetForeignKeyRuleText(updateRule)); }
public virtual Document AddRelationship(string name, IPropertySymbol foreignKey, IPropertySymbol refTable, string description, ForeignKeyRule deleteRule, ForeignKeyRule updateRule) { return(Mapper.Document); }
internal Document AddRelationship(IPropertySymbol dbTable, string name, IPropertySymbol foreignKey, IPropertySymbol refTable, string description, ForeignKeyRule deleteRule, ForeignKeyRule updateRule) { return AddRelationshipAsync(dbTable, name, foreignKey, refTable, description, deleteRule, updateRule).Result; }
public override Document AddRelationship(string name, IPropertySymbol foreignKey, IPropertySymbol refTable, string description, ForeignKeyRule deleteRule, ForeignKeyRule updateRule) { Debug.Assert(CanAddRelationship); return Mapper.AddRelationship(_table, name, foreignKey, refTable, description, deleteRule, updateRule); }