private string ForeignKeyConstraint(AtomMemberInfo member) { var foreignTable = member.Reference.Name; var foreignKeyColumnName = string.IsNullOrWhiteSpace(member.Reference.Member) ? member.Name : member.Reference.Member; // fix naming convention if we have multiple columns pointing to the same foreign key // the name goes from FK_Table_FkKey to FK_Table_ColumnName if ( member.Atom.Members.Any( i => i.HasReference && i.Reference.Member == member.Reference.Member && i.Reference.Name == member.Reference.Name && i.Name != member.Name)) { foreignKeyColumnName = member.Name; } string Schema = _table.AdditionalInfo.Schema, TableName = _table.Name, ForeignTable = foreignTable, ForeignKeyName = $"FK_{_table.Name}_{foreignTable}_{foreignKeyColumnName}", ForeignColumn = member.Reference.Member ?? member.Name, MemberName = member.Name, schema = member.Atom.AdditionalInfo.Schema; string fk = $@"ALTER TABLE [{schema}].[{TableName}] ADD CONSTRAINT [{ForeignKeyName}] FOREIGN KEY ([{MemberName}]) REFERENCES [{Schema}].[{ForeignTable}] ([{ForeignColumn}]) GO"; return(fk); }
protected string GetInsertFields(AtomMemberInfo arg) { if (arg.IsPrimary && arg.MemberType is MemberLong) { return(string.Empty); } if (arg.MemberType.CanSupplyDefaultCreationValue && arg.MemberType is MemberGuid && (arg.IsAltKey || arg.IsPrimary)) { return("(NEWID())"); } if (IsHiddenTemporal(arg)) { return("@NOW"); } if (arg.HasFlag(MemberFlags.SoftDeleteTracking)) { return("0"); } string paramName = "@" + arg.Name; return(paramName); }
private string GetUpdateValues(AtomMemberInfo member) { if (member.IsPrimary || member.IsAltKey) { return(null); } if (member.Atom.AdditionalInfo.Temporal.HasTemporal.GetValueOrDefault()) { if (member.HasFlag(MemberFlags.LastModifiedDateTimetracking)) { return(member.Name + " = @NOW"); } if (member.HasFlag(MemberFlags.CreatedDateTimeTracking)) { return(null); } } if (member.HasFlag(MemberFlags.SoftDeleteTracking)) { return(member.Name + " = 0"); } return(member.Name + " = @" + member.Name); }
public static AliasedAtomMemberInfo FromAtomMemberInfo(AtomMemberInfo src) { return new AliasedAtomMemberInfo { Name = src.Name, Member = src }; }
public static AliasedAtomMemberInfo FromAtomMemberInfo(AtomMemberInfo src) { return(new AliasedAtomMemberInfo { Name = src.Name, Member = src }); }
private string Optionality(AtomMemberInfo atomMemberInfo) { if (!atomMemberInfo.Optional) { return(string.Empty); } return(" = NULL"); }
protected AtomMemberInfo GetStrongTypeMember(AtomMemberInfo member) { if (member.HasReference && member.Reference.IsReferenceToHiddenPrimaryKey) { return(member.Reference.TargetAtomAlternateKey); } return(member); }
protected bool IsHiddenTemporal(AtomMemberInfo value) { if (Atom.AdditionalInfo.Temporal.HasTemporal.GetValueOrDefault() && value.MemberType is MemberDateTime) { return(value.HasFlag(MemberFlags.TemporalTracking)); } return(false); }
private string GetConstraintModifier(AtomMemberInfo member) { if (member.IsPrimary && !(member.MemberType is MemberGuid)) { return("CLUSTERED"); } return("NONCLUSTERED"); }
public static AtomMemberInfo Key(this AtomMemberInfo memberInfo) { memberInfo.Unique = true; memberInfo.Queryable = true; memberInfo.IsPrimary = true; memberInfo.AddFlags(MemberFlags.PrimaryKey); return(memberInfo); }
protected bool CanBeStronger(AtomMemberInfo member) { if (!Config.Entities.StrongTypes || member.HasFlag(MemberFlags.Hidden)) { return(false); } return(member.IsAltKey || member.IsPrimary || (member.HasReference && (member.Reference.IsReferenceToHiddenPrimaryKey || CanBeStronger(member.Reference.TargetMember)))); }
private string Generate(AtomMemberInfo member) { var type = GetMemberType(member); var constraint = GetMemberConstraint(member); var defaultValue = GetDefaultValue(member.Name, member); return($@"[{member.Name}] {type} {constraint} {defaultValue}".Trim()); }
protected bool IsKey(AtomMemberInfo value) { if (Atom.AdditionalInfo.ShouldHidePrimaryKey() || Atom.Members.Any(i => i.IsAltKey)) { return(value.IsAltKey); } return(value.IsPrimary); }
private string GetMemberConstraint(AtomMemberInfo value) { if (value.IsPrimary || value.IsAltKey || !value.Optional) { return("NOT NULL"); } return("NULL"); }
private string BuildIndex(AtomMemberInfo member) { string IndexType = (member.Unique ? "UNIQUE " : "") + "NONCLUSTERED", TableName = _data.Name, Columns = member.Name, Schema = _data.AdditionalInfo.Schema, IndexPrefix = member.Unique ? "AK" : "IX", SpacedColumns = BuildIndexColumnDef(member); return($@"CREATE {IndexType} INDEX [{IndexPrefix}_{TableName}_{Columns}] ON [{Schema}].[{TableName}] ({SpacedColumns}) ON [PRIMARY]"); }
private void AddLookupMembers(AtomModel data) { if (data.AdditionalInfo == null) { data.AdditionalInfo = new AtomAdditionalInfo(); } if (data.Members == null) { data.Members = new OrderedAtomMembers(); } var idMember = new AtomMemberInfo() { Name = data.Name + "Id", Type = data.Lookup.Type ?? "long" }; var id = idMember.Generated().Key(); var name = new AtomMemberInfo { Name = data.Name + "Name", Key = true }.Generated(); var description = new AtomMemberInfo { Name = data.Name + "Description" }.Generated(); var defaultLookupSettings = new AtomAdditionalInfo { Temporal = { HasTemporal = true }, HideId = false, AutoGenId = false, QueryTypes = new List <QueryFlags> { QueryFlags.None } }; defaultLookupSettings.Merge(_defaults); data.AdditionalInfo.Merge(defaultLookupSettings); data.Members.Insert(0, id); data.Members.Insert(1, name); data.Members.Insert(2, description); }
protected string GetTypedSprocParam(AtomMemberInfo arg) { var optional = Optionality(arg); if (arg.HasReference && arg.Reference.IsReferenceToHiddenPrimaryKey) { arg = arg.Reference.TargetAtomAlternateKey; } var typedParam = GetTypedVariable(arg); return(typedParam + optional); }
private string GetConstraintType(AtomMemberInfo member) { if (member.IsPrimary) { return("PRIMARY KEY " + GetConstraintModifier(member)); } if ((member.IsAltKey || member.Unique)) { return("UNIQUE " + GetConstraintModifier(member)); } return(string.Empty); }
private string GetTableType(AtomMemberInfo key) { if (key.MemberType is MemberGuid) { return(Constants.GuidTableType); } if (key.MemberType is MemberLong) { return(Constants.BigIntTableType); } throw new Exception($"Custom table type didn't exist for column {key.Name} with type {key.Type}"); }
private string GetConstraintName(AtomMemberInfo member) { if (member.IsPrimary) { return("PK_" + _table.Name); } if (member.IsAltKey || member.Unique) { return($"AK_{_table.Name}_{member.Name}"); } return(string.Empty); }
protected bool IsQueryableColumn(AtomMemberInfo arg) { if (arg.IsPrimary && Atom.AdditionalInfo.ShouldHidePrimaryKey()) { return(false); } if (IsKey(arg)) { return(true); } return(true); }
private string StrongTypeCastingType(AtomMemberInfo member) { if (Config.Entities.StrongTypes && CanBeStronger(member)) { var type = member.MemberType; if (member.HasReference && member.Reference.IsReferenceToHiddenPrimaryKey) { type = member.Reference.TargetAtomAlternateKey.MemberType; } return("(" + new CSharpDefaultTypeFinder(member.Optional).Visit(type) + ")"); } return(string.Empty); }
private string AlternateKeyConstraints(AtomMemberInfo member) { string Schema = _table.AdditionalInfo.Schema, TableName = _table.Name, ConstraintName = GetConstraintName(member), ConstraintType = GetConstraintType(member), MemberName = member.Name, schema = member.Atom.AdditionalInfo.Schema; string ak = $@"ALTER TABLE [{Schema}].[{TableName}] ADD CONSTRAINT [{ConstraintName}] {ConstraintType} ([{MemberName}]) ON [PRIMARY] GO";; return(ak); }
private string GetUpdateValues(AtomMemberInfo member) { if (member.HasFlag(MemberFlags.SoftDeleteTracking)) { return(member.Name + " = 1"); } if (member.Atom.AdditionalInfo.Temporal.HasTemporal.GetValueOrDefault() && member.HasFlag(MemberFlags.LastModifiedDateTimetracking)) { return(member.Name + " = @NOW"); } return(null); }
protected bool MemberIsUseableAsInsertParameter(AtomMemberInfo member) { if (!member.HasFlag(MemberFlags.NotUpdateable)) { return(true); } if (member.Key && !member.MemberType.CanSupplyDefaultCreationValue) { return(true); } return(member.HasReference); }
protected string GetMemberType(AtomMemberInfo member) { if (CanBeStronger(member)) { var referencingTypeName = new CSharpStrongTypeNameFinder(member).TypeName(); if (member.Optional) { return(referencingTypeName + "?"); } return(referencingTypeName); } string typeName = member.MemberType.Accept(new CSharpDefaultTypeFinder(member.Optional)); return(typeName); }
private bool IsListableField(AtomMemberInfo arg) { if (arg.IsPrimary && Atom.AdditionalInfo.ShouldHidePrimaryKey()) { return(false); } if (IsKey(arg)) { return(true); } if (IsHiddenTemporal(arg)) { return(false); } return(true); }
private string GetIndexColumnDeclaration(AtomMemberInfo member) { if (!member.SortDirection.HasValue) { return(string.Empty); } switch (member.SortDirection.Value) { case AtomMemberSortDirection.Asc: return(string.Empty); case AtomMemberSortDirection.Desc: return("DESC"); } string message = "Unknown index column declaration"; Log.Error($"{message} {{@Member}}", member); throw new Exception(message); }
private string GetDefaultValue(string name, AtomMemberInfo value) { // prevent duplicate primary keys getting the Identity Value if (!_primaryKeySet && value.IsPrimary && value.MemberType is MemberLong && !_atomModel.IsLookup) { _primaryKeySet = true; return("IDENTITY(1,1)"); } if (!string.IsNullOrEmpty(value.DefaultValue)) { return($"CONSTRAINT [DF_{_atomModel.Name}_{name}] DEFAULT ({ValidateDefault(value)})"); } return(string.Empty); }
private string GetLookupSqlForMember(AtomMemberInfo member) { var referenceAtom = member.Reference.TargetMember.Atom; var referenceKey = referenceAtom.Members.Single(m => m.Key); var lookup = $@" DECLARE {GetTypedVariable(member)} = ( SELECT {member.Name} FROM {referenceAtom.Name} WHERE [{referenceAtom.Name}].{referenceKey.Name} = @{referenceKey.Name} )"; if (!member.Optional) { lookup += $@" IF (@{member.Name} IS NULL) BEGIN RAISERROR('{referenceKey.Name} not found.', 11, 1); RETURN; END"; } return(lookup); }
public CSharpStrongTypeNameFinder(AtomMemberInfo member) { _member = member; }