/// <summary>
/// Processes the specified message context.
/// </summary>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
internal static void Process(MessageContext messageContext, IndexStoreContext storeContext)
{
// TBD : Support concurrent DeleteAllInType for different types
lock (LockingUtil.Instance.LockerObjects)
{
RelayMessage msg;
if (DataTierUtil.ShouldForwardToDataTier(messageContext.RelayTTL,
messageContext.SourceZone,
storeContext.MyZone,
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId].IndexServerMode))
{
// Send DeleteAll to Data Store
short relatedTypeId;
if(!storeContext.TryGetRelatedIndexTypeId(messageContext.TypeId, out relatedTypeId))
{
LoggingUtil.Log.ErrorFormat("Invalid RelatedTypeId for TypeId - {0}", messageContext.TypeId);
throw new Exception("Invalid RelatedTypeId for TypeId - " + messageContext.TypeId);
}
msg = new RelayMessage(relatedTypeId, 0, MessageType.DeleteAllInType);
storeContext.ForwarderComponent.HandleMessage(msg);
}
// Send DeleteAll to local Index storage
msg = new RelayMessage(messageContext.TypeId, 0, MessageType.DeleteAllInType);
storeContext.IndexStorageComponent.HandleMessage(msg);
// Delete hash mapping entries in file
storeContext.RemoveType(messageContext.TypeId);
}
}
/// <summary>
/// Processes the specified message context.
/// </summary>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
/// <returns>Raw CacheIndexInternal</returns>
internal static byte[] Process(MessageContext messageContext, IndexStoreContext storeContext)
{
byte[] payloadByteArray = null;
RelayMessage getMsg = new RelayMessage
{
MessageType = MessageType.Get,
Id = IndexCacheUtils.GeneratePrimaryId(messageContext.ExtendedId),
ExtendedId = IndexServerUtils.FormExtendedId(messageContext.ExtendedId, 0) // Pull first of the multiple indexes
};
if (storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection.Contains(messageContext.TypeId))
{
getMsg.TypeId = messageContext.TypeId;
}
else if (storeContext.RelatedTypeIds.TryGetValue(messageContext.TypeId, out getMsg.TypeId))
{
}
else
{
LoggingUtil.Log.InfoFormat("Invalid TypeID for GetMessage {0}", messageContext.TypeId);
return payloadByteArray;
}
storeContext.IndexStorageComponent.HandleMessage(getMsg);
if (getMsg.Payload != null)
{
payloadByteArray = getMsg.Payload.ByteArray;
}
return payloadByteArray;
}
/// <summary>
/// Gets the data into resultItemList items.
/// </summary>
/// <param name="resultItemList">The result item list.</param>
/// <param name="storeContext">The store context.</param>
/// <param name="messageContext">The message context.</param>
/// <param name="fullDataIdFieldList">The full data id field list.</param>
/// <param name="fullDataIdInfo">The full data id info.</param>
internal static void GetData(List<ResultItem> resultItemList,
IndexStoreContext storeContext,
MessageContext messageContext,
FullDataIdFieldList fullDataIdFieldList,
FullDataIdInfo fullDataIdInfo)
{
byte[] extendedId;
List<RelayMessage> dataStoreMessages = new List<RelayMessage>();
short relatedTypeId;
if (fullDataIdInfo != null && fullDataIdInfo.RelatedTypeName != null)
{
if (!storeContext.TryGetTypeId(fullDataIdInfo.RelatedTypeName, out relatedTypeId))
{
LoggingUtil.Log.ErrorFormat("Invalid RelatedCacheTypeName - {0}", fullDataIdInfo.RelatedTypeName);
throw new Exception("Invalid RelatedTypeId for TypeId - " + fullDataIdInfo.RelatedTypeName);
}
}
else if (!storeContext.TryGetRelatedIndexTypeId(messageContext.TypeId, out relatedTypeId))
{
LoggingUtil.Log.ErrorFormat("Invalid RelatedTypeId for TypeId - {0}", messageContext.TypeId);
throw new Exception("Invalid RelatedTypeId for TypeId - " + messageContext.TypeId);
}
if (resultItemList != null && resultItemList.Count > 0)
{
foreach (ResultItem resultItem in resultItemList)
{
extendedId = GetFullDataId(resultItem.IndexId,
resultItem,
fullDataIdInfo != null && fullDataIdInfo.RelatedTypeName != null ? fullDataIdInfo.FullDataIdFieldList : fullDataIdFieldList);
dataStoreMessages.Add(new RelayMessage(relatedTypeId,
IndexCacheUtils.GeneratePrimaryId(extendedId),
extendedId,
MessageType.Get));
}
storeContext.ForwarderComponent.HandleMessages(dataStoreMessages);
int i = 0;
foreach (ResultItem resultItem in resultItemList)
{
if (dataStoreMessages[i].Payload != null)
{
resultItem.Data = dataStoreMessages[i].Payload.ByteArray;
}
else
{
LoggingUtil.Log.DebugFormat("Fetched Null Data for TypeId: {0}, IndexId: {1}, ItemId: {2}, FullDataId: {3}, PrimaryId: {4}",
relatedTypeId,
IndexCacheUtils.GetReadableByteArray(resultItem.IndexId),
IndexCacheUtils.GetReadableByteArray(resultItem.ItemId),
IndexCacheUtils.GetReadableByteArray(dataStoreMessages[i].ExtendedId),
IndexCacheUtils.GeneratePrimaryId(dataStoreMessages[i].ExtendedId)
);
}
i++;
}
}
}
public void GetDataItems(FullDataIdInfo info, bool excludeData, MessageContext messageContext, IndexStoreContext storeContext, BaseMultiIndexIdQueryResult queryResult)
{
if (excludeData == false)
{
IndexTypeMapping indexTypeMapping =
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId];
DataTierUtil.GetData(queryResult.ResultItemList, storeContext, messageContext, indexTypeMapping.FullDataIdFieldList, info);
}
}
/// <summary>
/// Processes the specified cache index update.
/// </summary>
/// <param name="cacheIndexUpdate">The cache index update.</param>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
internal static void Process(CacheIndexUpdate cacheIndexUpdate, MessageContext messageContext, IndexStoreContext storeContext)
{
switch (cacheIndexUpdate.Command.CommandType)
{
case CommandType.FilteredIndexDelete:
PerformanceCounters.Instance.IncrementCounter(
PerformanceCounterEnum.FilterDelete,
messageContext.TypeId,
1);
FilteredIndexDeleteProcessor.Process(cacheIndexUpdate.Command as FilteredIndexDeleteCommand, messageContext, storeContext);
break;
}
}
/// <summary>
/// Processes the specified remote clustered intersection query.
/// </summary>
/// <param name="remoteClusteredIntersectionQuery">The remote clustered intersection query.</param>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
/// <returns>IntersectionQueryResult</returns>
internal static IntersectionQueryResult Process(RemoteClusteredIntersectionQuery remoteClusteredIntersectionQuery, MessageContext messageContext, IndexStoreContext storeContext)
{
// increment performance counter
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.IndexLookupAvgPerRemoteClusteredIntersectionQuery,
messageContext.TypeId,
remoteClusteredIntersectionQuery.IndexIdList.Count);
VirtualClusteredIntersectionQuery query = new VirtualClusteredIntersectionQuery(
remoteClusteredIntersectionQuery.IndexIdList,
remoteClusteredIntersectionQuery.TargetIndexName,
storeContext.GetTypeName(messageContext.TypeId))
{
ExcludeData = remoteClusteredIntersectionQuery.ExcludeData,
GetIndexHeader = remoteClusteredIntersectionQuery.GetIndexHeader,
Filter = remoteClusteredIntersectionQuery.Filter,
intersectionQueryParamsMapping = remoteClusteredIntersectionQuery.IntersectionQueryParamsMapping,
PrimaryId = remoteClusteredIntersectionQuery.PrimaryId,
PrimaryIdList = remoteClusteredIntersectionQuery.PrimaryIdList
};
return RelayClient.Instance.SubmitQuery<VirtualClusteredIntersectionQuery, IntersectionQueryResult>(query);
}
internal SpanQueryResult Process(RemoteClusteredSpanQuery remoteClusteredSpanQuery, MessageContext messageContext, IndexStoreContext storeContext)
{
// increment the performance counter
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.IndexLookupAvgPerRemoteClusteredSpanQuery,
messageContext.TypeId,
remoteClusteredSpanQuery.IndexIdList.Count);
// creating a spanQuery with copy ctor
VirtualSpanQuery query = new VirtualSpanQuery(remoteClusteredSpanQuery)
{
CacheTypeName = storeContext.GetTypeName(messageContext.TypeId),
// we get only reference at this point
ExcludeData = true
};
SpanQueryResult queryResult = RelayClient.Instance.SubmitQuery<VirtualSpanQuery, SpanQueryResult>(query);
GetDataItems(remoteClusteredSpanQuery.FullDataIdInfo, remoteClusteredSpanQuery.ExcludeData, messageContext, storeContext, queryResult);
return queryResult;
}
/// <summary>
/// Updates the existing index item.
/// </summary>
/// <param name="clientIndex">Index from the client.</param>
/// <param name="cacheIndexInternal">The cache index internal.</param>
/// <param name="indexInfo">The index info.</param>
/// <param name="addItem">The add item.</param>
/// <param name="searchIndex">Index to search.</param>
/// <param name="storeContext">The store context.</param>
/// <param name="comparer">The comparer.</param>
private static void UpdateExistingIndexItem(CacheIndex clientIndex, CacheIndexInternal cacheIndexInternal, Index indexInfo, IndexDataItem addItem, int searchIndex, IndexStoreContext storeContext, InternalItemComparer comparer)
{
InternalItem internalItem = cacheIndexInternal.InternalItemList[searchIndex];
if (clientIndex.TargetIndexName != null) //Save to single index
{
if (addItem.Tags != null && addItem.Tags.Count > 0)
{
bool reposition = IsRepositioningOfIndexItemRequired(indexInfo, addItem, internalItem);
// Update all tags on the internal item
foreach (KeyValuePair<string, byte[]> kvp in addItem.Tags)
{
storeContext.TagHashCollection.AddTag(cacheIndexInternal.InDeserializationContext.TypeId, kvp.Key);
internalItem.UpdateTag(TagHashCollection.GetTagHashCode(kvp.Key), kvp.Value);
}
// Reposition index item if required
if (reposition)
{
RepositionIndexItem(cacheIndexInternal, indexInfo, addItem, searchIndex, internalItem, comparer);
}
}
}
else //Save to multiple indexes
{
if (addItem.Tags != null && addItem.Tags.Count > 0)
{
List<string> tagNameList;
byte[] tagValue;
clientIndex.IndexTagMapping.TryGetValue(cacheIndexInternal.InDeserializationContext.IndexName, out tagNameList);
bool reposition = IsRepositioningOfIndexItemRequired(indexInfo, addItem, internalItem);
// Update all tags on the internal item
foreach (string tagName in tagNameList)
{
//Add to tagHashCollection
storeContext.TagHashCollection.AddTag(cacheIndexInternal.InDeserializationContext.TypeId, tagName);
addItem.TryGetTagValue(tagName, out tagValue);
internalItem.UpdateTag(TagHashCollection.GetTagHashCode(tagName), tagValue);
}
// Reposition index item if required
if (reposition)
{
RepositionIndexItem(cacheIndexInternal, indexInfo, addItem, searchIndex, internalItem, comparer);
}
}
}
}
/// <summary>
/// Adds the new item.
/// </summary>
/// <param name="clientIndex">Index from the client.</param>
/// <param name="cacheIndexInternal">The cache index internal.</param>
/// <param name="indexInfo">The index info.</param>
/// <param name="addItem">The add item.</param>
/// <param name="storeContext">The store context.</param>
/// <param name="comparer">The comparer.</param>
private static void AddNewItem(CacheIndex clientIndex,
CacheIndexInternal cacheIndexInternal,
Index indexInfo, IndexDataItem addItem,
IndexStoreContext storeContext,
InternalItemComparer comparer)
{
int searchIndex;
List<KeyValuePair<int, byte[]>> kvpList;
searchIndex = cacheIndexInternal.GetInsertPosition(addItem, indexInfo.PrimarySortInfo.SortOrderList[0].SortBy, comparer);
//Add item to CacheIndexInternal
kvpList = null;
if (addItem.Tags != null && addItem.Tags.Count > 0)
{
kvpList = new List<KeyValuePair<int, byte[]>>();
if (clientIndex.TargetIndexName != null) //Save to single index
{
foreach (KeyValuePair<string, byte[]> kvp in addItem.Tags)
{
//Add to tagHashCollection
storeContext.TagHashCollection.AddTag(cacheIndexInternal.InDeserializationContext.TypeId, kvp.Key);
kvpList.Add(new KeyValuePair<int, byte[]>(TagHashCollection.GetTagHashCode(kvp.Key), kvp.Value));
}
}
else //Save to multiple indexes
{
List<string> tagNameList;
clientIndex.IndexTagMapping.TryGetValue(cacheIndexInternal.InDeserializationContext.IndexName, out tagNameList);
foreach (string tagName in tagNameList)
{
//Add to tagHashCollection
storeContext.TagHashCollection.AddTag(cacheIndexInternal.InDeserializationContext.TypeId, tagName);
kvpList.Add(new KeyValuePair<int, byte[]>(TagHashCollection.GetTagHashCode(tagName), addItem.Tags[tagName]));
}
}
}
cacheIndexInternal.InsertItem(new InternalItem { ItemId = addItem.ItemId, TagList = kvpList }, searchIndex, true);
}
private static void ProcessAddList(List<CacheIndexInternal> internalIndexList,
List<IndexItem> cappedDeleteItemList,
CacheIndex clientIndex,
IndexStoreContext storeContext,
IndexTypeMapping indexTypeMapping)
{
#region Add new items to each internalIndex
Index indexInfo;
InternalItemComparer comparer;
int searchIndex;
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.AddList,
indexTypeMapping.TypeId,
clientIndex.AddList.Count);
foreach (CacheIndexInternal cacheIndexInternal in internalIndexList)
{
indexInfo = indexTypeMapping.IndexCollection[cacheIndexInternal.InDeserializationContext.IndexName];
comparer = new InternalItemComparer(indexInfo.PrimarySortInfo.IsTag, indexInfo.PrimarySortInfo.FieldName, indexInfo.PrimarySortInfo.SortOrderList);
if (clientIndex.AddList.Count > 0)
{
foreach (IndexDataItem addItem in clientIndex.AddList)
{
searchIndex = cacheIndexInternal.Search(addItem);
if (searchIndex > -1)
{
UpdateExistingIndexItem(clientIndex, cacheIndexInternal, indexInfo, addItem, searchIndex, storeContext, comparer);
}
else
{
AddNewItem(clientIndex, cacheIndexInternal, indexInfo, addItem, storeContext, comparer);
#region IndexSize Capping
if (indexInfo.MaxIndexSize > 0 && cacheIndexInternal.Count > indexInfo.MaxIndexSize)
{
int deleteIndex = indexInfo.TrimFromTail ? cacheIndexInternal.Count - 1 : 0;
//Add item to a list to delete it from the Data Store
cappedDeleteItemList.Add(InternalItemAdapter.ConvertToIndexItem(cacheIndexInternal.GetItem(deleteIndex),
cacheIndexInternal.InDeserializationContext));
//Delete from Index Store
cacheIndexInternal.DeleteItem(deleteIndex, false);
}
#endregion
}
}
}
//Update metadata
if (clientIndex.UpdateMetadata && indexTypeMapping.IndexCollection[cacheIndexInternal.InDeserializationContext.IndexName].MetadataPresent)
{
cacheIndexInternal.Metadata = clientIndex.Metadata;
}
}
#endregion
}
/// <summary>
/// Processes the specified cache index.
/// </summary>
/// <param name="cacheIndex">Index of the cache.</param>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
internal static void Process(CacheIndex cacheIndex, MessageContext messageContext, IndexStoreContext storeContext)
{
lock (LockingUtil.Instance.GetLock(messageContext.PrimaryId))
{
try
{
IndexTypeMapping indexTypeMapping =
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId];
#region Extract CacheIndex and Validate from incoming message
ValidateSave(cacheIndex);
#endregion
#region Log CacheIndex before processing
StringBuilder dbgIndexInfo = null;
if (LoggingUtil.Log.IsDebugEnabled)
{
dbgIndexInfo = new StringBuilder();
dbgIndexInfo.Append("TypeId=").Append(messageContext.TypeId).Append(Environment.NewLine);
dbgIndexInfo.Append(IndexServerUtils.GetPrintableCacheIndex(cacheIndex,
storeContext.TagHashCollection,
messageContext.TypeId));
}
#endregion
#region Init vars
List<RelayMessage> indexStorageMessageList = new List<RelayMessage>();
List<RelayMessage> dataStorageMessageList = new List<RelayMessage>();
List<CacheIndexInternal> internalIndexList = new List<CacheIndexInternal>();
List<IndexItem> cappedDeleteItemList = new List<IndexItem>();
CacheIndexInternal internalIndex;
#endregion
if (cacheIndex.IndexVirtualCountMapping == null)
{
#region Save Items
#region Extract CacheIndexInternal from index storage
if (cacheIndex.TargetIndexName == null) //Save to multiple indexes
{
#region Get CacheIndexInternal for multiple indexes
foreach (KeyValuePair<string /*IndexName*/, List<string> /*TagNameList*/> kvp in cacheIndex.IndexTagMapping)
{
Index indexInfo = indexTypeMapping.IndexCollection[kvp.Key];
internalIndex = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
cacheIndex.PrimaryId,
cacheIndex.IndexId,
indexInfo.ExtendedIdSuffix,
kvp.Key,
0,
null,
true,
null,
false,
false,
indexInfo.PrimarySortInfo,
indexInfo.LocalIdentityTagList,
indexInfo.StringHashCodeDictionary,
null);
if (internalIndex != null)
{
// update performance counter
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumberOfItemsInIndexPerSave,
messageContext.TypeId,
internalIndex.OutDeserializationContext.TotalCount);
}
if (internalIndex == null || cacheIndex.ReplaceFullIndex) //CacheIndexInternal does not exists or is to be discarded
{
internalIndex = new CacheIndexInternal
{
InDeserializationContext = new InDeserializationContext
{
TypeId = messageContext.TypeId,
TagHashCollection = storeContext.TagHashCollection,
IndexId = cacheIndex.IndexId,
IndexName = kvp.Key,
InclusiveFilter = true,
PrimarySortInfo = indexInfo.PrimarySortInfo,
LocalIdentityTagNames = indexInfo.LocalIdentityTagList,
StringHashCollection = storeContext.StringHashCollection,
StringHashCodeDictionary = indexInfo.StringHashCodeDictionary
}
};
}
internalIndexList.Add(internalIndex);
}
#endregion
}
else //Save to single index
{
#region Get CacheIndexInternal for TargetIndexName
Index indexInfo = indexTypeMapping.IndexCollection[cacheIndex.TargetIndexName];
internalIndex = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
cacheIndex.PrimaryId,
cacheIndex.IndexId,
indexInfo.ExtendedIdSuffix,
cacheIndex.TargetIndexName,
0,
null,
true,
null,
false,
false,
indexInfo.PrimarySortInfo,
indexInfo.LocalIdentityTagList,
indexInfo.StringHashCodeDictionary,
null);
if (internalIndex != null)
{
// update performance counter
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumberOfItemsInIndexPerSave,
messageContext.TypeId,
internalIndex.OutDeserializationContext.TotalCount);
}
if (internalIndex == null || cacheIndex.ReplaceFullIndex) //CacheIndexInternal does not exists or is to be discarded
{
internalIndex = new CacheIndexInternal
{
InDeserializationContext = new InDeserializationContext
{
TypeId = messageContext.TypeId,
TagHashCollection = storeContext.TagHashCollection,
IndexId = cacheIndex.IndexId,
IndexName = cacheIndex.TargetIndexName,
InclusiveFilter = true,
PrimarySortInfo = indexInfo.PrimarySortInfo,
LocalIdentityTagNames = indexInfo.LocalIdentityTagList,
StringHashCollection = storeContext.StringHashCollection,
StringHashCodeDictionary = indexInfo.StringHashCodeDictionary
}
};
}
internalIndexList.Add(internalIndex);
#endregion
}
#endregion
#region Log CacheIndexInternals before save
if (LoggingUtil.Log.IsDebugEnabled && dbgIndexInfo != null)
{
dbgIndexInfo.Append(Environment.NewLine).Append(string.Format("BEFORE SAVE {0}",
IndexServerUtils.GetPrintableCacheIndexInternalList(
internalIndexList,
storeContext.TagHashCollection,
messageContext.TypeId)));
}
#endregion
#region Process Delete and Add List
try
{
#region Process Delete List
if (cacheIndex.DeleteList.Count > 0 && !cacheIndex.ReplaceFullIndex)
{
ProcessDeleteList(internalIndexList, cacheIndex.DeleteList, messageContext.TypeId);
}
#endregion
#region Process Add List
if (cacheIndex.AddList.Count > 0 || cacheIndex.UpdateMetadata)
{
ProcessAddList(internalIndexList, cappedDeleteItemList, cacheIndex, storeContext, indexTypeMapping);
}
#endregion
}
catch
{
LoggingUtil.Log.Debug(IndexServerUtils.GetPrintableCacheIndexInternalList(internalIndexList, storeContext.TagHashCollection, messageContext.TypeId));
throw;
}
#endregion
#region Log CacheIndexInternals after save
if (LoggingUtil.Log.IsDebugEnabled && dbgIndexInfo != null)
{
dbgIndexInfo.Append(Environment.NewLine).Append(string.Format("AFTER SAVE {0}",
IndexServerUtils.GetPrintableCacheIndexInternalList(internalIndexList,
storeContext.TagHashCollection,
messageContext.TypeId)));
}
#endregion
#region Data store relay messages for deletes and saves
if (DataTierUtil.ShouldForwardToDataTier(messageContext.RelayTTL,
messageContext.SourceZone,
storeContext.MyZone,
indexTypeMapping.IndexServerMode) && !cacheIndex.PreserveData)
{
byte[] fullDataId;
short relatedTypeId;
if (!storeContext.TryGetRelatedIndexTypeId(messageContext.TypeId, out relatedTypeId))
{
LoggingUtil.Log.ErrorFormat("Invalid RelatedTypeId for TypeId - {0}", messageContext.TypeId);
throw new Exception("Invalid RelatedTypeId for TypeId - " + messageContext.TypeId);
}
#region Delete Messages
foreach (IndexItem indexItem in cacheIndex.DeleteList)
{
fullDataId = DataTierUtil.GetFullDataId(cacheIndex.IndexId, indexItem, indexTypeMapping.FullDataIdFieldList);
if (fullDataId != null)
{
dataStorageMessageList.Add(new RelayMessage(relatedTypeId,
IndexCacheUtils.GeneratePrimaryId(fullDataId),
fullDataId,
MessageType.Delete));
}
}
#endregion
#region Save Messages
foreach (IndexDataItem indexDataItem in cacheIndex.AddList)
{
fullDataId = DataTierUtil.GetFullDataId(cacheIndex.IndexId, indexDataItem, indexTypeMapping.FullDataIdFieldList);
if (fullDataId != null)
{
dataStorageMessageList.Add(new RelayMessage(relatedTypeId,
IndexCacheUtils.GeneratePrimaryId(fullDataId),
fullDataId,
DateTime.Now,
indexDataItem.Data ?? new byte[0],
storeContext.GetCompressOption(messageContext.TypeId),
MessageType.Save));
if (indexDataItem.Data == null || indexDataItem.Data.Length == 0)
{
LoggingUtil.Log.WarnFormat("Saving null data for TypeId: {0}, IndexId: {1}, ItemId: {2}, FullDataId: {3}, PrimaryId: {4}",
relatedTypeId,
IndexCacheUtils.GetReadableByteArray(cacheIndex.IndexId),
IndexCacheUtils.GetReadableByteArray(indexDataItem.ItemId),
IndexCacheUtils.GetReadableByteArray(fullDataId),
IndexCacheUtils.GeneratePrimaryId(fullDataId));
}
}
}
#endregion
#region Capped Item Delete Messages
foreach (IndexItem indexItem in cappedDeleteItemList)
{
fullDataId = DataTierUtil.GetFullDataId(cacheIndex.IndexId, indexItem, indexTypeMapping.FullDataIdFieldList);
if (fullDataId != null)
{
dataStorageMessageList.Add(new RelayMessage(relatedTypeId,
IndexCacheUtils.GeneratePrimaryId(fullDataId),
fullDataId,
MessageType.Delete));
}
}
#endregion
#region Send relay mesaages to data store
if (dataStorageMessageList.Count > 0)
{
storeContext.ForwarderComponent.HandleMessages(dataStorageMessageList);
}
#endregion
}
#endregion
#endregion
if (dbgIndexInfo != null)
{
LoggingUtil.Log.Debug(dbgIndexInfo.ToString());
}
}
else
{
#region Update Virtual Count
foreach (KeyValuePair<string /*IndexName*/, int /*VirtualCount*/> kvp in cacheIndex.IndexVirtualCountMapping)
{
Index indexInfo = indexTypeMapping.IndexCollection[kvp.Key];
internalIndex = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
cacheIndex.PrimaryId,
cacheIndex.IndexId,
indexInfo.ExtendedIdSuffix,
kvp.Key,
0,
null,
true,
null,
true,
false,
indexInfo.PrimarySortInfo,
indexInfo.LocalIdentityTagList,
indexInfo.StringHashCodeDictionary,
null);
if (internalIndex == null)
{
internalIndex = new CacheIndexInternal
{
InDeserializationContext = new InDeserializationContext
{
TypeId = messageContext.TypeId,
TagHashCollection = storeContext.TagHashCollection,
IndexId = cacheIndex.IndexId,
IndexName = kvp.Key,
InclusiveFilter = true,
DeserializeHeaderOnly = true,
PrimarySortInfo = indexInfo.PrimarySortInfo,
LocalIdentityTagNames = indexInfo.LocalIdentityTagList,
StringHashCollection = storeContext.StringHashCollection,
StringHashCodeDictionary = indexInfo.StringHashCodeDictionary
}
};
}
else
{
// update performance counter
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumberOfItemsInIndexPerSave,
messageContext.TypeId,
internalIndex.OutDeserializationContext.TotalCount);
}
internalIndex.VirtualCount = kvp.Value;
internalIndexList.Add(internalIndex);
}
#endregion
}
#region Index storage relay messages for each CacheIndexInternal
#region Metadata
if (indexTypeMapping.MetadataStoredSeperately && cacheIndex.UpdateMetadata)
{
indexStorageMessageList.Add(new RelayMessage(messageContext.TypeId,
cacheIndex.PrimaryId,
cacheIndex.IndexId,
DateTime.Now,
cacheIndex.Metadata ?? new byte[0],
storeContext.GetCompressOption(messageContext.TypeId),
MessageType.Save));
}
#endregion
#region Index(es)
byte[] payload;
CompactBinaryWriter writer;
RelayMessage indexStorageMessage;
byte[] extendedId;
foreach (CacheIndexInternal cacheIndexInternal in internalIndexList)
{
extendedId = IndexServerUtils.FormExtendedId(
cacheIndex.IndexId,
indexTypeMapping.IndexCollection[cacheIndexInternal.InDeserializationContext.IndexName].ExtendedIdSuffix);
// This mess is required until Moods 2.0 migrated to have IVersionSerializable version of CacheIndexInternal
// ** TBD - Should be removed later
if (LegacySerializationUtil.Instance.IsSupported(messageContext.TypeId))
{
writer = new CompactBinaryWriter(new BinaryWriter(new MemoryStream()));
cacheIndexInternal.Serialize(writer);
payload = new byte[writer.BaseStream.Length];
writer.BaseStream.Position = 0;
writer.BaseStream.Read(payload, 0, payload.Length);
indexStorageMessage = new RelayMessage(messageContext.TypeId,
cacheIndex.PrimaryId,
extendedId,
DateTime.Now,
payload,
storeContext.GetCompressOption(messageContext.TypeId),
MessageType.Save);
}
else
{
indexStorageMessage = RelayMessage.GetSaveMessageForObject(messageContext.TypeId,
cacheIndex.PrimaryId,
extendedId,
DateTime.Now,
cacheIndexInternal,
storeContext.GetCompressOption(messageContext.TypeId));
}
indexStorageMessageList.Add(indexStorageMessage);
}
#endregion
#region Send relay mesaages to index storage
storeContext.IndexStorageComponent.HandleMessages(indexStorageMessageList);
#endregion
#endregion
}
catch (Exception ex)
{
LoggingUtil.Log.DebugFormat("CacheIndex: {0}", IndexServerUtils.GetPrintableCacheIndex(cacheIndex, storeContext.TagHashCollection, messageContext.TypeId));
throw new Exception("TypeId " + messageContext.TypeId + " -- Error processing save message.", ex);
}
}
}
/// <summary>
/// Gets the CacheIndexInternal.
/// </summary>
/// <param name="storeContext">The store context.</param>
/// <param name="typeId">The type id.</param>
/// <param name="primaryId">The primary id.</param>
/// <param name="indexId">The index id.</param>
/// <param name="extendedIdSuffix">The extended id suffix.</param>
/// <param name="indexName">Name of the index.</param>
/// <param name="count">The count.</param>
/// <param name="filter">The filter.</param>
/// <param name="inclusiveFilter">if set to <c>true</c> includes the items that pass the filter; otherwise , <c>false</c>.</param>
/// <param name="indexCondition">The index condition.</param>
/// <param name="deserializeHeaderOnly">if set to <c>true</c> if just CacheIndexInternal header is to be deserialized; otherwise, <c>false</c>.</param>
/// <param name="getFilteredItems">if set to <c>true</c> get filtered items; otherwise, <c>false</c>.</param>
/// <param name="primarySortInfo">The primary sort info.</param>
/// <param name="localIdentityTagNames">The local identity tag names.</param>
/// <param name="stringHashCodeDictionary">The string hash code dictionary.</param>
/// <param name="capCondition">The cap condition.</param>
/// <returns>CacheIndexInternal</returns>
internal static CacheIndexInternal GetCacheIndexInternal(IndexStoreContext storeContext,
short typeId,
int primaryId,
byte[] indexId,
short extendedIdSuffix,
string indexName,
int count,
Filter filter,
bool inclusiveFilter,
IndexCondition indexCondition,
bool deserializeHeaderOnly,
bool getFilteredItems,
PrimarySortInfo primarySortInfo,
List<string> localIdentityTagNames,
Dictionary<int, bool> stringHashCodeDictionary,
CapCondition capCondition)
{
CacheIndexInternal cacheIndexInternal = null;
byte[] extendedId = FormExtendedId(indexId, extendedIdSuffix);
RelayMessage getMsg = new RelayMessage(typeId, primaryId, extendedId, MessageType.Get);
storeContext.IndexStorageComponent.HandleMessage(getMsg);
if (getMsg.Payload != null) //CacheIndex exists
{
cacheIndexInternal = new CacheIndexInternal
{
InDeserializationContext = new InDeserializationContext
{
TypeId = getMsg.TypeId,
TagHashCollection = storeContext.TagHashCollection,
IndexId = indexId,
IndexName = indexName,
MaxItemsPerIndex = count,
Filter = filter,
InclusiveFilter = inclusiveFilter,
IndexCondition = indexCondition,
DeserializeHeaderOnly = deserializeHeaderOnly,
CollectFilteredItems = getFilteredItems,
PrimarySortInfo = primarySortInfo,
LocalIdentityTagNames = localIdentityTagNames,
StringHashCollection = storeContext.StringHashCollection,
StringHashCodeDictionary = stringHashCodeDictionary,
CapCondition = capCondition
}
};
// This mess is required until Moods 2.0 migrated to have IVersionSerializable version of CacheIndexInternal
// ** TBD - Should be removed later
if (LegacySerializationUtil.Instance.IsSupported(getMsg.TypeId))
{
MemoryStream stream = new MemoryStream(getMsg.Payload.ByteArray);
cacheIndexInternal.Deserialize(new CompactBinaryReader(stream));
}
else
{
getMsg.GetObject(cacheIndexInternal);
}
}
return cacheIndexInternal;
}
/// <summary>
/// Processes the specified intersection query.
/// </summary>
/// <param name="intersectionQuery">The intersection query.</param>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
/// <returns>IntersectionQueryResult</returns>
internal static IntersectionQueryResult Process(IntersectionQuery intersectionQuery, MessageContext messageContext, IndexStoreContext storeContext)
{
//Fetch each index (assume all indexes are local) and perform intersection and return the results
IntersectionQueryResult intersectionQueryResult;
List<IndexDataItem> resultItemList = null;
Dictionary<byte[], IndexHeader> indexIdIndexHeaderMapping = new Dictionary<byte[], IndexHeader>(new ByteArrayEqualityComparer());
List<string> localIdentityTagNames = null;
bool isTagPrimarySort = false;
string sortFieldName = null;
List<SortOrder> sortOrderList = null;
StringBuilder exceptionInfo = new StringBuilder();
try
{
if (intersectionQuery.IndexIdList.Count > 0)
{
IndexTypeMapping indexTypeMapping =
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId];
ValidateQuery(indexTypeMapping, intersectionQuery);
#region Set sort vars
Index targetIndexInfo = indexTypeMapping.IndexCollection[intersectionQuery.TargetIndexName];
localIdentityTagNames = indexTypeMapping.IndexCollection[intersectionQuery.TargetIndexName].LocalIdentityTagList;
bool sortFieldPartOfLocalId = IsSortFieldPartOfLocalId(localIdentityTagNames, targetIndexInfo.PrimarySortInfo);
TagSort itemIdTagSort = new TagSort("ItemId", false, new SortOrder(DataType.Int32, SortBy.ASC));
if (!sortFieldPartOfLocalId)
{
//Set sort vars
isTagPrimarySort = itemIdTagSort.IsTag;
sortFieldName = itemIdTagSort.TagName;
sortOrderList = new List<SortOrder>(1) { itemIdTagSort.SortOrder };
}
else
{
isTagPrimarySort = targetIndexInfo.PrimarySortInfo.IsTag;
sortFieldName = targetIndexInfo.PrimarySortInfo.FieldName;
sortOrderList = targetIndexInfo.PrimarySortInfo.SortOrderList;
}
#endregion
#region Fetch CacheIndexInternal and Intersect
CacheIndexInternal targetIndex;
CacheIndexInternal resultCacheIndexInternal = null;
IntersectionQueryParams indexIdParam;
byte[] indexId;
for (int i = 0; i < intersectionQuery.IndexIdList.Count; i++)
{
#region Extract index and apply criteria
indexId = intersectionQuery.IndexIdList[i];
indexIdParam = intersectionQuery.GetIntersectionQueryParamForIndexId(indexId);
targetIndex = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
(intersectionQuery.PrimaryIdList != null && i < intersectionQuery.PrimaryIdList.Count) ?
intersectionQuery.PrimaryIdList[i] :
IndexCacheUtils.GeneratePrimaryId(indexId),
indexId,
targetIndexInfo.ExtendedIdSuffix,
intersectionQuery.TargetIndexName,
0,
indexIdParam.Filter,
true,
null,
false,
false,
targetIndexInfo.PrimarySortInfo,
targetIndexInfo.LocalIdentityTagList,
targetIndexInfo.StringHashCodeDictionary,
null);
#endregion
if (targetIndex != null)
{
if (targetIndex.Count < 0)
{
// No items in one of the indexes. Stop Interestion !!
resultCacheIndexInternal = null;
break;
}
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsInIndexPerIntersectionQuery,
messageContext.TypeId,
targetIndex.OutDeserializationContext.TotalCount);
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsReadPerIntersectionQuery,
messageContext.TypeId,
targetIndex.OutDeserializationContext.ReadItemCount);
if (!sortFieldPartOfLocalId)
{
//Need to sort indexes by item id
targetIndex.Sort(itemIdTagSort);
}
#region Intersection
if (resultCacheIndexInternal == null)
{
// No need to perform intersection for first index
resultCacheIndexInternal = targetIndex;
}
else
{
IntersectionAlgo.Intersect(isTagPrimarySort,
sortFieldName,
localIdentityTagNames,
sortOrderList,
resultCacheIndexInternal.InternalItemList,
targetIndex.InternalItemList);
if (resultCacheIndexInternal == null || resultCacheIndexInternal.Count < 1)
{
// Unable to fetch one of the indexes. Stop Interestion !!
resultCacheIndexInternal = null;
indexIdIndexHeaderMapping = null;
break;
}
}
#endregion
}
else
{
// Unable to fetch one of the indexes. Stop Interestion !!
resultCacheIndexInternal = null;
indexIdIndexHeaderMapping = null;
break;
}
#region Get MetaData
if (intersectionQuery.GetIndexHeader)
{
if (!indexIdIndexHeaderMapping.ContainsKey(indexId))
{
indexIdIndexHeaderMapping.Add(indexId,
GetIndexHeader(targetIndex, indexTypeMapping, messageContext.TypeId, IndexCacheUtils.GeneratePrimaryId(indexId), storeContext));
}
}
#endregion
}
if (resultCacheIndexInternal != null && resultCacheIndexInternal.Count > 0)
{
resultItemList = CacheIndexInternalAdapter.GetIndexDataItemList(resultCacheIndexInternal, 1, int.MaxValue);
}
#endregion
#region Get data
if (!intersectionQuery.ExcludeData && resultItemList != null && resultItemList.Count > 0)
{
DataTierUtil.GetData(resultItemList,
storeContext,
messageContext,
indexTypeMapping.FullDataIdFieldList,
intersectionQuery.FullDataIdInfo);
}
#endregion
}
intersectionQueryResult = new IntersectionQueryResult(resultItemList,
indexIdIndexHeaderMapping,
localIdentityTagNames,
isTagPrimarySort,
sortFieldName,
sortOrderList,
exceptionInfo.ToString());
// update performance counter
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.IndexLookupAvgPerIntersectionQuery,
messageContext.TypeId,
intersectionQuery.IndexIdList.Count);
}
catch (Exception ex)
{
exceptionInfo.Append(" | " + ex.Message);
intersectionQueryResult = new IntersectionQueryResult(null, null, null, false, null, null, exceptionInfo.ToString());
LoggingUtil.Log.ErrorFormat("TypeId {0} -- Error processing IntersectionQuery : {1}", messageContext.TypeId, ex);
}
return intersectionQueryResult;
}
/// <summary>
/// Processes the specified message context.
/// </summary>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
internal static void Process(MessageContext messageContext, IndexStoreContext storeContext)
{
lock (LockingUtil.Instance.GetLock(messageContext.PrimaryId))
{
IndexTypeMapping indexTypeMapping =
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId];
List<RelayMessage> dataStorageMessageList = new List<RelayMessage>();
List<RelayMessage> indexStorageMessageList = new List<RelayMessage>(indexTypeMapping.IndexCollection.Count);
CacheIndexInternal internalIndex;
List<byte[]> fullDataIdList;
if (indexTypeMapping.MetadataStoredSeperately)
{
indexStorageMessageList.Add(new RelayMessage(messageContext.TypeId,
messageContext.PrimaryId,
messageContext.ExtendedId,
MessageType.Delete));
}
foreach (Index index in indexTypeMapping.IndexCollection)
{
internalIndex = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
messageContext.PrimaryId,
messageContext.ExtendedId,
index.ExtendedIdSuffix,
index.IndexName,
0,
null,
true,
null,
false,
false,
index.PrimarySortInfo,
index.LocalIdentityTagList,
index.StringHashCodeDictionary,
null);
if (internalIndex != null)
{
#region Deletes messages for data store
if (DataTierUtil.ShouldForwardToDataTier(messageContext.RelayTTL,
messageContext.SourceZone,
storeContext.MyZone,
indexTypeMapping.IndexServerMode))
{
fullDataIdList = DataTierUtil.GetFullDataIds(messageContext.ExtendedId,
internalIndex.InternalItemList,
indexTypeMapping.FullDataIdFieldList);
short relatedTypeId;
foreach (byte[] fullDataId in fullDataIdList)
{
if (fullDataId != null)
{
if (storeContext.TryGetRelatedIndexTypeId(messageContext.TypeId, out relatedTypeId))
{
dataStorageMessageList.Add(new RelayMessage(relatedTypeId,
IndexCacheUtils.GeneratePrimaryId(fullDataId),
fullDataId,
MessageType.Delete));
}
else
{
LoggingUtil.Log.ErrorFormat("Invalid RelatedTypeId for TypeId - {0}", messageContext.TypeId);
throw new Exception("Invalid RelatedTypeId for TypeId - " + messageContext.TypeId);
}
}
}
}
#endregion
#region Delete messages for index store
indexStorageMessageList.Add(new RelayMessage(messageContext.TypeId,
messageContext.PrimaryId,
IndexServerUtils.FormExtendedId(messageContext.ExtendedId, index.ExtendedIdSuffix),
MessageType.Delete));
#endregion
}
}
if (dataStorageMessageList.Count > 0)
{
storeContext.ForwarderComponent.HandleMessages(dataStorageMessageList);
}
if (indexStorageMessageList.Count > 0)
{
storeContext.IndexStorageComponent.HandleMessages(indexStorageMessageList);
}
}
}
/// <summary>
/// Processes the specified filtered index delete command.
/// </summary>
/// <param name="filteredIndexDeleteCommand">The filtered index delete command.</param>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
internal static void Process(
FilteredIndexDeleteCommand filteredIndexDeleteCommand,
MessageContext messageContext,
IndexStoreContext storeContext)
{
if (filteredIndexDeleteCommand != null)
{
IndexTypeMapping indexTypeMapping =
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId];
Index indexInfo = indexTypeMapping.IndexCollection[filteredIndexDeleteCommand.TargetIndexName];
#region Get CacheIndexInternal for TargetIndexName
CacheIndexInternal cacheIndexInternal = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
filteredIndexDeleteCommand.PrimaryId,
filteredIndexDeleteCommand.IndexId,
indexInfo.ExtendedIdSuffix,
filteredIndexDeleteCommand.TargetIndexName,
0,
filteredIndexDeleteCommand.DeleteFilter,
false,
null,
false,
true,
indexInfo.PrimarySortInfo,
indexInfo.LocalIdentityTagList,
indexInfo.StringHashCodeDictionary,
null);
#endregion
if (cacheIndexInternal != null)
{
#region Increment perf counters' number
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsInIndexPerFilterDeleteRequest,
messageContext.TypeId,
cacheIndexInternal.OutDeserializationContext.TotalCount);
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsReadPerFilterDeleteRequest,
messageContext.TypeId,
cacheIndexInternal.OutDeserializationContext.ReadItemCount);
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsFilteredPerFilterDeleteRequest,
messageContext.TypeId,
(cacheIndexInternal.OutDeserializationContext.TotalCount - cacheIndexInternal.OutDeserializationContext.FilteredInternalItemList.Count));
#endregion
#region Update VirtualCount
cacheIndexInternal.VirtualCount -= (cacheIndexInternal.OutDeserializationContext.TotalCount - cacheIndexInternal.Count);
#endregion
#region Save CacheIndexInternal to local storage since item which pass delete filter are pruned in it
byte[] extendedId = IndexServerUtils.FormExtendedId(filteredIndexDeleteCommand.IndexId,
indexTypeMapping.IndexCollection[cacheIndexInternal.InDeserializationContext.IndexName].ExtendedIdSuffix);
RelayMessage indexStorageMessage = RelayMessage.GetSaveMessageForObject(messageContext.TypeId,
filteredIndexDeleteCommand.PrimaryId,
extendedId,
DateTime.Now,
cacheIndexInternal,
storeContext.GetCompressOption(messageContext.TypeId));
storeContext.IndexStorageComponent.HandleMessage(indexStorageMessage);
#endregion
#region Data store deletes
if (DataTierUtil.ShouldForwardToDataTier(messageContext.RelayTTL,
messageContext.SourceZone,
storeContext.MyZone,
indexTypeMapping.IndexServerMode) &&
cacheIndexInternal.OutDeserializationContext.FilteredInternalItemList != null &&
cacheIndexInternal.OutDeserializationContext.FilteredInternalItemList.Count > 0)
{
List<RelayMessage> dataStorageMessageList = new List<RelayMessage>();
short relatedTypeId;
if (!storeContext.TryGetRelatedIndexTypeId(messageContext.TypeId, out relatedTypeId))
{
LoggingUtil.Log.ErrorFormat("Invalid RelatedTypeId for TypeId - {0}", messageContext.TypeId);
throw new Exception("Invalid RelatedTypeId for TypeId - " + messageContext.TypeId);
}
cacheIndexInternal.InternalItemList = cacheIndexInternal.OutDeserializationContext.FilteredInternalItemList;
List<byte[]> fullDataIdList = DataTierUtil.GetFullDataIds(cacheIndexInternal.InDeserializationContext.IndexId,
cacheIndexInternal.InternalItemList,
indexTypeMapping.FullDataIdFieldList);
foreach (byte[] fullDataId in fullDataIdList)
{
if (fullDataId != null)
{
dataStorageMessageList.Add(new RelayMessage(relatedTypeId,
IndexCacheUtils.GeneratePrimaryId(fullDataId),
fullDataId,
MessageType.Delete));
}
}
if (dataStorageMessageList.Count > 0)
{
storeContext.ForwarderComponent.HandleMessages(dataStorageMessageList);
}
}
#endregion
}
}
}
/// <summary>
/// Processes the specified contains index query.
/// </summary>
/// <param name="containsIndexQuery">The contains index query.</param>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
/// <returns>ContainsIndexQueryResult</returns>
internal static ContainsIndexQueryResult Process(ContainsIndexQuery containsIndexQuery, MessageContext messageContext, IndexStoreContext storeContext)
{
ContainsIndexQueryResult containsIndexQueryResult;
MultiItemResult multiItemResult = null;
byte[] metadata = null;
bool indexExists = false;
int indexSize = -1;
int virtualCount = -1;
try
{
IndexTypeMapping indexTypeMapping =
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId];
#region Check TargetIndexName
if (!indexTypeMapping.IndexCollection.Contains(containsIndexQuery.TargetIndexName))
{
throw new Exception("Invalid TargetIndexName - " + containsIndexQuery.TargetIndexName);
}
#endregion
Index targetIndexInfo = indexTypeMapping.IndexCollection[containsIndexQuery.TargetIndexName];
List<CacheIndexInternal> internalCacheIndexList = new List<CacheIndexInternal>();
#region Get TargetIndex
CacheIndexInternal cacheIndexInternal = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
messageContext.PrimaryId,
containsIndexQuery.IndexId,
targetIndexInfo.ExtendedIdSuffix,
containsIndexQuery.TargetIndexName,
0,
null,
true,
null,
false,
false,
targetIndexInfo.PrimarySortInfo,
targetIndexInfo.LocalIdentityTagList,
targetIndexInfo.StringHashCodeDictionary,
null);
#endregion
if (cacheIndexInternal != null)
{
internalCacheIndexList.Add(cacheIndexInternal);
indexExists = true;
indexSize = cacheIndexInternal.OutDeserializationContext.TotalCount;
virtualCount = cacheIndexInternal.VirtualCount;
// update the performance counter
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsInIndexPerContainsIndexQuery,
messageContext.TypeId,
indexSize);
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsReadPerContainsIndexQuery,
messageContext.TypeId,
cacheIndexInternal.OutDeserializationContext.ReadItemCount);
int searchIndex;
IndexDataItem indexDataItem;
foreach (IndexItem queryIndexItem in containsIndexQuery.IndexItemList)
{
#region Search item in index
searchIndex = internalCacheIndexList[0].Search(queryIndexItem);
#endregion
if (searchIndex > -1)
{
if (multiItemResult == null)
{
multiItemResult = new MultiItemResult(containsIndexQuery.IndexId);
}
indexDataItem = new IndexDataItem(InternalItemAdapter.ConvertToIndexItem(internalCacheIndexList[0].GetItem(searchIndex),
internalCacheIndexList[0].InDeserializationContext));
#region Get extra tags
if (containsIndexQuery.TagsFromIndexes != null && containsIndexQuery.TagsFromIndexes.Count != 0)
{
foreach (string indexName in containsIndexQuery.TagsFromIndexes)
{
Index indexInfo = indexTypeMapping.IndexCollection[indexName];
CacheIndexInternal indexInternal =
IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
messageContext.PrimaryId,
containsIndexQuery.IndexId,
indexInfo.ExtendedIdSuffix,
indexName,
0,
null,
true,
null,
false,
false,
indexInfo.PrimarySortInfo,
indexInfo.LocalIdentityTagList,
indexInfo.StringHashCodeDictionary,
null);
if (indexInternal != null)
{
// update the performance counter
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsInIndexPerContainsIndexQuery,
messageContext.TypeId,
indexInternal.OutDeserializationContext.TotalCount);
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsReadPerContainsIndexQuery,
messageContext.TypeId,
indexInternal.OutDeserializationContext.ReadItemCount);
internalCacheIndexList.Add(indexInternal);
IndexServerUtils.GetTags(indexInternal, queryIndexItem, indexDataItem);
}
}
}
#endregion
multiItemResult.Add(indexDataItem);
}
}
#region Get data
if (!containsIndexQuery.ExcludeData && multiItemResult != null)
{
byte[] extendedId;
List<RelayMessage> dataStoreMessages = new List<RelayMessage>(multiItemResult.Count);
short relatedTypeId;
if (containsIndexQuery.FullDataIdInfo != null && containsIndexQuery.FullDataIdInfo.RelatedTypeName != null)
{
if (!storeContext.TryGetTypeId(containsIndexQuery.FullDataIdInfo.RelatedTypeName, out relatedTypeId))
{
LoggingUtil.Log.ErrorFormat("Invalid RelatedCacheTypeName - {0}", containsIndexQuery.FullDataIdInfo.RelatedTypeName);
throw new Exception("Invalid RelatedTypeId for TypeId - " + containsIndexQuery.FullDataIdInfo.RelatedTypeName);
}
}
else if (!storeContext.TryGetRelatedIndexTypeId(messageContext.TypeId, out relatedTypeId))
{
LoggingUtil.Log.ErrorFormat("Invalid RelatedTypeId for TypeId - {0}", messageContext.TypeId);
throw new Exception("Invalid RelatedTypeId for TypeId - " + messageContext.TypeId);
}
foreach (IndexDataItem resultItem in multiItemResult)
{
extendedId = DataTierUtil.GetFullDataId(containsIndexQuery.IndexId,
resultItem,
containsIndexQuery.FullDataIdInfo != null && containsIndexQuery.FullDataIdInfo.RelatedTypeName != null ?
containsIndexQuery.FullDataIdInfo.FullDataIdFieldList :
indexTypeMapping.FullDataIdFieldList);
dataStoreMessages.Add(new RelayMessage(relatedTypeId, IndexCacheUtils.GeneratePrimaryId(extendedId), extendedId, MessageType.Get));
}
storeContext.ForwarderComponent.HandleMessages(dataStoreMessages);
int i = 0;
foreach (IndexDataItem resultItem in multiItemResult)
{
if (dataStoreMessages[i].Payload != null)
{
resultItem.Data = dataStoreMessages[i].Payload.ByteArray;
}
i++;
}
}
#endregion
#region Get metadata
if (containsIndexQuery.GetMetadata)
{
metadata = IndexServerUtils.GetQueryMetadata(internalCacheIndexList,
indexTypeMapping,
messageContext.TypeId,
messageContext.PrimaryId,
containsIndexQuery.IndexId,
storeContext);
}
#endregion
}
containsIndexQueryResult = new ContainsIndexQueryResult(multiItemResult, metadata, indexSize, indexExists, virtualCount, null);
}
catch (Exception ex)
{
containsIndexQueryResult = new ContainsIndexQueryResult(null, null, -1, false, -1, ex.Message);
LoggingUtil.Log.ErrorFormat("TypeId {0} -- Error processing ContainsIndexQuery : {1}", messageContext.TypeId, ex);
}
return containsIndexQueryResult;
}
/// <summary>
/// Gets the index header.
/// </summary>
/// <param name="targetIndex">Index of the target.</param>
/// <param name="indexTypeMapping">The index type mapping.</param>
/// <param name="typeId">The type id.</param>
/// <param name="primaryId">The primary id.</param>
/// <param name="storeContext">The store context.</param>
/// <returns>IndexHeader</returns>
private static IndexHeader GetIndexHeader(CacheIndexInternal targetIndex,
IndexTypeMapping indexTypeMapping,
short typeId,
int primaryId,
IndexStoreContext storeContext)
{
IndexHeader indexHeader = new IndexHeader();
#region Metadata
if (indexTypeMapping.MetadataStoredSeperately)
{
#region Check if metadata is stored seperately
//Send a get message to local index storage and fetch seperately stored metadata
RelayMessage getMsg = new RelayMessage(typeId, primaryId, targetIndex.InDeserializationContext.IndexId, MessageType.Get);
storeContext.IndexStorageComponent.HandleMessage(getMsg);
if (getMsg.Payload != null)
{
indexHeader.Metadata = getMsg.Payload.ByteArray;
}
#endregion
}
else
{
#region Check metadata on targetIndex
if (indexTypeMapping.IndexCollection[targetIndex.InDeserializationContext.IndexName].MetadataPresent)
{
indexHeader.Metadata = targetIndex.Metadata;
}
#endregion
}
#endregion
#region VirtualCount
indexHeader.VirtualCount = targetIndex.VirtualCount;
#endregion
return indexHeader;
}
/// <summary>
/// Processes the specified random query.
/// </summary>
/// <param name="randomQuery">The random query.</param>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
/// <returns>RandomQueryResult</returns>
internal static RandomQueryResult Process(RandomQuery randomQuery, MessageContext messageContext, IndexStoreContext storeContext)
{
RandomQueryResult randomQueryResult;
List<ResultItem> resultItemList = null;
bool indexExists = false;
int indexSize = -1;
int virtualCount = -1;
byte[] metadata = null;
try
{
IndexTypeMapping indexTypeMapping =
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId];
#region Validate Query
ValidateQuery(indexTypeMapping, randomQuery);
#endregion
Index targetIndexInfo = indexTypeMapping.IndexCollection[randomQuery.TargetIndexName];
#region Prepare Result
#region Extract index and apply criteria
CacheIndexInternal targetIndex = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
messageContext.PrimaryId,
randomQuery.IndexId,
targetIndexInfo.ExtendedIdSuffix,
randomQuery.TargetIndexName,
0,
randomQuery.Filter,
true,
null,
false,
false,
targetIndexInfo.PrimarySortInfo,
targetIndexInfo.LocalIdentityTagList,
targetIndexInfo.StringHashCodeDictionary,
null);
#endregion
if (targetIndex != null)
{
indexSize = targetIndex.OutDeserializationContext.TotalCount;
virtualCount = targetIndex.VirtualCount;
indexExists = true;
// update performance counters
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsInIndexPerRandomQuery,
messageContext.TypeId,
indexSize);
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsReadPerRandomQuery,
messageContext.TypeId,
targetIndex.OutDeserializationContext.ReadItemCount);
#region Populate resultLists
int indexItemCount = targetIndex.Count;
int resultListCount = Math.Min(randomQuery.Count, indexItemCount);
IEnumerable<int> itemPositionList = Algorithm.RandomSubset(new Random(), 0, indexItemCount - 1, resultListCount);
resultItemList = CacheIndexInternalAdapter.GetResultItemList(targetIndex, itemPositionList);
#endregion
#region Get data
if (!randomQuery.ExcludeData)
{
DataTierUtil.GetData(resultItemList, storeContext, messageContext, indexTypeMapping.FullDataIdFieldList, randomQuery.FullDataIdInfo);
}
#endregion
#region Get metadata
if (randomQuery.GetMetadata)
{
metadata = IndexServerUtils.GetQueryMetadata(new List<CacheIndexInternal>(1) { targetIndex },
indexTypeMapping,
messageContext.TypeId,
messageContext.PrimaryId,
randomQuery.IndexId,
storeContext);
}
#endregion
#endregion
}
randomQueryResult = new RandomQueryResult(indexExists, indexSize, metadata, resultItemList, virtualCount, null);
}
catch (Exception ex)
{
randomQueryResult = new RandomQueryResult(false, -1, null, null, -1, ex.Message);
LoggingUtil.Log.ErrorFormat("TypeId {0} -- Error processing RandomQuery : {1}", messageContext.TypeId, ex);
}
return randomQueryResult;
}
/// <summary>
/// Processes the specified first last query.
/// </summary>
/// <param name="firstLastQuery">The first last query.</param>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
/// <returns>FirstLastQueryResult</returns>
internal static FirstLastQueryResult Process(FirstLastQuery firstLastQuery, MessageContext messageContext, IndexStoreContext storeContext)
{
FirstLastQueryResult firstLastQueryResult;
List<ResultItem> firstPageResultItemList = null;
List<ResultItem> lastPageResultItemList = null;
bool indexExists = false;
int indexSize = -1;
int virtualCount = -1;
byte[] metadata = null;
try
{
IndexTypeMapping indexTypeMapping =
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId];
#region Validate Query
ValidateQuery(indexTypeMapping, firstLastQuery);
#endregion
int maxItemsPerIndex = ((firstLastQuery.FirstPageSize > 0) && (firstLastQuery.LastPageSize < 1))
? firstLastQuery.FirstPageSize
: int.MaxValue;
Index targetIndexInfo = indexTypeMapping.IndexCollection[firstLastQuery.TargetIndexName];
#region Prepare Result
#region Extract index and apply criteria
CacheIndexInternal targetIndex = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
messageContext.PrimaryId,
firstLastQuery.IndexId,
targetIndexInfo.ExtendedIdSuffix,
firstLastQuery.TargetIndexName,
maxItemsPerIndex,
firstLastQuery.Filter,
true,
null,
false,
false,
targetIndexInfo.PrimarySortInfo,
targetIndexInfo.LocalIdentityTagList,
targetIndexInfo.StringHashCodeDictionary,
null);
#endregion
if (targetIndex != null)
{
indexSize = targetIndex.OutDeserializationContext.TotalCount;
virtualCount = targetIndex.VirtualCount;
indexExists = true;
// update perf counters
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsInIndexPerFirstLastQuery,
messageContext.TypeId,
indexSize);
PerformanceCounters.Instance.SetCounterValue(
PerformanceCounterEnum.NumOfItemsReadPerFirstLastQuery,
messageContext.TypeId,
targetIndex.OutDeserializationContext.ReadItemCount);
#region Populate resultLists
if (firstLastQuery.FirstPageSize + firstLastQuery.LastPageSize <= targetIndex.Count)
{
firstPageResultItemList = CacheIndexInternalAdapter.GetResultItemList(targetIndex, 1, firstLastQuery.FirstPageSize);
lastPageResultItemList = CacheIndexInternalAdapter.GetResultItemList(targetIndex,
targetIndex.Count - firstLastQuery.LastPageSize + 1,
firstLastQuery.LastPageSize);
}
else
{
//Populate everything in firstPageResultItemList
firstPageResultItemList = CacheIndexInternalAdapter.GetResultItemList(targetIndex, 1, targetIndex.Count);
}
#endregion
#region Get data
if (!firstLastQuery.ExcludeData)
{
//First Page
if (firstPageResultItemList != null)
{
DataTierUtil.GetData(firstPageResultItemList,
storeContext,
messageContext,
indexTypeMapping.FullDataIdFieldList,
firstLastQuery.FullDataIdInfo);
}
//Last Page
if (lastPageResultItemList != null)
{
DataTierUtil.GetData(lastPageResultItemList,
storeContext,
messageContext,
indexTypeMapping.FullDataIdFieldList,
firstLastQuery.FullDataIdInfo);
}
}
#endregion
#region Get metadata
if (firstLastQuery.GetMetadata)
{
metadata = IndexServerUtils.GetQueryMetadata(new List<CacheIndexInternal>(1) { targetIndex },
indexTypeMapping,
messageContext.TypeId,
messageContext.PrimaryId,
firstLastQuery.IndexId,
storeContext);
}
#endregion
}
#endregion
firstLastQueryResult = new FirstLastQueryResult(indexExists, indexSize, metadata, firstPageResultItemList, lastPageResultItemList, virtualCount, null);
}
catch (Exception ex)
{
firstLastQueryResult = new FirstLastQueryResult(false, -1, null, null, null, -1, ex.Message);
LoggingUtil.Log.ErrorFormat("TypeID {0} -- Error processing FirstLastQuery : {1}", messageContext.TypeId, ex);
}
return firstLastQueryResult;
}
/// <summary>
/// Gets the query metadata.
/// </summary>
/// <param name="internalCacheIndexList">The internal cache index list.</param>
/// <param name="indexTypeMapping">The index type mapping.</param>
/// <param name="typeId">The type id.</param>
/// <param name="primaryId">The primary id.</param>
/// <param name="extendedId">The extended id.</param>
/// <param name="storeContext">The store context.</param>
/// <returns></returns>
internal static byte[] GetQueryMetadata(List<CacheIndexInternal> internalCacheIndexList,
IndexTypeMapping indexTypeMapping,
short typeId,
int primaryId,
byte[] extendedId,
IndexStoreContext storeContext)
{
if (indexTypeMapping.MetadataStoredSeperately)
{
#region Check if metadata is stored seperately
//Send a get message to local index storage and fetch index for IndexId
RelayMessage getMsg = new RelayMessage(typeId, primaryId, extendedId, MessageType.Get);
storeContext.IndexStorageComponent.HandleMessage(getMsg);
if (getMsg.Payload != null)
{
return getMsg.Payload.ByteArray;
}
#endregion
}
else
{
#region Check metadata on indexes
foreach (CacheIndexInternal cacheIndexInternal in internalCacheIndexList)
{
if (indexTypeMapping.IndexCollection[cacheIndexInternal.InDeserializationContext.IndexName].MetadataPresent)
{
return cacheIndexInternal.Metadata;
}
}
#endregion
}
return null;
}