/// <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;
MetadataPropertyCollection metadataPropertyCollection = null;
bool indexExists = false;
int indexSize = -1;
int virtualCount = -1;
try
{
IndexTypeMapping indexTypeMapping =
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId];
#region Check TargetIndexName
if (string.IsNullOrEmpty(containsIndexQuery.TargetIndexName))
{
containsIndexQuery.TargetIndexName = IndexServerUtils.CheckQueryTargetIndexName(indexTypeMapping);
}
if (!indexTypeMapping.IndexCollection.Contains(containsIndexQuery.TargetIndexName))
{
throw new Exception("Invalid TargetIndexName - " + containsIndexQuery.TargetIndexName);
}
#endregion
Index targetIndexInfo = indexTypeMapping.IndexCollection[containsIndexQuery.TargetIndexName];
int indexCap = targetIndexInfo.MaxIndexSize;
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,
targetIndexInfo.IsMetadataPropertyCollection,
null,
containsIndexQuery.DomainSpecificProcessingType,
storeContext.DomainSpecificConfig,
null,
null,
false);
#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,
indexInfo.IsMetadataPropertyCollection,
null,
containsIndexQuery.DomainSpecificProcessingType,
storeContext.DomainSpecificConfig,
null,
null,
false);
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)
{
if (indexTypeMapping.MetadataStoredSeperately)
{
IndexServerUtils.GetMetadataStoredSeperately(indexTypeMapping,
messageContext.TypeId,
messageContext.PrimaryId,
containsIndexQuery.IndexId,
storeContext,
out metadata,
out metadataPropertyCollection);
}
else
{
IndexServerUtils.GetMetadataStoredWithIndex(indexTypeMapping,
internalCacheIndexList,
out metadata,
out metadataPropertyCollection);
}
}
#endregion
}
containsIndexQueryResult = new ContainsIndexQueryResult(multiItemResult,
metadata,
metadataPropertyCollection,
indexSize,
indexExists,
virtualCount,
indexCap,
null);
}
catch (Exception ex)
{
containsIndexQueryResult = new ContainsIndexQueryResult(null, null, null, -1, false, -1, 0, ex.Message);
LoggingUtil.Log.ErrorFormat("TypeId {0} -- Error processing ContainsIndexQuery : {1}", messageContext.TypeId, ex);
}
return(containsIndexQueryResult);
}
/// <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;
MetadataPropertyCollection metadataPropertyCollection = 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];
int indexCap = targetIndexInfo.MaxIndexSize;
#region Prepare Result
#region Extract index and apply criteria
if (indexTypeMapping.MetadataStoredSeperately)
{
IndexServerUtils.GetMetadataStoredSeperately(indexTypeMapping,
messageContext.TypeId,
messageContext.PrimaryId,
firstLastQuery.IndexId,
storeContext,
out metadata,
out metadataPropertyCollection);
}
CacheIndexInternal targetIndex = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
messageContext.PrimaryId,
firstLastQuery.IndexId,
targetIndexInfo.ExtendedIdSuffix,
firstLastQuery.TargetIndexName,
maxItemsPerIndex,
firstLastQuery.Filter,
true,
firstLastQuery.IndexCondition,
false,
false,
targetIndexInfo.PrimarySortInfo,
targetIndexInfo.LocalIdentityTagList,
targetIndexInfo.StringHashCodeDictionary,
null,
targetIndexInfo.IsMetadataPropertyCollection,
metadataPropertyCollection,
firstLastQuery.DomainSpecificProcessingType,
storeContext.DomainSpecificConfig,
null,
null,
false);
#endregion
if (targetIndex != null)
{
indexSize = targetIndex.OutDeserializationContext.TotalCount;
virtualCount = targetIndex.VirtualCount;
indexExists = true;
#region Dynamic tag sort
if (firstLastQuery.TagSort != null)
{
targetIndex.Sort(firstLastQuery.TagSort);
}
#endregion
// 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,
null,
storeContext,
messageContext,
indexTypeMapping.FullDataIdFieldList,
firstLastQuery.FullDataIdInfo);
}
//Last Page
if (lastPageResultItemList != null)
{
DataTierUtil.GetData(lastPageResultItemList,
null,
storeContext,
messageContext,
indexTypeMapping.FullDataIdFieldList,
firstLastQuery.FullDataIdInfo);
}
}
#endregion
#region Get metadata
if (firstLastQuery.GetMetadata && !indexTypeMapping.MetadataStoredSeperately)
{
IndexServerUtils.GetMetadataStoredWithIndex(indexTypeMapping,
new List <CacheIndexInternal>(1)
{
targetIndex
},
out metadata,
out metadataPropertyCollection);
}
#endregion
}
#endregion
firstLastQueryResult = new FirstLastQueryResult(indexExists, indexSize, metadata, metadataPropertyCollection, firstPageResultItemList, lastPageResultItemList, virtualCount, indexCap, null);
}
catch (Exception ex)
{
firstLastQueryResult = new FirstLastQueryResult(false, -1, null, null, null, null, -1, 0, ex.Message);
LoggingUtil.Log.ErrorFormat("TypeID {0} -- Error processing FirstLastQuery : {1}", messageContext.TypeId, ex);
}
return(firstLastQueryResult);
}
/// <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;
MetadataPropertyCollection metadataPropertyCollection = null;
try
{
IndexTypeMapping indexTypeMapping =
storeContext.StorageConfiguration.CacheIndexV3StorageConfig.IndexTypeMappingCollection[messageContext.TypeId];
#region Validate Query
ValidateQuery(indexTypeMapping, randomQuery);
#endregion
Index targetIndexInfo = indexTypeMapping.IndexCollection[randomQuery.TargetIndexName];
int indexCap = targetIndexInfo.MaxIndexSize;
#region Prepare Result
#region Extract index and apply criteria
if (indexTypeMapping.MetadataStoredSeperately)
{
IndexServerUtils.GetMetadataStoredSeperately(indexTypeMapping,
messageContext.TypeId,
messageContext.PrimaryId,
randomQuery.IndexId,
storeContext,
out metadata,
out metadataPropertyCollection);
}
CacheIndexInternal targetIndex = IndexServerUtils.GetCacheIndexInternal(storeContext,
messageContext.TypeId,
messageContext.PrimaryId,
randomQuery.IndexId,
targetIndexInfo.ExtendedIdSuffix,
randomQuery.TargetIndexName,
0,
randomQuery.Filter,
true,
randomQuery.IndexCondition,
false,
false,
targetIndexInfo.PrimarySortInfo,
targetIndexInfo.LocalIdentityTagList,
targetIndexInfo.StringHashCodeDictionary,
null,
targetIndexInfo.IsMetadataPropertyCollection,
metadataPropertyCollection,
randomQuery.DomainSpecificProcessingType,
storeContext.DomainSpecificConfig,
null,
null,
false);
#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,
null,
storeContext,
messageContext,
indexTypeMapping.FullDataIdFieldList,
randomQuery.FullDataIdInfo);
}
#endregion
#region Get metadata
if (randomQuery.GetMetadata && !indexTypeMapping.MetadataStoredSeperately)
{
IndexServerUtils.GetMetadataStoredWithIndex(indexTypeMapping,
new List <CacheIndexInternal>(1)
{
targetIndex
},
out metadata,
out metadataPropertyCollection);
}
#endregion
#endregion
}
randomQueryResult = new RandomQueryResult(indexExists, indexSize, metadata, metadataPropertyCollection, resultItemList, virtualCount, indexCap, null);
}
catch (Exception ex)
{
randomQueryResult = new RandomQueryResult(false, -1, null, null, null, -1, 0, ex.Message);
LoggingUtil.Log.ErrorFormat("TypeId {0} -- Error processing RandomQuery : {1}", messageContext.TypeId, ex);
}
return(randomQueryResult);
}