public FromEntityMetaDataProviderTableReader(IEntityMetaDataProvider provider)
{
if (null == provider)
throw new ArgumentNullException("provider");
this.metaData = provider.CreateEntityMetaData();
}
public virtual void SetColumnValue(IEntityMetaData metaData, int index, SqlQuery query, PropertyMetaData pm, object entity)//Parametewnin eklenip eklenmeyeceği bilinmdeğinden prefix ve entity verilmek zorunda.
{
SchemaInfo schema = pm.Schema;
PropertyInfo pi = pm.Property;
object parValue = pm.Property.GetValue(entity, null);
StringBuilder text = query.Text;
if (schema.DefaultValue.Length != 0)
{
object defaultValue = ReflectionExtensions.GetDefault(pi.PropertyType);
if (Object.Equals(defaultValue, parValue))//Eğer Property Değeri Default Haldeyse yazdır Bunu
{
text.Append(schema.DefaultValue);
return;
}
}
switch (schema.SqlValueType)
{
case SqlValueType.Parameterized:
text.Append(this.Prefix);
string parameterName = metaData.GetParameterName(pm, index);
text.Append(parameterName);
SqlQueryParameter par = SqlQueryParameter.Create(parameterName, pm, parValue);
query.Parameters.Add(par);
break;
case SqlValueType.Text:
string textValue = null;
if (null != parValue)
{
Type dataType = pm.Schema.DataType;//Neden Schema.DataType çünkü pi.PropertyType nullable olabalir.
if (WithQuotes.Contains(dataType))
{
textValue = "'" + parValue + "'";
}
else
{
IFormattable f = parValue as IFormattable;
textValue = null != f ? f.ToString(null, NumericCulture) : parValue.ToString();
}
}
text.Append(textValue);
break;
default:
throw new NotSupportedException(schema.SqlValueType.ToString());
}
}
public virtual SqlQuery CreateQuery(object entity, IEntityMetaData metaData)
{
if (null == entity)
throw new ArgumentNullException("entity");
SqlQueryHelper.IndexParameterNames(metaData, this.ParameterIndex);
bool updatedFieldsEnabled = !this.UpdatedFields.IsEmptyList();
SqlQuery query = new SqlQuery();
StringBuilder text = query.Text;
text.Append("UPDATE ");
text.Append(metaData.TableName);
text.Append(" SET ");
foreach (PropertyMetaData property in metaData.Properties)
{
SchemaInfo schema = property.Schema;
if (schema.IsKey)
continue;
if (schema.DatabaseGeneratedOption != StoreGeneratedPattern.None)
continue;
if (schema.ReadOnly)
continue;
if (updatedFieldsEnabled && !this.UpdatedFields.Contains(schema.ColumnName))
continue;
text.Append(schema.ColumnName);
text.Append("=");
SqlQueryHelper.SetColumnValue(ValueSetter.Instance, query, property, entity);
text.Append(',');
}
text.Remove(text.Length - 1, 1);
query.Combine(SqlQueryHelper.CreateWhereSqlByKeys(metaData, ':', entity));
if (this.UseSemicolon)
text.Append(';');
return query;
}
internal static void MakeKeyIdentity(IEntityMetaData metaData)
{
PropertyMetaData primaryKey = metaData.GetPrimaryKey();
if (null != primaryKey)//has no or multiple primary key found means no primary key.
{
SchemaInfo schema = primaryKey.Schema;
StoreGeneratedPattern pattern = schema.DatabaseGeneratedOption;
if (pattern != StoreGeneratedPattern.AutoGenerateSequence)
{
bool isLocked = schema.IsLocked;
if (isLocked)
schema.Unlock();
schema.DatabaseGeneratedOption = StoreGeneratedPattern.AutoGenerateSequence;
if (isLocked)
schema.Lock();
}
}
}
public static SqlQuery CreateWhereSqlByKeys(IEntityMetaData metaData, char prefix, object entity)
{
if (null == entity)
throw new ArgumentNullException("entity");
IList<PropertyMetaData> keySchemas = metaData.OfKeys(true);
object[] keyValues = new object[keySchemas.Count];
for (int j = 0; j < keySchemas.Count; ++j)
{
keyValues[j] = keySchemas[j].Property.GetValue(entity, null);
}
FilterCriteriaList list = new FilterCriteriaList(prefix);
for (int j = 0; j < keySchemas.Count; ++j)
{
PropertyMetaData keySchema = keySchemas[j];
list.Add(keySchema, ConditionOperator.Equals, keyValues[j]);
}
return list.ToQuery();
}
public IObjRef GetCreateObjRef(Object obj, MergeHandle mergeHandle)
{
if (obj == null)
{
return(null);
}
IObjRef ori = null;
IDictionary <Object, IObjRef> objToOriDict = mergeHandle != null ? mergeHandle.objToOriDict : null;
if (objToOriDict != null)
{
ori = DictionaryExtension.ValueOrDefault(objToOriDict, obj);
}
if (ori != null)
{
return(ori);
}
if (obj is IObjRef)
{
return((IObjRef)obj);
}
if (!(obj is IEntityMetaDataHolder))
{
return(null);
}
IEntityMetaData metaData = ((IEntityMetaDataHolder)obj).Get__EntityMetaData();
Object keyValue;
if (obj is AbstractCacheValue)
{
keyValue = ((AbstractCacheValue)obj).Id;
}
else
{
keyValue = metaData.IdMember.GetValue(obj, false);
}
if (keyValue == null || mergeHandle != null && mergeHandle.HandleExistingIdAsNewId)
{
IDirectObjRef dirOri = new DirectObjRef(metaData.EntityType, obj);
if (keyValue != null)
{
dirOri.Id = keyValue;
}
ori = dirOri;
}
else
{
Object version;
if (obj is AbstractCacheValue)
{
version = ((AbstractCacheValue)obj).Version;
}
else
{
Member versionMember = metaData.VersionMember;
version = versionMember != null?versionMember.GetValue(obj, true) : null;
}
ori = ObjRefFactory.CreateObjRef(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, keyValue, version);
}
if (objToOriDict != null)
{
objToOriDict.Add(obj, ori);
IDictionary <IObjRef, Object> oriToObjDict = mergeHandle != null ? mergeHandle.oriToObjDict : null;
if (oriToObjDict != null && !oriToObjDict.ContainsKey(ori))
{
oriToObjDict.Add(ori, obj);
}
}
return(ori);
}
public override void PrePersist(IEntityMetaData metaData, Object entity)
{
CallMethod(entity, "PrePersist");
}
protected RootCacheValue(IEntityMetaData metaData)
{
// Intended blank
}
public virtual Object CreateEntity(Type entityType)
{
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(entityType);
return(CreateEntity(metaData));
}
public override Object CreateEntity(Type entityType)
{
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(entityType);
return(CreateEntityIntern(metaData, true));
}
SqlQuery IEntitySqlQueryBuilder.CreateQuery(object entity, IEntityMetaData metaData)
{
PropertyMetaData identity;
return this.CreateQuery(entity, metaData, out identity);
}
internal ProxyEntityMetaDataProvider(IEntityMetaData metaData)
{
this.metaData = metaData;
}
protected ICUDResult ApplyIntern(ICUDResult cudResult, bool checkBaseState, IncrementalMergeState incrementalState)
{
ICache stateCache = incrementalState.GetStateCache();
IList <IChangeContainer> allChanges = cudResult.AllChanges;
IList <Object> originalRefs = cudResult.GetOriginalRefs();
IList <Object> allObjects = GetAllExistingObjectsFromCache(stateCache, allChanges);
List <Object> hardRefs = new List <Object>();
hardRefs.Add(allObjects); // add list as item intended. adding each item of the source is NOT needed
List <IObjRef> toFetchFromCache = new List <IObjRef>();
List <DirectValueHolderRef> toPrefetch = new List <DirectValueHolderRef>();
List <IBackgroundWorkerDelegate> runnables = new List <IBackgroundWorkerDelegate>();
IEntityFactory entityFactory = this.EntityFactory;
IdentityHashMap <IObjRef, StateEntry> newObjRefToStateEntryMap = new IdentityHashMap <IObjRef, StateEntry>();
IdentityHashMap <IChangeContainer, IChangeContainer> alreadyClonedMap = new IdentityHashMap <IChangeContainer, IChangeContainer>();
List <IChangeContainer> newAllChanges = new List <IChangeContainer>(allChanges.Count);
for (int a = 0, size = allChanges.Count; a < size; a++)
{
IChangeContainer changeContainer = allChanges[a];
Object originalEntity = originalRefs[a];
StateEntry stateEntry = incrementalState.entityToStateMap.Get(originalEntity);
IChangeContainer newChangeContainer;
if (changeContainer is CreateContainer)
{
newChangeContainer = new CreateContainer();
}
else if (changeContainer is UpdateContainer)
{
newChangeContainer = new UpdateContainer();
}
else
{
newChangeContainer = new DeleteContainer();
}
newAllChanges.Add(newChangeContainer);
alreadyClonedMap.Put(changeContainer, newChangeContainer);
if (!(changeContainer is CreateContainer))
{
Object stateCacheEntity2 = allObjects[a];
stateEntry = incrementalState.entityToStateMap.Get(stateCacheEntity2);
if (stateEntry == null)
{
stateEntry = new StateEntry(stateCacheEntity2, changeContainer.Reference, incrementalState.entityToStateMap.Count + 1);
incrementalState.entityToStateMap.Put(stateCacheEntity2, stateEntry);
incrementalState.objRefToStateMap.Put(stateEntry.objRef, stateEntry);
}
// delete & update do not need further handling
continue;
}
Type realType = changeContainer.Reference.RealType;
Object stateCacheEntity;
if (stateEntry == null)
{
stateCacheEntity = entityFactory.CreateEntity(realType);
DirectObjRef directObjRef = new DirectObjRef(realType, stateCacheEntity);
directObjRef.CreateContainerIndex = a;
stateEntry = new StateEntry(stateCacheEntity, directObjRef, incrementalState.entityToStateMap.Count + 1);
incrementalState.entityToStateMap.Put(stateCacheEntity, stateEntry);
incrementalState.objRefToStateMap.Put(stateEntry.objRef, stateEntry);
newObjRefToStateEntryMap.Put(changeContainer.Reference, stateEntry);
}
else
{
stateCacheEntity = stateEntry.entity;
}
allObjects[a] = stateCacheEntity;
}
cloneStateTL.Value = new CloneState(newObjRefToStateEntryMap, incrementalState);
try
{
for (int a = allChanges.Count; a-- > 0;)
{
IChangeContainer changeContainer = allChanges[a];
IObjRefContainer entity = (IObjRefContainer)allObjects[a];
changeContainer = FillClonedChangeContainer(changeContainer, alreadyClonedMap);
IPrimitiveUpdateItem[] puis;
IRelationUpdateItem[] ruis;
if (changeContainer is CreateContainer)
{
CreateContainer createContainer = (CreateContainer)changeContainer;
puis = createContainer.Primitives;
ruis = createContainer.Relations;
}
else if (changeContainer is UpdateContainer)
{
UpdateContainer updateContainer = (UpdateContainer)changeContainer;
puis = updateContainer.Primitives;
ruis = updateContainer.Relations;
}
else
{
((IDataObject)entity).ToBeDeleted = true;
continue;
}
IEntityMetaData metaData = ((IEntityMetaDataHolder)entity).Get__EntityMetaData();
ApplyPrimitiveUpdateItems(entity, puis, metaData);
if (ruis != null)
{
bool isUpdate = changeContainer is UpdateContainer;
foreach (IRelationUpdateItem rui in ruis)
{
ApplyRelationUpdateItem(entity, rui, isUpdate, metaData, toPrefetch, toFetchFromCache, checkBaseState, runnables);
}
}
}
while (toPrefetch.Count > 0 || toFetchFromCache.Count > 0 || runnables.Count > 0)
{
if (toPrefetch.Count > 0)
{
PrefetchHelper.Prefetch(toPrefetch);
toPrefetch.Clear();
}
if (toFetchFromCache.Count > 0)
{
IList <Object> fetchedObjects = stateCache.GetObjects(toFetchFromCache, CacheDirective.None);
hardRefs.Add(fetchedObjects); // add list as item intended. adding each item of the source is NOT needed
toFetchFromCache.Clear();
}
IBackgroundWorkerDelegate[] runnableArray = runnables.ToArray();
runnables.Clear();
foreach (IBackgroundWorkerDelegate runnable in runnableArray)
{
runnable();
}
}
List <Object> newObjects = new List <Object>(allObjects.Count);
List <DirectValueHolderRef> changedRelationRefs = new List <DirectValueHolderRef>();
for (int a = allObjects.Count; a-- > 0;)
{
IChangeContainer newChange = newAllChanges[a];
IRelationUpdateItem[] ruis = null;
Object entity = allObjects[a];
if (newChange is CreateContainer)
{
newObjects.Add(entity);
ruis = ((CreateContainer)newChange).Relations;
}
else if (newChange is UpdateContainer)
{
ruis = ((UpdateContainer)newChange).Relations;
}
if (ruis == null)
{
continue;
}
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(entity.GetType());
foreach (IRelationUpdateItem rui in ruis)
{
Member member = metaData.GetMemberByName(rui.MemberName);
changedRelationRefs.Add(new DirectValueHolderRef((IObjRefContainer)entity, (RelationMember)member));
}
}
if (newObjects.Count > 0)
{
((IWritableCache)stateCache).Put(newObjects);
}
if (changedRelationRefs.Count > 0)
{
PrefetchHelper.Prefetch(changedRelationRefs);
}
return(new CUDResult(newAllChanges, allObjects));
}
finally
{
cloneStateTL.Value = null;
}
}
public IdentityLinkedSet <Member> GetPrioMembers(ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchPath,
List <PrefetchCommand> pendingPrefetchCommands, MergePrefetchPathsCache mergePrefetchPathsCache)
{
IdentityLinkedSet <Member> key1 = new IdentityLinkedSet <Member>();
PrioMembersKey key = new PrioMembersKey(entityTypeToPrefetchPath, key1);
for (int a = 0, size = pendingPrefetchCommands.Count; a < size; a++)
{
PrefetchCommand prefetchCommand = pendingPrefetchCommands[a];
key1.Add(prefetchCommand.valueHolder.Member);
}
IdentityLinkedSet <Member> prioMembersMap = activeMembersToPrioMembersMap.Get(key);
if (prioMembersMap != null)
{
return(prioMembersMap);
}
prioMembersMap = new IdentityLinkedSet <Member>(0.5f);
Tuple2KeyHashMap <Type, PrefetchPath[], bool?> alreadyVisited = null;
IdentityHashSet <Type> touchedTypesInPriority = null;
if (mergePrefetchPathsCache == null)
{
mergePrefetchPathsCache = new MergePrefetchPathsCache(entityMetaDataProvider);
}
bool prio2Mode = true;
foreach (PrefetchCommand prefetchCommand in pendingPrefetchCommands)
{
DirectValueHolderRef valueHolder = prefetchCommand.valueHolder;
PrefetchPath[] prefetchPaths = prefetchCommand.prefetchPaths;
RelationMember member = valueHolder.Member;
Type targetEntityType = member.ElementType;
// Merge the root prefetch path with the relative prefetch path
prefetchPaths = mergePrefetchPathsCache.MergePrefetchPaths(targetEntityType, prefetchPaths, entityTypeToPrefetchPath);
IEntityMetaData metaData = valueHolder.Vhc.Get__EntityMetaData();
if (targetEntityType.Equals(metaData.EntityType))
{
// prio1 overrides prio2
if (prio2Mode)
{
prio2Mode = false;
alreadyVisited = null;
prioMembersMap.Clear();
if (touchedTypesInPriority != null)
{
touchedTypesInPriority.Clear();
}
}
prioMembersMap.Add(member);
if (touchedTypesInPriority == null)
{
touchedTypesInPriority = new IdentityHashSet <Type>();
}
touchedTypesInPriority.Add(member.EntityType);
touchedTypesInPriority.Add(targetEntityType);
continue;
}
if (prefetchPaths == null || !prio2Mode)
{
continue;
}
if (alreadyVisited == null)
{
alreadyVisited = new Tuple2KeyHashMap <Type, PrefetchPath[], bool?>();
}
if (IsPrio2Member(metaData, entityMetaDataProvider.GetMetaData(targetEntityType), prefetchPaths, entityTypeToPrefetchPath, alreadyVisited,
mergePrefetchPathsCache))
{
prioMembersMap.Add(member);
if (touchedTypesInPriority == null)
{
touchedTypesInPriority = new IdentityHashSet <Type>();
}
touchedTypesInPriority.Add(member.EntityType);
touchedTypesInPriority.Add(targetEntityType);
}
}
if (prioMembersMap.Count > 0)
{
// check for out-of-order members which have nothing to do (and will never ever have in a transitive manner) with the priorized members
foreach (PrefetchCommand prefetchCommand in pendingPrefetchCommands)
{
DirectValueHolderRef valueHolder = prefetchCommand.valueHolder;
RelationMember member = valueHolder.Member;
if (prioMembersMap.Contains(member))
{
// already priorized
continue;
}
if (touchedTypesInPriority.Contains(member.EntityType) || touchedTypesInPriority.Contains(member.ElementType))
{
continue;
}
prioMembersMap.Add(member);
}
}
Object writeLock = activeMembersToPrioMembersMap.GetWriteLock();
lock (writeLock)
{
IdentityLinkedSet <Member> existingPrioMembersMap = activeMembersToPrioMembersMap.Get(key);
if (existingPrioMembersMap != null)
{
return(existingPrioMembersMap);
}
activeMembersToPrioMembersMap.Put(key, prioMembersMap);
return(prioMembersMap);
}
}
public DefaultRootCacheValue(IEntityMetaData metaData) : base(metaData)
{
this.metaData = metaData;
}
public abstract void PrePersist(IEntityMetaData metaData, Object entity);
public override void PrePersist(IEntityMetaData metaData, Object entity)
{
// intended blank
}
public override void PostLoad(IEntityMetaData metaData, Object entity)
{
CallMethod(entity, "PostLoad");
}
public GetIdMethodCreator(IClassVisitor cv, IEntityMetaData metaData)
: base(cv)
{
this.metaData = metaData;
}
protected void ApplyPrimitiveUpdateItems(Object entity, IPrimitiveUpdateItem[] puis, IEntityMetaData metadata)
{
if (puis == null)
{
return;
}
foreach (IPrimitiveUpdateItem pui in puis)
{
String memberName = pui.MemberName;
Object newValue = pui.NewValue;
Member member = metadata.GetMemberByName(memberName);
member.SetValue(entity, newValue);
}
}
public virtual SqlQuery CreateQuery(object entity, IEntityMetaData metaData, int index, out PropertyMetaData identity)
{
if (null == entity)
throw new ArgumentNullException(nameof(entity));
identity = null;
bool insertFieldsEnabled = !this.InsertFields.IsEmptyList();
SqlQuery query = new SqlQuery();
StringBuilder text = query.Text;
text.Append("INSERT INTO ");
text.Append(metaData.TableName);
text.Append(" (");
List<PropertyMetaData> validInfos = new List<PropertyMetaData>();
foreach (PropertyMetaData property in metaData.Properties)
{
SchemaInfo schema = property.Schema;
switch (schema.DatabaseGeneratedOption)
{
case StoreGeneratedPattern.Identity:
if (null != identity)
throw new MultipleIdentityColumnFoundException(entity);
identity = property;
break;
case StoreGeneratedPattern.Computed:
break;
default:
if (insertFieldsEnabled && !this.InsertFields.Contains(schema.ColumnName))
continue;
text.Append(schema.ColumnName);
text.Append(',');
validInfos.Add(property);
break;
}
}
text.Remove(text.Length - 1, 1);
text.Append(") VALUES (");
foreach (PropertyMetaData property in validInfos)
{
SqlQueryHelper.SetColumnValue(ValueSetter.Instance, metaData, index, query, property, entity);
text.Append(',');
}
text.Remove(text.Length - 1, 1);
text.Append(')');
if (null != identity)
{
text.Append(" RETURNING ");
text.Append(identity.Schema.ColumnName);
text.Append(';');
}
else if (this.UseSemicolon)
text.Append(';');
return query;
}
protected void ApplyRelationUpdateItem(IObjRefContainer entity, IRelationUpdateItem rui, bool isUpdate,
IEntityMetaData metaData, IList <DirectValueHolderRef> toPrefetch, List <IObjRef> toFetchFromCache, bool checkBaseState,
IList <IBackgroundWorkerDelegate> runnables)
{
IObjRefHelper objRefHelper = this.ObjRefHelper;
String memberName = rui.MemberName;
int relationIndex = metaData.GetIndexByRelationName(memberName);
RelationMember relationMember = metaData.RelationMembers[relationIndex];
IObjRef[] existingORIs;
if (entity.Is__Initialized(relationIndex))
{
existingORIs = ListUtil.ToArray(ObjRefHelper.ExtractObjRefList(relationMember.GetValue(entity), null));
}
else
{
existingORIs = entity.Get__ObjRefs(relationIndex);
if (existingORIs == null)
{
toPrefetch.Add(new DirectValueHolderRef(entity, relationMember, true));
runnables.Add(new IBackgroundWorkerDelegate(delegate()
{
ApplyRelationUpdateItem(entity, rui, isUpdate, metaData, toPrefetch, toFetchFromCache, checkBaseState, runnables);
}));
return;
}
}
IObjRef[] addedORIs = rui.AddedORIs;
IObjRef[] removedORIs = rui.RemovedORIs;
IObjRef[] newORIs;
if (existingORIs.Length == 0)
{
if (checkBaseState && removedORIs != null)
{
throw new Exception("Removing from empty member");
}
newORIs = addedORIs != null ? (IObjRef[])addedORIs.Clone() : ObjRef.EMPTY_ARRAY;
for (int a = newORIs.Length; a-- > 0;)
{
newORIs[a] = CloneObjRef(newORIs[a], false);
}
}
else
{
// Set to efficiently remove entries
LinkedHashSet <IObjRef> existingORIsSet = new LinkedHashSet <IObjRef>(existingORIs);
if (removedORIs != null)
{
foreach (IObjRef removedORI in removedORIs)
{
IObjRef clonedObjRef = CloneObjRef(removedORI, false);
if (existingORIsSet.Remove(clonedObjRef) || !checkBaseState)
{
continue;
}
throw OptimisticLockUtil.ThrowModified(objRefHelper.EntityToObjRef(entity), null, entity);
}
}
if (addedORIs != null)
{
foreach (IObjRef addedORI in addedORIs)
{
IObjRef clonedObjRef = CloneObjRef(addedORI, false);
if (existingORIsSet.Add(clonedObjRef) || !checkBaseState)
{
continue;
}
throw OptimisticLockUtil.ThrowModified(objRefHelper.EntityToObjRef(entity), null, entity);
}
}
if (existingORIsSet.Count == 0)
{
newORIs = ObjRef.EMPTY_ARRAY;
}
else
{
newORIs = existingORIsSet.ToArray();
}
}
if (!entity.Is__Initialized(relationIndex))
{
entity.Set__ObjRefs(relationIndex, newORIs);
return;
}
toFetchFromCache.AddRange(newORIs);
runnables.Add(new IBackgroundWorkerDelegate(delegate()
{
ICache stateCache = cloneStateTL.Value.incrementalState.GetStateCache();
IList <Object> objects = stateCache.GetObjects(newORIs, CacheDirective.FailEarly);
Object value;
if (relationMember.IsToMany)
{
// To-many relation
Object coll = ListUtil.CreateObservableCollectionOfType(relationMember.RealType, objects.Count);
ListUtil.FillList(coll, objects);
value = coll;
}
else
{
// To-one relation
value = objects.Count > 0 ? objects[0] : null;
}
relationMember.SetValue(entity, value);
}));
}
public abstract void PostCreate(IEntityMetaData metaData, Object newEntity);
public static void IndexParameterNames(IEntityMetaData metaData, int parameterIndex)//ParameterIndex Batch ler için.
{
if (parameterIndex > -1)
{
IEnumerable<PropertyMetaData> properties = metaData.Properties;
int fieldCount = ((ICollection<PropertyMetaData>)properties).Count;
int factor = fieldCount * parameterIndex;
foreach (PropertyMetaData prop in properties)
{
prop.ParameterName = (factor++).ToString();
}
}
else
{
int indexName = -1;
foreach (PropertyMetaData prop in metaData.Properties)
{
prop.ParameterName = (++indexName).ToString();
}
}
}
public override Object CreateEntity(IEntityMetaData metaData)
{
return(CreateEntityIntern(metaData, true));
}
public Object CreateEntity(IEntityMetaData metadata)
{
return(CreateEntity(metadata.EntityType));
}
public abstract Object CreateEntity(IEntityMetaData metaData);
public abstract RootCacheValue CreateRootCacheValue(IEntityMetaData metaData);
public override void PostLoad(IEntityMetaData metaData, Object entity)
{
// intended blank
}
public CacheMapEntryVisitor(IClassVisitor cv, IEntityMetaData metaData, sbyte idIndex)
: base(cv)
{
this.metaData = metaData;
this.idIndex = idIndex;
}
public override void PostCreate(IEntityMetaData metaData, Object newEntity)
{
// intended blank
}
protected override int ExecuteInternal(IEnumerable<IEntityChange> changes, BatchCommandMode mode, IEntityMetaData metaData)
{
IEnumerable<IEntityChange> modified = changes.Where(e => e.State == EntityState.Modified);
IEnumerable<IEntityChange> deleted = changes.Where(e => e.State == EntityState.Deleted);
IEnumerable<IEntityChange> added = changes.Where(e => e.State == EntityState.Added);
switch (mode)
{
case BatchCommandMode.Batch:
SqlQuery batchQuery = new SqlQuery();
batchQuery.Text.Append(GlobalInternal.BeginStatement);
batchQuery.Text.AppendLine();
int index = 0;
if (!modified.IsEmptyList())
{
EntitySqlQueryBuilderUpdate updateBuilder = new EntitySqlQueryBuilderUpdate() { UseSemicolon = true };
foreach (IEntityChange change in modified)
{
updateBuilder.ParameterIndex = index++;
updateBuilder.UpdatedFields = change.UpdatedFields;
batchQuery.Combine(updateBuilder.CreateQuery(change.Entity, metaData));
batchQuery.Text.AppendLine();
}
batchQuery.Text.AppendLine();
}
if (!deleted.IsEmptyList())
{
foreach (IEntityChange change in deleted)
{
SqlQuery deleteQuery = new SqlQuery();
deleteQuery.Text.Append("DELETE FROM ");
deleteQuery.Text.Append(metaData.TableName);
SqlQueryHelper.IndexParameterNames(metaData, index++);
deleteQuery.Combine(SqlQueryHelper.CreateWhereSqlByKeys(metaData, '@', change.Entity));
batchQuery.Combine(deleteQuery);
batchQuery.Text.AppendLine(";");
}
batchQuery.Text.AppendLine();
}
if (!added.IsEmptyList())
{
PropertyMetaData sequenceIdentity = null;
EntitySqlQueryBuilderInsert insertBuilder = new EntitySqlQueryBuilderInsert() { UseSemicolon = true };
foreach (IEntityChange change in added)
{
insertBuilder.ParameterIndex = index++;
batchQuery.Combine(insertBuilder.CreateQuery(change.Entity, metaData, out sequenceIdentity));
batchQuery.Text.AppendLine();
}
}
batchQuery.Text.Append(GlobalInternal.EndStatement);
return base.DataAccess.ExecuteNonQuery(batchQuery);
case BatchCommandMode.Single:
int sum = 0;
if (!modified.IsEmptyList())
{
EntityCommandUpdate updateCommand = new EntityCommandUpdate(base.DataAccess);
foreach (IEntityChange change in modified)
{
updateCommand.UpdatedFields = change.UpdatedFields;
sum += updateCommand.UpdateInternal(change.Entity, metaData);
}
}
if (!deleted.IsEmptyList())
{
EntityCommandDelete deleteCommand = new EntityCommandDelete(base.DataAccess);
foreach (IEntityChange change in deleted)
{
sum += deleteCommand.DeleteInternal(change.Entity, metaData);
}
}
if (!added.IsEmptyList())
{
EntityCommandInsert insertCommand = new EntityCommandInsert(base.DataAccess);
foreach (IEntityChange change in added)
{
sum += insertCommand.InsertInternal(change.Entity, metaData);
}
}
return sum;
default:
throw new NotSupportedException(mode.ToString());
}
}
public IObjRef EntityToObjRef(Object entity, IEntityMetaData metaData)
{
return(EntityToObjRef(entity, ObjRef.PRIMARY_KEY_INDEX, metaData));
}
public virtual SqlQuery CreateQuery(object entity, IEntityMetaData metaData, int index, out PropertyMetaData sequenceIdentity)
{
EntitySqlQueryBuilderUpdate builderUpdate = new EntitySqlQueryBuilderUpdate() { UseSemicolon = true };
builderUpdate.UpdatedFields = this.UpdatedFields;
SqlQuery query = new SqlQuery();
StringBuilder text = query.Text;
if (!this.isBatchUpsert)
text.Append(GlobalInternal.OracleBeginStatement);
query.Combine(builderUpdate.CreateQuery(entity, metaData, index));
text.AppendLine();
text.Append("IF SQL%ROWCOUNT = 0 THEN ");
text.AppendLine();
EntitySqlQueryBuilderInsert builderInsert = new EntitySqlQueryBuilderInsert(this.dataAccess, true) { UseSemicolon = true };
builderInsert.InsertFields = this.InsertFields;
query.Combine(builderInsert.CreateQuery(entity, metaData, index, out sequenceIdentity));
text.AppendLine();
text.Append("END IF;");
if (!this.isBatchUpsert)
text.Append(GlobalInternal.OracleEndStatement);
return query;
}
protected virtual void RevertChangesIntern(IRevertChangesSavepoint savepoint, IList <Object> objectsToRevert, bool globally,
RevertChangesFinishedCallback revertChangesFinishedCallback)
{
// Store the RevertChangesFinishedCallback from this thread on the stack and set the property null (for following calls):
if (objectsToRevert == null || objectsToRevert.Count == 0)
{
if (revertChangesFinishedCallback != null)
{
revertChangesFinishedCallback.Invoke(true);
}
return;
}
if (globally)
{
GuiThreadHelper.InvokeOutOfGui(delegate()
{
bool success = false;
try
{
DataChangeEvent dataChange = new DataChangeEvent();
dataChange.IsLocalSource = true;
dataChange.Inserts = new List <IDataChangeEntry>(0);
dataChange.Updates = new List <IDataChangeEntry>();
dataChange.Deletes = new List <IDataChangeEntry>();
for (int a = objectsToRevert.Count; a-- > 0;)
{
Object objectToRevert = objectsToRevert[a];
IEntityMetaData metaData = ((IEntityMetaDataHolder)objectToRevert).Get__EntityMetaData();
Object id = metaData.IdMember.GetValue(objectToRevert, false);
if (id == null)
{
dataChange.Deletes.Add(new DirectDataChangeEntry(objectToRevert));
continue;
}
dataChange.Updates.Add(new DataChangeEntry(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null));
}
EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1);
success = true;
}
finally
{
if (revertChangesFinishedCallback != null)
{
revertChangesFinishedCallback.Invoke(success);
}
}
});
}
else
{
// Commented the following part from Ambeth 0.130 and use the part from Ambeth 0.129 due to a deadlock in the merge process:
//GuiThreadHelper.InvokeOutOfGui(delegate()
//{
// bool success1 = false;
// try
// {
// IList<IDataChangeEntry> directObjectDeletes = new List<IDataChangeEntry>();
// IList<Object> initializedObjects = MergeController.ScanForInitializedObjects(objectsToRevert, true, null);
// IList<IObjRef> orisToRevert = new List<IObjRef>();
// ISet<Object> persistedObjectsToRevert = new IdentityHashSet<Object>();
// for (int a = initializedObjects.Count; a-- > 0; )
// {
// Object objectToRevert = initializedObjects[a];
// IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(objectToRevert.GetType());
// Object id = metaData.IdMember.GetValue(objectToRevert, false);
// if (id == null)
// {
// directObjectDeletes.Add(new DirectDataChangeEntry(objectToRevert));
// continue;
// }
// persistedObjectsToRevert.Add(objectToRevert);
// orisToRevert.Add(new ObjRef(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null));
// }
// IList<Object> hardRefsToRootCacheValues = RootCache.GetObjects(orisToRevert, CacheDirective.CacheValueResult | CacheDirective.ReturnMisses);
// for (int a = orisToRevert.Count; a-- > 0; )
// {
// if (hardRefsToRootCacheValues[a] == null)
// {
// // Object could not be loaded/retrieved any more. So the ori refers to an invalid object
// // We can not revert invalid objects and currently ignore them. They will raise exceptions if they will
// // be tried to persist in a merge process any time in the future
// orisToRevert.RemoveAt(a);
// }
// }
// // We do nothing with the hardRef-list from the RootCache. It is only necessary to keep track of the instance reference on the stack
// // To prohibit GC any potential WeakReferences in the meantime....
// GuiThreadHelper.InvokeInGuiAndWait(delegate()
// {
// IProcessResumeItem processResumeItem = WaitEventToResume();
// try
// {
// bool oldCacheModificationValue = CacheModification.IsActive;
// CacheModification.IsActive = true;
// bool oldFailEarlyModeActive = AbstractCache<Object>.FailEarlyModeActive;
// AbstractCache<Object>.FailEarlyModeActive = true;
// try
// {
// IList<IWritableCache> firstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();
// IList<Object> hardRefsToRootCacheValuesHere = hardRefsToRootCacheValues;
// foreach (IWritableCache firstLevelCache in firstLevelCaches)
// {
// IList<Object> persistedObjectsInThisCache = firstLevelCache.GetObjects(orisToRevert, CacheDirective.FailEarly);
// for (int a = persistedObjectsInThisCache.Count; a-- > 0; )
// {
// Object persistedObjectInThisCache = persistedObjectsInThisCache[a];
// if (!persistedObjectsToRevert.Contains(persistedObjectInThisCache))
// {
// continue;
// }
// RootCache.ApplyValues(persistedObjectInThisCache, (ICacheIntern)firstLevelCache);
// }
// }
// for (int a = objectsToRevert.Count; a-- > 0; )
// {
// Object objectToRevert = objectsToRevert[a];
// if (objectToRevert is IDataObject)
// {
// // Objects which are specified to be reverted loose their delete flag
// ((IDataObject)objectToRevert).ToBeDeleted = false;
// }
// }
// }
// finally
// {
// AbstractCache<Object>.FailEarlyModeActive = oldFailEarlyModeActive;
// CacheModification.IsActive = oldCacheModificationValue;
// }
// }
// finally
// {
// if (processResumeItem != null)
// {
// processResumeItem.ResumeProcessingFinished();
// processResumeItem = null;
// }
// }
// });
// if (directObjectDeletes.Count > 0)
// {
// DataChangeEvent dataChange = DataChangeEvent.Create(0, 0, 0);
// dataChange.Deletes = directObjectDeletes;
// EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1);
// }
// success1 = true;
// }
// finally
// {
// if (revertChangesFinishedCallback != null)
// {
// revertChangesFinishedCallback.Invoke(success1);
// }
// }
//});
// Here comes the part from Ambeth 0.129:
GuiThreadHelper.InvokeOutOfGui(delegate()
{
bool success1 = false;
bool?success2 = null;
bool?success3 = null;
try
{
IList <IDataChangeEntry> directObjectDeletes = new List <IDataChangeEntry>();
List <IObjRef> objRefs = new List <IObjRef>();
List <ValueHolderRef> valueHolderKeys = new List <ValueHolderRef>();
IList <Object> initializedObjects = MergeController.ScanForInitializedObjects(objectsToRevert, true, null, objRefs, valueHolderKeys);
IList <IObjRef> orisToRevert = new List <IObjRef>();
ISet <Object> persistedObjectsToRevert = new IdentityHashSet <Object>();
for (int a = initializedObjects.Count; a-- > 0;)
{
Object objectToRevert = initializedObjects[a];
IEntityMetaData metaData = ((IEntityMetaDataHolder)objectToRevert).Get__EntityMetaData();
Object id = metaData.IdMember.GetValue(objectToRevert, false);
if (id == null)
{
directObjectDeletes.Add(new DirectDataChangeEntry(objectToRevert));
continue;
}
persistedObjectsToRevert.Add(objectToRevert);
orisToRevert.Add(new ObjRef(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null));
}
IList <Object> hardRefsToRootCacheValues = RootCache.GetObjects(orisToRevert, CacheDirective.CacheValueResult | CacheDirective.ReturnMisses);
for (int a = orisToRevert.Count; a-- > 0;)
{
if (hardRefsToRootCacheValues[a] == null)
{
// Object could not be loaded/retrieved any more. So the ori refers to an invalid object
// We can not revert invalid objects and currently ignore them. They will raise exceptions if they will
// be tried to persist in a merge process any time in the future
orisToRevert.RemoveAt(a);
}
}
// We do nothing with the hardRef-list from the RootCache. It is only necessary to keep track of the instance reference on the stack
// To prohibit GC any potential WeakReferences in the meantime....
success2 = false;
GuiThreadHelper.InvokeInGui(delegate(Object state)
{
WaitEventToResume(delegate(IProcessResumeItem processResumeItem)
{
try
{
bool oldCacheModificationValue = CacheModification.Active;
CacheModification.Active = true;
bool oldFailEarlyModeActive = AbstractCache.FailInCacheHierarchyModeActive;
AbstractCache.FailInCacheHierarchyModeActive = true;
try
{
IList <IWritableCache> firstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();
IList <Object> hardRefsToRootCacheValuesHere = hardRefsToRootCacheValues;
foreach (IWritableCache firstLevelCache in firstLevelCaches)
{
IList <Object> persistedObjectsInThisCache = firstLevelCache.GetObjects(orisToRevert, CacheDirective.FailEarly);
for (int a = persistedObjectsInThisCache.Count; a-- > 0;)
{
Object persistedObjectInThisCache = persistedObjectsInThisCache[a];
if (!persistedObjectsToRevert.Contains(persistedObjectInThisCache))
{
continue;
}
RootCache.ApplyValues(persistedObjectInThisCache, (ICacheIntern)firstLevelCache, null);
}
}
for (int a = objectsToRevert.Count; a-- > 0;)
{
Object objectToRevert = objectsToRevert[a];
if (objectToRevert is IDataObject)
{
// Objects which are specified to be reverted loose their flags
((IDataObject)objectToRevert).ToBeDeleted = false;
}
}
if (directObjectDeletes.Count == 0)
{
success2 = true;
return;
}
}
finally
{
AbstractCache.FailInCacheHierarchyModeActive = oldFailEarlyModeActive;
CacheModification.Active = oldCacheModificationValue;
}
}
finally
{
if (processResumeItem != null)
{
processResumeItem.ResumeProcessingFinished();
}
}
success3 = false;
GuiThreadHelper.InvokeOutOfGui(delegate()
{
try
{
DataChangeEvent dataChange = DataChangeEvent.Create(0, 0, 0);
dataChange.Deletes = directObjectDeletes;
EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1);
success3 = true;
}
finally
{
if (revertChangesFinishedCallback != null)
{
revertChangesFinishedCallback.Invoke(success3.Value);
}
}
});
success2 = true;
}, delegate(Exception e)
{
if (revertChangesFinishedCallback != null && success3 == null)
{
revertChangesFinishedCallback.Invoke(success2.Value);
}
});
}, null);
success1 = true;
}
finally
{
if (revertChangesFinishedCallback != null && success2 == null && success3 == null)
{
revertChangesFinishedCallback.Invoke(success1);
}
}
});
}
}
public abstract void PostLoad(IEntityMetaData metaData, Object entity);
public SqlQueryBuilderSelect(IEntityMetaData metaData)
{
metaData.EnsureEntityMetaData();
this.MetaData = metaData;
}
protected virtual Object PostProcessCacheResult(IList <IObjRef> objRefs, IList <Object> cacheResult, Type expectedType, IServiceResult serviceResult, Object[] originalArgs,
Attribute annotation)
{
int cacheResultSize = cacheResult != null ? cacheResult.Count : objRefs.Count;
if (typeof(IEnumerable).IsAssignableFrom(expectedType))
{
Object targetCollection = ListUtil.CreateCollectionOfType(expectedType);
MethodInfo addMethod = targetCollection.GetType().GetMethod("Add");
Object[] parameters = new Object[1];
if (cacheResult != null)
{
for (int a = 0; a < cacheResultSize; a++)
{
parameters[0] = cacheResult[a];
addMethod.Invoke(targetCollection, parameters);
}
}
else
{
for (int a = 0; a < cacheResultSize; a++)
{
parameters[0] = objRefs[a];
addMethod.Invoke(targetCollection, parameters);
}
}
return(targetCollection);
}
else if (expectedType.IsArray)
{
Array array = Array.CreateInstance(expectedType.GetElementType(), cacheResultSize);
if (cacheResult != null)
{
for (int a = 0; a < cacheResultSize; a++)
{
array.SetValue(cacheResult[a], a);
}
}
else
{
for (int a = 0; a < cacheResultSize; a++)
{
array.SetValue(objRefs[a], a);
}
}
return(array);
}
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(expectedType, true);
if (metaData != null)
{
// It is a simple entity which can be returned directly
if (cacheResultSize == 0)
{
return(null);
}
else if (cacheResultSize == 1)
{
return(cacheResult != null ? cacheResult[0] : objRefs[0]);
}
}
Object additionalInformation = serviceResult != null ? serviceResult.AdditionalInformation : null;
if (additionalInformation == null)
{
throw new Exception("Can not convert list of " + cacheResultSize + " results from cache to type " + expectedType.FullName);
}
IServiceResultProcessor serviceResultProcessor = ServiceResultProcessorRegistry.GetServiceResultProcessor(expectedType);
return(serviceResultProcessor.ProcessServiceResult(additionalInformation, objRefs, cacheResult, expectedType, originalArgs, annotation));
}
public virtual SqlQuery CreateQuery(object entity, IEntityMetaData metaData, int index, out PropertyMetaData sequenceIdentity)
{
if (null == entity)
throw new ArgumentNullException(nameof(entity));
sequenceIdentity = null;
bool insertFieldsEnabled = !this.InsertFields.IsEmptyList();
SqlQuery query = new SqlQuery();
StringBuilder text = query.Text;
text.Append("INSERT INTO ");
text.Append(metaData.TableName);
text.Append(" (");
List<PropertyMetaData> validInfos = new List<PropertyMetaData>();
foreach (PropertyMetaData property in metaData.Properties)
{
SchemaInfo schema = property.Schema;
switch (schema.DatabaseGeneratedOption)
{
case StoreGeneratedPattern.Identity://Oracle 12c ile test edilip bu kısımda çalışılabilr hale getirilecek.
case StoreGeneratedPattern.Computed:
continue;// not in insert list.
//case StoreGeneratedPattern.Sequence:
// if (schema.DefaultValue.Length == 0)
// throw new NullReferenceException("if SchemaInfo.DatabaseGeneratedOption = Sequence then Schema.DefaultValue can not be null or empty");
// break;
case StoreGeneratedPattern.AutoGenerateSequence:
if (null != sequenceIdentity)
throw new MultipleIdentityColumnFoundException(entity);
sequenceIdentity = property;
break;//Identity ise insert list e giriyor.
default:
if (insertFieldsEnabled && !this.InsertFields.Contains(schema.ColumnName))
continue;
break;
}
text.Append(schema.ColumnName);
text.Append(',');
validInfos.Add(property);
}
text.Remove(text.Length - 1, 1);
text.Append(") VALUES (");
bool addSequenceIdentity = null != sequenceIdentity;
foreach (PropertyMetaData property in validInfos)
{
SchemaInfo schema = property.Schema;
if (addSequenceIdentity && sequenceIdentity.Schema.Equals(schema))
{
text.Append(SequenceManager.GetSequenceName(this.dataAccess, metaData.TableName, sequenceIdentity.Schema.ColumnName));
text.Append(".NEXTVAL,");
addSequenceIdentity = false;
}
else
{
SqlQueryHelper.SetColumnValue(ValueSetter.Instance, metaData, index, query, property, entity);
text.Append(',');
}
}
text.Remove(text.Length - 1, 1);
text.Append(')');
if (null != sequenceIdentity)
{
text.AppendLine();
text.Append("RETURNING ");
text.Append(sequenceIdentity.Schema.ColumnName);
text.Append(" INTO :");
string parameterName = metaData.GetParameterName(sequenceIdentity, index);
text.Append(parameterName);
SqlQueryParameter identityParameter = SqlQueryHelper.EnsureHasParameter(query, parameterName, sequenceIdentity, entity);
identityParameter.Direction = this.isUpsert ? System.Data.ParameterDirection.InputOutput : System.Data.ParameterDirection.Output;
}
if (this.UseSemicolon)
text.Append(';');
return query;
}
protected override Object InterceptLoad(IInvocation invocation, Attribute annotation, Boolean?isAsyncBegin)
{
ServiceDescription serviceDescription;
IServiceResult serviceResult;
MethodInfo method = invocation.Method;
Object[] args = invocation.Arguments;
CachedAttribute cached = annotation is CachedAttribute ? (CachedAttribute)annotation : null;
if (cached == null && pauseCache.Value)
{
return(base.InterceptLoad(invocation, annotation, isAsyncBegin));
}
Type returnType = method.ReturnType;
if (ImmutableTypeSet.IsImmutableType(returnType))
{
// No possible result which might been read by cache
return(base.InterceptLoad(invocation, annotation, isAsyncBegin));
}
if (cached == null)
{
ISecurityScope[] securityScopes = SecurityScopeProvider.SecurityScopes;
serviceDescription = SyncToAsyncUtil.CreateServiceDescription(ServiceName, method, args, securityScopes);
serviceResult = CacheService.GetORIsForServiceRequest(serviceDescription);
return(CreateResultObject(serviceResult, returnType, args, annotation));
}
if (args.Length != 1)
{
throw new Exception("This annotation is only allowed on methods with exactly 1 argument. Please check your "
+ typeof(CachedAttribute).FullName + " annotation on method " + method.ToString());
}
Type entityType = cached.Type;
if (entityType == null || typeof(void).Equals(entityType))
{
entityType = TypeInfoItemUtil.GetElementTypeUsingReflection(returnType, null);
}
if (entityType == null || typeof(void).Equals(entityType))
{
throw new Exception("Please specify a valid returnType for the " + typeof(CachedAttribute).FullName + " annotation on method "
+ method.ToString());
}
IEntityMetaData metaData = GetSpecifiedMetaData(method, typeof(CachedAttribute), entityType);
Member member = GetSpecifiedMember(method, typeof(CachedAttribute), metaData, cached.AlternateIdName);
sbyte idIndex;
try
{
idIndex = metaData.GetIdIndexByMemberName(member.Name);
}
catch (Exception e)
{
throw new Exception(
"Member "
+ entityType.FullName
+ "."
+ cached.AlternateIdName
+ " is not configured as an alternate ID member. There must be a single-column unique contraint on the respective table column. Please check your "
+ typeof(CachedAttribute).FullName + " annotation on method " + method.ToString(), e);
}
bool returnMisses = cached.ReturnMisses;
List <IObjRef> orisToGet = new List <IObjRef>();
FillOrisToGet(orisToGet, args, entityType, idIndex, returnMisses);
return(CreateResultObject(orisToGet, returnType, returnMisses, annotation));
}
protected override int ExecuteInternal(IEnumerable<IEntityChange> changes, BatchCommandMode mode, IEntityMetaData metaData)
{
PropertyMetaData identity = null;
Dictionary<string, object> outs = new Dictionary<string, object>();
IEnumerable<IEntityChange> modified = changes.Where(e => e.State == EntityState.Modified);
IEnumerable<IEntityChange> deleted = changes.Where(e => e.State == EntityState.Deleted);
IEnumerable<IEntityChange> added = changes.Where(e => e.State == EntityState.Added);
switch (mode)
{
case BatchCommandMode.Batch:
SqlQuery batchQuery = new SqlQuery();
batchQuery.Text.Append(GlobalInternal.SqlServerBeginStatement);
batchQuery.Text.AppendLine();
int index = 0;
if (!modified.IsEmptyList())
{
EntitySqlQueryBuilderUpdate updateBuilder = new EntitySqlQueryBuilderUpdate();
foreach (IEntityChange change in modified)
{
updateBuilder.ParameterIndex = index++;
updateBuilder.UpdatedFields = change.UpdatedFields;
batchQuery.Combine(updateBuilder.CreateQuery(change.Entity, metaData));
batchQuery.Text.AppendLine();
}
batchQuery.Text.AppendLine();
}
if (!deleted.IsEmptyList())
{
foreach (IEntityChange change in deleted)
{
SqlQuery deleteQuery = new SqlQuery();
deleteQuery.Text.Append("DELETE FROM ");
deleteQuery.Text.Append(metaData.TableName);
SqlQueryHelper.IndexParameterNames(metaData, index++);
deleteQuery.Combine(SqlQueryHelper.CreateWhereSqlByKeys(metaData, '@', change.Entity));
batchQuery.Combine(deleteQuery);
batchQuery.Text.AppendLine();
}
batchQuery.Text.AppendLine();
}
if (!added.IsEmptyList())
{
EntitySqlQueryBuilderInsert insertBuilder = new EntitySqlQueryBuilderInsert();
foreach (IEntityChange change in added)
{
insertBuilder.ParameterIndex = index++;
batchQuery.Combine(insertBuilder.CreateQuery(change.Entity, metaData, out identity));
if (null != identity)
outs.Add(identity.ParameterName, change.Entity);
batchQuery.Text.AppendLine();
}
}
batchQuery.Text.Append(GlobalInternal.SqlServerEndStatement);
int ret = base.DataAccess.ExecuteNonQuery(batchQuery);
if (null != identity)//outParameterNames.Count must be equal to entityList.Count.
{
foreach (KeyValuePair<string, object> kvp in outs)
{
string outParameterName = kvp.Key;
object identityValue = batchQuery.Parameters.Find(outParameterName).Value;
identity.Property.SetValue(kvp.Value, identityValue, null);
}
}
return ret;
case BatchCommandMode.Single:
int sum = 0;
if (!modified.IsEmptyList())
{
EntityCommandUpdate updateCommand = new EntityCommandUpdate(base.DataAccess);
foreach (IEntityChange change in modified)
{
updateCommand.UpdatedFields = change.UpdatedFields;
sum += updateCommand.UpdateInternal(change.Entity, metaData);
}
}
if (!deleted.IsEmptyList())
{
EntityCommandDelete deleteCommand = new EntityCommandDelete(base.DataAccess);
foreach (IEntityChange change in deleted)
{
sum += deleteCommand.DeleteInternal(change.Entity, metaData);
}
}
if (!added.IsEmptyList())
{
EntityCommandInsert insertCommand = new EntityCommandInsert(base.DataAccess);
foreach (IEntityChange change in added)
{
sum += insertCommand.InsertInternal(change.Entity, metaData);
}
}
return sum;
default:
throw new NotSupportedException(mode.ToString());
}
}
protected void BuildCacheChangeItems(CacheDependencyNode node, List <IObjRef> deletesToSearchInCache, List <IObjRef> changesToSearchInCache,
List <IObjRef> changesWithVersion)
{
List <ChildCache> directChildCaches = node.directChildCaches;
for (int flcIndex = directChildCaches.Count; flcIndex-- > 0;)
{
ChildCache childCache = directChildCaches[flcIndex];
List <IObjRef> objectRefsToDelete = new List <IObjRef>();
List <IObjRef> objectRefsToUpdate = new List <IObjRef>();
List <Object> objectsToUpdate = new List <Object>();
Lock readLock = childCache.ReadLock;
readLock.Lock();
try
{
IList <Object> deletesInCache = childCache.GetObjects(deletesToSearchInCache, CacheDirective.FailEarly | CacheDirective.ReturnMisses);
for (int a = deletesToSearchInCache.Count; a-- > 0;)
{
Object result = deletesInCache[a];
if (result == null)
{
// not in this cache
continue;
}
objectRefsToDelete.Add(deletesToSearchInCache[a]);
}
IList <Object> changesInCache = childCache.GetObjects(changesToSearchInCache, CacheDirective.FailEarly | CacheDirective.ReturnMisses);
for (int a = changesToSearchInCache.Count; a-- > 0;)
{
Object result = changesInCache[a];
if (result == null)
{
// not in this cache
continue;
}
// Attach version to ORI. We can not do this before because then we would have had a
// cache miss in the childCache above. We need the version now because our second level cache
// has to refresh its entries
IObjRef objRefWithVersion = changesWithVersion[a];
node.hardRefObjRefsToLoad.Add(objRefWithVersion);
if (result is IDataObject)
{
IDataObject dataObject = (IDataObject)result;
if (dataObject.ToBeUpdated || dataObject.ToBeDeleted)
{
continue;
}
}
if (objRefWithVersion.Version != null)
{
IEntityMetaData metaData = ((IEntityMetaDataHolder)result).Get__EntityMetaData();
Object versionInCache = metaData.VersionMember != null?metaData.VersionMember.GetValue(result, false) : null;
if (versionInCache != null && ((IComparable)objRefWithVersion.Version).CompareTo(versionInCache) <= 0)
{
continue;
}
}
objectsToUpdate.Add(result);
node.objRefsToLoad.Add(objRefWithVersion);
// scanForInitializedObjects(result, alreadyScannedObjects, hardRefOrisToLoad);
objectRefsToUpdate.Add(objRefWithVersion);
}
}
finally
{
readLock.Unlock();
}
if (objectRefsToDelete.Count == 0 && objectsToUpdate.Count == 0)
{
continue;
}
CacheChangeItem cci = new CacheChangeItem();
cci.Cache = childCache;
cci.DeletedObjRefs = objectRefsToDelete;
cci.UpdatedObjRefs = objectRefsToUpdate;
cci.UpdatedObjects = objectsToUpdate;
node.PushPendingChangeOnAnyChildCache(flcIndex, cci);
}
List <CacheDependencyNode> childNodes = node.childNodes;
for (int a = childNodes.Count; a-- > 0;)
{
BuildCacheChangeItems(childNodes[a], deletesToSearchInCache, changesToSearchInCache, changesWithVersion);
}
}
public virtual SqlQuery CreateQuery(object entity, IEntityMetaData metaData, out PropertyMetaData identity)
{
EntitySqlQueryBuilderUpdate builderUpdate = new EntitySqlQueryBuilderUpdate();
builderUpdate.ParameterIndex = this.ParameterIndex;
builderUpdate.UpdatedFields = this.UpdatedFields;
SqlQuery query = builderUpdate.CreateQuery(entity, metaData);
StringBuilder text = query.Text;
text.AppendLine();
text.Append("IF @@ROWCOUNT = 0");
text.AppendLine();
text.Append("BEGIN");
text.AppendLine();
EntitySqlQueryBuilderInsert builderInsert = new EntitySqlQueryBuilderInsert();
builderInsert.ParameterIndex = this.ParameterIndex;
builderInsert.InsertFields = this.InsertFields;
query.Combine(builderInsert.CreateQuery(entity, metaData, out identity));
text.AppendLine();
text.Append("END");
return query;
}
protected void ChangeFirstLevelCachesIntern(CacheDependencyNode node, ISet <IObjRef> intermediateDeletes)
{
List <CacheDependencyNode> childNodes = node.childNodes;
for (int a = childNodes.Count; a-- > 0;)
{
ChangeFirstLevelCachesIntern(childNodes[a], intermediateDeletes);
}
CacheChangeItem[] cacheChangeItems = node.cacheChangeItems;
if (cacheChangeItems == null)
{
return;
}
IRootCache parentCache = node.rootCache;
// RootCache readlock must be acquired before individual writelock to the child caches due to deadlock reasons
Lock parentCacheReadLock = parentCache.ReadLock;
parentCacheReadLock.Lock();
try
{
HashMap <IObjRef, CacheValueAndPrivilege> objRefToCacheValueMap = node.objRefToCacheValueMap;
for (int a = cacheChangeItems.Length; a-- > 0;)
{
CacheChangeItem cci = cacheChangeItems[a];
if (cci == null)
{
continue;
}
ChildCache childCache = node.directChildCaches[a];
IList <IObjRef> deletedObjRefs = cci.DeletedObjRefs;
IList <Object> objectsToUpdate = cci.UpdatedObjects;
IList <IObjRef> objRefsToUpdate = cci.UpdatedObjRefs;
IRootCache parent = ((IRootCache)childCache.Parent).CurrentRootCache;
Lock writeLock = childCache.WriteLock;
writeLock.Lock();
try
{
if (deletedObjRefs != null && deletedObjRefs.Count > 0)
{
childCache.Remove(deletedObjRefs);
}
foreach (IObjRef intermediateDeleteObjRef in intermediateDeletes)
{
childCache.Remove(intermediateDeleteObjRef);
}
if (objectsToUpdate != null && objectsToUpdate.Count > 0)
{
List <IObjRef> objRefsToForget = null;
for (int b = objectsToUpdate.Count; b-- > 0;)
{
Object objectInCache = objectsToUpdate[b];
IObjRef objRefInCache = objRefsToUpdate[b];
// Check if the objects still have their id. They may have lost them concurrently because this
// method here may be called from another thread (e.g. UI thread)
IEntityMetaData metaData = ((IEntityMetaDataHolder)objectInCache).Get__EntityMetaData();
Object id = metaData.IdMember.GetValue(objectInCache, false);
if (id == null)
{
continue;
}
CacheValueAndPrivilege cacheValueP = objRefToCacheValueMap.Get(objRefInCache);
if (cacheValueP == null)
{
if (objRefsToForget == null)
{
objRefsToForget = new List <IObjRef>();
}
objRefsToForget.Add(objRefInCache);
foreach (PrimitiveMember member in metaData.PrimitiveMembers)
{
member.SetValue(objectInCache, null);
}
RelationMember[] relationMembers = metaData.RelationMembers;
for (int relationIndex = relationMembers.Length; relationIndex-- > 0;)
{
((IValueHolderContainer)objectInCache).Set__Uninitialized(relationIndex, null);
}
continue;
}
if (!parentCache.ApplyValues(objectInCache, childCache, cacheValueP.privilege))
{
if (Log.WarnEnabled)
{
Log.Warn("No entry for object '" + objectInCache + "' found in second level cache");
}
}
}
if (objRefsToForget != null)
{
childCache.Remove(objRefsToForget);
}
}
}
finally
{
writeLock.Unlock();
}
}
}
finally
{
parentCacheReadLock.Unlock();
}
}
public virtual SqlQuery CreateQuery(object entity, IEntityMetaData metaData, out PropertyMetaData identity)
{
if (null == entity)
throw new ArgumentNullException("entity");
identity = null;
SqlQueryHelper.IndexParameterNames(metaData, this.ParameterIndex);
bool insertFieldsEnabled = !this.InsertFields.IsEmptyList();
SqlQuery query = new SqlQuery();
StringBuilder text = query.Text;
text.Append("INSERT INTO ");
text.Append(metaData.TableName);
text.Append(" (");
List<PropertyMetaData> validInfos = new List<PropertyMetaData>();
foreach (PropertyMetaData property in metaData.Properties)
{
SchemaInfo schema = property.Schema;
switch (schema.DatabaseGeneratedOption)
{
case StoreGeneratedPattern.Identity:
if (null != identity)
throw new MultipleIdentityColumnFoundException(entity);
identity = property;
break;
case StoreGeneratedPattern.Computed:
break;
default:
if (insertFieldsEnabled && !this.InsertFields.Contains(schema.ColumnName))
continue;
text.Append(schema.ColumnName);
text.Append(',');
validInfos.Add(property);
break;
}
}
text.Remove(text.Length - 1, 1);
text.Append(") VALUES (");
foreach (PropertyMetaData property in validInfos)
{
SchemaInfo schema = property.Schema;
SqlQueryHelper.SetColumnValue(ValueSetter.Instance, query, property, entity);
text.Append(',');
}
text.Remove(text.Length - 1, 1);
text.Append(')');
if (null != identity)
{
text.AppendLine();
text.Append("SELECT @");
text.Append(identity.ParameterName);
text.Append("=SCOPE_IDENTITY()");
SqlQueryParameter identityParameter = SqlQueryHelper.EnsureHasParameter(query, identity, entity);
identityParameter.Direction = System.Data.ParameterDirection.InputOutput;
}
return query;
}
public ObjRefStoreVisitor(IClassVisitor cv, IEntityMetaData metaData, int idIndex)
: base(cv, metaData, idIndex)
{
}
