public virtual void CreateKey(IActivationLog log) { if (this.Key != null) //protect against multiple processing { return; } // we initially assign temp names this.Key = new EntityKeyInfo(HostEntity, KeyType, HostMember, this.Alias); // add members if (HostMember != null) { Key.KeyMembers.Add(new EntityKeyMemberInfo(HostMember, false)); } else { // it will add errors if it fails HostEntity.TryParseKeySpec(this.MemberNames, log, out Key.KeyMembers, ordered: true); } // construct name Key.ExplicitDbKeyName = this.DbKeyName; // PK if (KeyType.IsSet(KeyType.PrimaryKey)) { if (HostEntity.PrimaryKey == null) { HostEntity.PrimaryKey = Key; Key.KeyMembers.Each(km => km.Member.Flags |= EntityMemberFlags.PrimaryKey); } else { log.Error("Entity {0} has more than one Primary Key specified.", GetHostRef()); } } }
/// <summary> /// 尝试取缓存项,若不存在则自动加载 /// </summary> /// <param name="groupKey"></param> /// <param name="isAutoLoad">是否要自动加载</param> /// <param name="itemData"></param> /// <param name="loadStatus"></param> /// <returns></returns> protected bool TryGetCacheItem <TValue>(object[] keys, bool isAutoLoad, out TValue itemData) { CheckLoad(); itemData = default; string groupKey = EntityKeyInfo.CreateKeyCode(keys); if (string.IsNullOrEmpty(groupKey)) { return(false); } //处理分组方法加载,在内存中存在且加载不出错时,才不需要重读 if (Collection.TryGetValue(groupKey, out object itemSet)) { itemData = (TValue)itemSet; return(true); } if (isAutoLoad && LoadItemFactory(keys, false)) { if (Collection.TryGetValue(groupKey, out itemSet)) { itemData = (TValue)itemSet; return(true); } } return(false); }
private void AddParametersFromKey(EntityCommand command, EntityKeyInfo key) { foreach (var keyMember in key.ExpandedKeyMembers) { command.Parameters.Add(new EntityCommandParameter(keyMember.Member)); } }
private string GetKeyAttribute(EntityKeyInfo key, bool onProperty) { var attrName = GetKeyAttributeName(key.KeyType); var args = new List <string>(); if (!onProperty) { args.Add(DQuote(GetKeyColumnList(key))); } if (key.IndexFilter != null) { args.Add("Filter = " + DQuote(key.IndexFilter.Template.OriginalTemplate)); } if (key.IncludeMembers.Count > 0) { var sInc = string.Join(",", key.IncludeMembers.Select(m => m.MemberName)); args.Add("IncludeMembers = " + DQuote(sInc)); } if (key.KeyType.IsSet(KeyType.PrimaryKey) && key.KeyType.IsSet(KeyType.Clustered)) { args.Add("Clustered=true"); } if (args.Count == 0) { return(attrName); } var result = attrName + "(" + string.Join(", ", args) + ")"; return(result); }
private void ProcessEntityRefMember(EntityMemberInfo member) { // Check if EntityRef attr is present var entRefAttr = member.Attributes.OfType <EntityRefAttribute>().FirstOrDefault(); var entity = member.Entity; var propName = entity.EntityType.Name + "." + member.MemberName; var targetType = member.DataType; var targetEntity = this.Model.GetEntityInfo(targetType); if (targetEntity == null) { Log.Error("Reference property {0}: target entity not found: {1}", propName, targetType); return; } //find target key; usually it is PK on target entity, but MS SQL allows linking to any unique key // EntityRef attr might specify target unique key var targetKey = targetEntity.PrimaryKey; var targetUniqueIndexAlias = entRefAttr?.TargetUniqueIndexAlias; if (!string.IsNullOrEmpty(targetUniqueIndexAlias)) { targetKey = FindCreateKeyByAlias(targetEntity, targetUniqueIndexAlias); if (targetKey == null) { Log.Error("Property {0}: Invalid target index alias '{1}' in EntityRef attrribute, index not found on target entity {2}.", propName, targetUniqueIndexAlias, targetEntity.EntityType); return; } if (!targetKey.KeyType.IsSet(KeyType.Unique)) { Log.Error("Property {0}: Invalid target Index in EntityRef attrribute; Index {1} is not Unique.", propName, targetUniqueIndexAlias); return; } } //Create foreign key var fk = new EntityKeyInfo(entity, KeyType.ForeignKey, member); fk.IsCopyOf = targetKey; fk.KeyMembers.Add(new EntityKeyMemberInfo(member, false)); var refInfo = member.ReferenceInfo = new EntityReferenceInfo(member, fk, targetKey); // if there's EntitRef attr, apply its props if specified if (entRefAttr != null) { if (!string.IsNullOrEmpty(entRefAttr.ForeignKeyName)) { refInfo.FromKey.Name = entRefAttr.ForeignKeyName; } if (!string.IsNullOrWhiteSpace(entRefAttr.KeyColumns)) { refInfo.ForeignKeyColumns = entRefAttr.KeyColumns; } } if (targetEntity.Flags.IsSet(EntityFlags.HasIdentity)) { entity.Flags |= EntityFlags.ReferencesIdentity; } }
public TEntity Find(params object[] keys) { string key = EntityKeyInfo.CreateKeyCode(keys); var entity = cacheManager.Get <TEntity>(key, Region); return(entity); }
/// <summary> /// /// </summary> /// <param name="entity"></param> public TEntity Add(TEntity entity) { var key = EntityKeyInfo.GetPrimaryKey(entity); cacheManager.Add(key, entity, Region); return(entity); }
public TEntity Delete(TEntity entity) { var key = EntityKeyInfo.GetPrimaryKey(entity); cacheManager.Remove(key, Region); return(entity); }
/// <summary> /// cachemanager 不支持findall /// 使用redis。HKEYS 查询所有的key然后再查找key是否包含keyvalue可以实现(待做) /// https://github.com/MichaCo/CacheManager/issues/225 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="keyValues"></param> /// <returns></returns> public override IEnumerable <T> OnFindAllExecuting <T>(params object[] keyValues) { var efRepository = services.GetService(DbType) as IFindExpressionRepository <T>; var props = EntityKeyInfo.GetGroupProps <T>(); var query = efRepository.FindQuery(); var item = Expression.Parameter(typeof(T), "item"); Expression expression = null; for (int i = 0; i < props.Count; i++) { var prop = Expression.Property(item, props[i].Name); var soap = Expression.Constant(keyValues[i]); var equal = Expression.Equal(prop, soap); if (expression == null) { expression = equal; } else { expression = Expression.And( expression, equal ); } } var lambda = Expression.Lambda <Func <T, bool> >(expression, item); return(query.Where(lambda).ToList()); }
public EntityKey(EntityKeyInfo key, params object[] values) { var keyCount = key.ExpandedKeyMembers.Count; Util.Check(keyCount == values.Length, "Invalid number of key values, expected: {0}, provided: {1}.", keyCount, values.Length); KeyInfo = key; Values = values; }//constructor
public static SpecialLinqCommand CreateCheckAnyChildRecords(EntityKeyInfo childKey, EntityRecord record) { childKey.SqlCacheKey_ChildExists = childKey.SqlCacheKey_ChildExists ?? SqlCacheKeyBuilder.BuildSpecialSelectKey(Tag_ExistsByKey, childKey.Entity.Name, childKey.Name, LockType.None, null); return(new SpecialLinqCommand(record.Session, childKey.SqlCacheKey_ChildExists, childKey, LockType.None, null, record.PrimaryKey.Values, Setup_CheckChildExists)); }
public EntityCommand(string commandName, string description, EntityCommandKind kind, EntityInfo entity, EntityKeyInfo selectKey = null) : this(commandName, description, kind) { TargetEntityInfo = entity; Area = entity.Area; TargetEntityType = entity.EntityType; SelectKey = selectKey; }
/// <summary> /// /// </summary> /// <param name="dataList"></param> /// <param name="periodTime"></param> /// <param name="isReplace"></param> /// <returns></returns> protected bool InitCache(List <TEntity> dataList, bool isReplace) { Collection.Clear(); foreach (var data in dataList) { Collection.Add(EntityKeyInfo.GetPrimaryKey(data), data); } return(true); }
public IEnumerable <TEntity> AddRange(IEnumerable <TEntity> entitiesToAdd) { foreach (var entity in entitiesToAdd) { var key = EntityKeyInfo.GetPrimaryKey(entity); cacheManager.Add(key, entity, Region); } return(entitiesToAdd); }
public TEntity Update(TEntity entity) { var key = EntityKeyInfo.GetPrimaryKey(entity); return(cacheManager.AddOrUpdate(key, Region, entity, (oldValue) => { return entity; })); }
public DbKeyInfo(string name, DbTableInfo table, KeyType type, EntityKeyInfo entityKey = null) : base(table.DbModel, table.Schema, DbObjectType.Key, entityKey) { Name = name; Table = table; KeyType = type; EntityKey = entityKey; table.Keys.Add(this); base.GlobalName = DbModelHelper.GetGlobalName(table.Schema, name); }
public void PrefixWithMultipleSegmentsConstantStringsObjectPropertiesTest() { var keyInfo = new EntityKeyInfo <TestModel>("UR", e => new { PrefixNameDoesntMatter = "LF", e.LastName, e.FirstName }); var key = keyInfo.KeyGetter.Invoke(_testModel); Assert.AreEqual(key, "UR__LF__Liu__Yue"); var testModel = new TestModel(); keyInfo.KeySetter.Invoke(testModel, "UR__LF__Liu__Yue"); Assert.AreEqual(testModel.FirstName, "Yue"); Assert.AreEqual(testModel.LastName, "Liu"); Assert.AreEqual(testModel.Description, null); keyInfo.KeySetter.Invoke(testModel, "UR__LF__Liu__"); Assert.AreEqual(testModel.FirstName, string.Empty); Assert.AreEqual(testModel.LastName, "Liu"); Assert.AreEqual(testModel.Description, null); keyInfo.KeySetter.Invoke(testModel, "UR__LF____"); Assert.AreEqual(testModel.FirstName, string.Empty); Assert.AreEqual(testModel.LastName, string.Empty); Assert.AreEqual(testModel.Description, null); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, null)); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, string.Empty)); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, ",=")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, ",-")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "Liu")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, ",")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, ",L")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, ",Liu")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "Liu__Yue")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "__Liu__Yue")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "LFLiu__Yue")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "LF__Liu")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "LF__Liu_")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "LF__")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "LF___")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__,=")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__,-")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__Liu")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__,")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__,L")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__,Liu")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__Liu__Yue")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR____Liu__Yue")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__LFLiu__Yue")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__LF__Liu")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__LF__Liu_")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__LF__")); Expect.Exception <FormatException>(() => keyInfo.KeySetter.Invoke(testModel, "UR__LF___")); }
public EntityCommand BuildCrudSelectByKeyCommand(EntityKeyInfo key, string filter = null, string nameSuffix = null) { var entity = key.Entity; var procName = entity.Name + "_SelectBy" + key.GetMemberNames(string.Empty, removeUnderscore: true) + nameSuffix; var descr = "Selects entity(ies) by key."; var cmd = AddCommand(procName, descr, EntityCommandKind.SelectByKey, entity, key); cmd.Filter = filter; AddParametersFromKey(cmd, key); return(cmd); }
/// <summary> /// /// </summary> /// <param name="value"></param> /// <returns></returns> public TEntity Add(TEntity value) { string personalId = EntityKeyInfo.GetGroupKey(value); if (string.IsNullOrEmpty(personalId)) { throw new ArgumentNullException("t", "t.PersonalId is null"); } if (!RunAspect(attribute => attribute.OnAddExecuting(value))) { return(default);
public SpecialLinqCommand(EntitySession session, string sqlCacheKey, EntityKeyInfo key, LockType lockType, List <EntityKeyMemberInfo> orderBy, object[] paramValues, Action <SpecialLinqCommand> setupAction) : base(session, LinqCommandKind.Special, LinqOperation.Select) { this.SqlCacheKey = sqlCacheKey; Key = key; base.LockType = lockType; OrderBy = orderBy; ParamValues = paramValues; SetupAction = setupAction; }
public bool KeyIsLoaded(EntityKeyInfo key) { for (int i = 0; i < key.ExpandedKeyMembers.Count; i++) { var valueIndex = key.ExpandedKeyMembers[i].Member.ValueIndex; var v = ValuesModified[valueIndex] ?? ValuesOriginal[valueIndex]; if (v == null) { return(false); } } return(true); }
public EntityCommand BuildCrudSelectByKeyArrayCommand(EntityKeyInfo key) { if (key.ExpandedKeyMembers.Count > 1) return null; var member0 = key.ExpandedKeyMembers[0].Member; var entity = key.Entity; var procName = entity.Name + "_SelectByArrayOf_" + key.GetMemberNames(string.Empty, removeUnderscore: true); var descr = "Selects entities by array of key values."; var cmd = AddCommand(procName, descr, EntityCommandKind.SelectByKeyArray, entity, key); var prmType = typeof(IEnumerable<>).MakeGenericType(member0.DataType); cmd.Parameters.Add(new EntityCommandParameter("Values", prmType, 0, null)); return cmd; }
}//method public bool KeyIsNull(EntityKeyInfo key) { for (int i = 0; i < key.ExpandedKeyMembers.Count; i++) { var valueIndex = key.ExpandedKeyMembers[i].Member.ValueIndex; var v = ValuesModified[valueIndex] ?? ValuesOriginal[valueIndex]; // Note: transient values in new record might be null if (v != DBNull.Value) { return(false); } } return(true); }
public bool KeyMatches(EntityKeyInfo keyInfo, object[] keyValues) { for (int i = 0; i < keyInfo.ExpandedKeyMembers.Count; i++) { var member = keyInfo.ExpandedKeyMembers[i].Member; var thisValue = GetValue(member); var otherValue = keyValues[i]; var eq = member.AreValuesEqual(thisValue, otherValue); if (!eq) { return(false); } } return(true); }
private string GetKeyColumnList(EntityKeyInfo key) { var specs = new string[key.KeyMembers.Count]; for (int i = 0; i < key.KeyMembers.Count; i++) { var keyMember = key.KeyMembers[i]; var memberSpec = keyMember.Member.MemberName;// ?? keyMember.Member.MemberName; if (keyMember.Desc) { memberSpec += ":DESC"; } specs[i] = memberSpec; } return(string.Join(",", specs)); }
public EntityCommand BuildCrudSelectByKeyArrayCommand(EntityKeyInfo key) { if (key.ExpandedKeyMembers.Count > 1) { return(null); } var member0 = key.ExpandedKeyMembers[0].Member; var entity = key.Entity; var procName = entity.Name + "_SelectByArrayOf_" + key.GetMemberNames(string.Empty, removeUnderscore: true); var descr = "Selects entities by array of key values."; var cmd = AddCommand(procName, descr, EntityCommandKind.SelectByKeyArray, entity, key); var prmType = typeof(IEnumerable <>).MakeGenericType(member0.DataType); cmd.Parameters.Add(new EntityCommandParameter("Values", prmType, 0, null)); return(cmd); }
public override void Apply(AttributeContext context, Attribute attribute, EntityMemberInfo member) { if (member.Kind != MemberKind.EntityRef) { context.Log.Error("EntityRef attribute may be used only on properties that are references to other entities. Property: {0}.{1}", member.Entity.Name, member.MemberName); return; } var entity = member.Entity; // Create reference info var targetType = member.DataType; //.Property.PropertyType; var targetEntity = context.Model.GetEntityInfo(targetType); Util.Check(targetEntity != null, "Target entity not found: {0}", targetType); //Create foreign key ForeignKeyName = ForeignKeyName ?? "FK_" + entity.Name + "_" + member.MemberName; var fk = new EntityKeyInfo(ForeignKeyName, KeyType.ForeignKey, entity, member); fk.KeyMembers.Add(new EntityKeyMemberInfo(member, false)); member.ReferenceInfo = new EntityReferenceInfo(member, fk, targetEntity.PrimaryKey); member.ReferenceInfo.ForeignKeyColumns = this.KeyColumns; }
//Verify values and create key public static EntityKey CreateSafe(EntityKeyInfo key, params object[] values) { //Verify Util.Check(key.ExpandedKeyMembers.Count == values.Length, "EntityKeyValue constructor: values count does not match key members count. Key={0}", key); for (int i = 0; i < values.Length; i++) { var value = values[i]; if (value == null) { continue; } var memberType = key.ExpandedKeyMembers[i].Member.DataType; var valueType = value.GetType(); Util.Check(memberType.IsAssignableFrom(valueType), "Invalid key value [{0}] (type: {1}); expected {2}.", value, valueType, memberType); } return(new EntityKey(key, values)); }
public static EntityKey KeyFromString(EntityKeyInfo key, string valueString) { if (key.ExpandedKeyMembers.Count == 1) //shortcut { var m0 = key.ExpandedKeyMembers[0].Member; var v = m0.ValueFromStringRef(m0, valueString); var kv = new EntityKey(key, new object[] { v }); return(kv); } //complex keys var sValues = valueString.Split(';'); var values = new object[key.ExpandedKeyMembers.Count]; for (int i = 0; i < values.Length; i++) { var m = key.ExpandedKeyMembers[i].Member; values[i] = m.ValueFromStringRef(m, sValues[i]); } return(new EntityKey(key, values)); }
// regular, non-foreign key private bool ExpandRegularKey(EntityKeyInfo key) { key.ExpandedKeyMembers.Clear(); if (!ExpandRefMembers(key.KeyMembers.Select(km => km.Member).ToList())) { return(false); } if (!ExpandRefMembers(key.IncludeMembers)) { return(false); } // Key members foreach (var km in key.KeyMembers) { var member = km.Member; if (member.Kind == EntityMemberKind.EntityRef) { key.ExpandedKeyMembers.AddRange(member.ReferenceInfo.FromKey.ExpandedKeyMembers); } else { key.ExpandedKeyMembers.Add(km); } } //foreach km // include members foreach (var member in key.IncludeMembers) { if (member.Kind == EntityMemberKind.EntityRef) { key.ExpandedIncludeMembers.AddRange(member.ReferenceInfo.FromKey.ExpandedKeyMembers.Select(km => km.Member)); } else { key.ExpandedIncludeMembers.Add(member); } } //foreach km return(true); } //method
// these are not key names in db, we assign DbKey.Name in DbModelBuilder using some special code public static string ConstructKeyName(this EntityKeyInfo key) { Util.Check(key.IsExpanded(), "KeyMembers list must be expanded, cannot construct name. Entity: {0}, keytype: {1}", key.Entity.Name, key.KeyType); var entity = key.Entity; var tName = entity.TableName ?? entity.Name; var prefix = GetKeyNamePrefix(key.KeyType); if (key.KeyType.IsSet(KeyType.PrimaryKey)) { return(prefix + tName); } else if (key.KeyType.IsSet(KeyType.ForeignKey)) { var target = key.OwnerMember.ReferenceInfo.ToKey.Entity; return(prefix + tName + "_" + (target.TableName ?? target.Name)); } else { var members = key.GetMemberNames(); string memberNames = string.Join(string.Empty, members).Replace("_", string.Empty); //remove underscores in names return(prefix + tName + "_" + memberNames); } }
private bool ExpandKey(EntityKeyInfo key) { if (key.IsExpanded()) { return(true); } if (_keysInExpansion.Contains(key)) { Log.LogError($"Cannot expand key/index {key.GetFullRef()}, ran into key circular reference."); return(false); } try { _keysInExpansion.Add(key); if (key.KeyType.IsSet(KeyType.ForeignKey)) { return(ExpandForeignKey(key)); } ExpandRegularKey(key); } finally { _keysInExpansion.Remove(key); } key.HasIdentityMember = key.ExpandedKeyMembers.Any(m => m.Member.Flags.IsSet(EntityMemberFlags.Identity)); return(true); }
private string GetKeyColumnList(EntityKeyInfo key) { var specs = new string[key.KeyMembers.Count]; for (int i = 0; i < key.KeyMembers.Count; i++) { var keyMember = key.KeyMembers[i]; var memberSpec = keyMember.Member.MemberName;// ?? keyMember.Member.MemberName; if (keyMember.Desc) memberSpec += ":DESC"; specs[i] = memberSpec; } return string.Join(",", specs); }
private string GetKeyAttribute(EntityKeyInfo key, bool onProperty) { var attrName = GetKeyAttributeName(key.KeyType); var args = new List<string>(); if(!onProperty) args.Add(DQuote(GetKeyColumnList(key))); if(!string.IsNullOrWhiteSpace(key.Filter)) args.Add("Filter = " + DQuote(key.Filter)); if(key.IncludeMembers.Count > 0) { var sInc = string.Join(",", key.IncludeMembers.Select(m => m.MemberName)); args.Add("IncludeMembers = " + DQuote(sInc)); } if(key.KeyType.IsSet(KeyType.PrimaryKey) && key.KeyType.IsSet(KeyType.Clustered)) args.Add("IsClustered=true"); if(args.Count == 0) return attrName; var result = attrName + "(" + string.Join(", ", args) + ")"; return result; }
public bool KeyIsLoaded(EntityKeyInfo key) { for(int i = 0; i < key.ExpandedKeyMembers.Count; i++) { var valueIndex = key.ExpandedKeyMembers[i].Member.ValueIndex; var v = ValuesModified[valueIndex] ?? ValuesOriginal[valueIndex]; if(v == null) return false; } return true; }
public bool KeyIsNull(EntityKeyInfo key) { for(int i = 0; i < key.ExpandedKeyMembers.Count; i++) { var valueIndex = key.ExpandedKeyMembers[i].Member.ValueIndex; var v = ValuesModified[valueIndex] ?? ValuesOriginal[valueIndex]; // Note: transient values in new record might be null if(v != DBNull.Value) return false; } return true; }
public bool KeyMatches(EntityKeyInfo keyInfo, object[] keyValues) { for(int i = 0; i < keyInfo.ExpandedKeyMembers.Count; i++) { var member = keyInfo.ExpandedKeyMembers[i].Member; var thisValue = GetValue(member); var otherValue = keyValues[i]; var eq = member.AreValuesEqual(thisValue, otherValue); if(!eq) return false; } return true; }
public EntityCommand BuildCrudSelectByKeyCommand(EntityKeyInfo key, string filter = null, string nameSuffix = null) { var entity = key.Entity; var procName = entity.Name + "_SelectBy" + key.GetMemberNames(string.Empty, removeUnderscore: true) + nameSuffix; var descr = "Selects entity(ies) by key."; var cmd = AddCommand(procName, descr, EntityCommandKind.SelectByKey, entity, key); cmd.Filter = filter; AddParametersFromKey(cmd, key); return cmd; }
private bool IsPropertyKey(EntityKeyInfo key) { if (key.KeyMembers.Count != 1) return false; if(key.KeyMembers[0].Desc) return false; // Only Index or PK - but not ForeignKey; FK is hidden key, without attribute bool isIndexOrPk = key.KeyType.IsSet(KeyType.Index | KeyType.PrimaryKey); if (!isIndexOrPk) return false; //if it is a key on fk column that is NOT explicitly exposed as property if (key.KeyMembers.Any(km => km.Member.Flags.IsSet(EntityMemberFlags.ForeignKey))) return false; return true; }
private EntityCommand AddCommand(string commandName, string description, EntityCommandKind kind, EntityInfo entity, EntityKeyInfo selectKey = null) { var command = new EntityCommand(commandName, description, kind, entity, selectKey); _model.AddCommand(command); return command; }
private void AddParametersFromKey(EntityCommand command, EntityKeyInfo key) { foreach (var keyMember in key.ExpandedKeyMembers) command.Parameters.Add(new EntityCommandParameter(keyMember.Member)); }