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;
}
