public virtual QueryResult GroupedItemQuery(QueryFilter queryFilter, ItemQueryType queryFlags, GroupByAndOrder[] groupBy, int expandCount, SortBy[] sortColumns, params PropertyDefinition[] dataColumns)
{
EnumValidator.ThrowIfInvalid <ItemQueryType>(queryFlags, "queryFlags");
if (groupBy == null)
{
throw new ArgumentNullException("groupBy");
}
if (dataColumns == null)
{
throw new ArgumentNullException("dataColumns");
}
if (expandCount > groupBy.Length)
{
throw new ArgumentException("expandCount should be less or equal to groupBy lengths");
}
ContentsTableFlags flags = QueryExecutor.ItemQueryTypeToContentsTableFlags(queryFlags) | ContentsTableFlags.DeferredErrors;
MapiTable mapiTable = this.GetContentsTable(flags);
QueryResult queryResult = null;
bool flag = false;
QueryResult result;
try
{
List <PropTag> alteredProperties = null;
this.SetTableFilter(mapiTable, queryFilter);
SortOrder sortOrder = this.GetSortOrder(mapiTable, sortColumns, groupBy, expandCount, ref alteredProperties);
queryResult = new QueryResult(mapiTable, dataColumns, alteredProperties, this.Session, true, sortOrder);
if (this.Session != null)
{
this.Session.MessagesWereDownloaded = true;
}
flag = true;
result = queryResult;
}
finally
{
if (!flag)
{
if (queryResult != null)
{
queryResult.Dispose();
queryResult = null;
}
if (mapiTable != null)
{
mapiTable.Dispose();
mapiTable = null;
}
}
}
return(result);
}
public InMemoryFilterQueryResult(Folder folder, ItemQueryType itemQueryType, QueryFilter filter, SortBy[] sortBy, PropertyDefinition[] queryColumns, bool useSortOrder)
{
ComparisonFilter comparisonFilter = filter as ComparisonFilter;
if (comparisonFilter == null)
{
AndFilter andFilter = filter as AndFilter;
if (andFilter != null)
{
comparisonFilter = (andFilter.Filters[0] as ComparisonFilter);
if (comparisonFilter == null)
{
comparisonFilter = (ComparisonFilter)andFilter.Filters[1];
}
}
}
this.BuildResultSet(folder, itemQueryType, filter, comparisonFilter, sortBy, queryColumns, useSortOrder);
}
List <MessageRec> IFolder.LookupMessages(PropTag ptagToLookup, List <byte[]> keysToLookup, PropTag[] additionalPtagsToLoad)
{
MrsTracer.Provider.Function("StorageFolder.LookupMessages: {0}", new object[]
{
this.DisplayNameForTracing
});
EntryIdMap <MessageRec> result = new EntryIdMap <MessageRec>();
ItemQueryType[] array = new ItemQueryType[]
{
ItemQueryType.None,
ItemQueryType.Associated
};
int capacity = 3 + ((additionalPtagsToLoad == null) ? 0 : additionalPtagsToLoad.Length);
List <PropertyDefinition> columns = new List <PropertyDefinition>(capacity)
{
CoreObjectSchema.EntryId,
CoreItemSchema.Size,
CoreObjectSchema.CreationTime
};
int idxEntryId = 0;
int idxMessageSize = 1;
int idxCreationTime = 2;
int idxExtraProperties = 3;
if (additionalPtagsToLoad != null && additionalPtagsToLoad.Length > 0)
{
columns.AddRange(this.Mailbox.ConvertPropTagsToDefinitions(additionalPtagsToLoad));
}
ItemQueryType[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
StorageFolder.< > c__DisplayClassb CS$ < > 8__locals2 = new StorageFolder.< > c__DisplayClassb();
CS$ < > 8__locals2.queryType = array2[i];
if (result.Count >= keysToLookup.Count)
{
break;
}
bool doingFAI = CS$ < > 8__locals2.queryType == ItemQueryType.Associated;
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("StorageFolder.GetContentsTable", OperationType.None),
new SimpleValueDataContext("QueryType", CS$ < > 8__locals2.queryType)
}).Execute(delegate
// Token: 0x060005C1 RID: 1473 RVA: 0x0002B884 File Offset: 0x00029A84
protected int FolderItemTypeCount(Folder folder, ItemQueryType queryType)
{
if (queryType != ItemQueryType.None && queryType != ItemQueryType.Associated)
{
SysCleanupEnforcerBase.Tracer.TraceDebug <SysCleanupEnforcerBase, string, ItemQueryType>((long)this.GetHashCode(), "{0}:{1} Folder is Empty of type {2}", this, folder.Id.ObjectId.ToHexEntryId(), queryType);
return(0);
}
StorePropertyDefinition propertyDefinition;
if (queryType == ItemQueryType.Associated)
{
propertyDefinition = FolderSchema.AssociatedItemCount;
}
else
{
propertyDefinition = FolderSchema.ItemCount;
}
return((int)folder[propertyDefinition]);
}
// Token: 0x06000620 RID: 1568 RVA: 0x0002EFA0 File Offset: 0x0002D1A0
private void ProcessFolderContents(StoreId folderId, ItemQueryType itemQueryType)
{
SupplementExpirationEnforcer.Tracer.TraceDebug <SupplementExpirationEnforcer, StoreId, ItemQueryType>((long)this.GetHashCode(), "{0}: Starting to process folder {1} with query type {2}.", this, folderId, itemQueryType);
using (Folder folder = Folder.Bind(base.MailboxDataForTags.MailboxSession, folderId))
{
if (base.FolderItemTypeCount(folder, itemQueryType) <= 0)
{
SupplementExpirationEnforcer.Tracer.TraceDebug <SupplementExpirationEnforcer, string, ItemQueryType>((long)this.GetHashCode(), "{0}:{1} Folder is Empty of type {2}", this, folder.Id.ObjectId.ToHexEntryId(), itemQueryType);
}
else
{
using (QueryResult queryResult = folder.ItemQuery(itemQueryType, null, new SortBy[]
{
new SortBy(ItemSchema.RetentionDate, SortOrder.Descending)
}, SupplementExpirationEnforcer.ItemPropertyColumns.PropertyDefinitions))
{
ComparisonFilter seekFilter = new ComparisonFilter(ComparisonOperator.LessThanOrEqual, ItemSchema.RetentionDate, base.MailboxDataForTags.UtcNow.Date);
queryResult.SeekToCondition(SeekReference.OriginBeginning, seekFilter);
bool flag = false;
while (!flag)
{
object[][] rows = queryResult.GetRows(100);
if (rows.Length <= 0)
{
break;
}
foreach (object[] rawProperties in rows)
{
PropertyArrayProxy propertyArrayProxy = new PropertyArrayProxy(SupplementExpirationEnforcer.ItemPropertyColumns, rawProperties);
if (!(propertyArrayProxy[ItemSchema.RetentionDate] is ExDateTime))
{
SupplementExpirationEnforcer.Tracer.TraceDebug <SupplementExpirationEnforcer>((long)this.GetHashCode(), "{0}: Retention date is missing. Skipping items from here on.", this);
flag = true;
break;
}
this.EnlistItem(propertyArrayProxy);
}
base.SysCleanupSubAssistant.ThrottleStoreCallAndCheckForShutdown(base.MailboxDataForTags.MailboxSession.MailboxOwner);
}
}
}
}
}
// Token: 0x060005F4 RID: 1524 RVA: 0x0002D2F0 File Offset: 0x0002B4F0
private bool ProcessFolderContents(DefaultFolderType folderToCollect, ItemQueryType itemQueryType)
{
DumpsterQuotaEnforcer.Tracer.TraceDebug <DumpsterQuotaEnforcer, DefaultFolderType, ItemQueryType>((long)this.GetHashCode(), "{0}: ProcessFolderContents: folderToCollect={1}, itemQueryType={2}.", this, folderToCollect, itemQueryType);
bool flag = false;
using (Folder folder = Folder.Bind(base.MailboxDataForTags.MailboxSession, folderToCollect))
{
int num = base.FolderItemTypeCount(folder, itemQueryType);
this.itemsInDumpster += num;
if (num <= 0)
{
DumpsterQuotaEnforcer.Tracer.TraceDebug <DumpsterQuotaEnforcer, string, ItemQueryType>((long)this.GetHashCode(), "{0}:{1} Folder is Empty of type {2}", this, folder.Id.ObjectId.ToHexEntryId(), itemQueryType);
return(false);
}
using (QueryResult queryResult = folder.ItemQuery(itemQueryType, null, new SortBy[]
{
new SortBy(StoreObjectSchema.LastModifiedTime, SortOrder.Ascending)
}, DumpsterQuotaEnforcer.PropertyColumns.PropertyDefinitions))
{
queryResult.SeekToOffset(SeekReference.OriginBeginning, 0);
while (!flag)
{
object[][] rows = queryResult.GetRows(100);
if (rows.Length <= 0)
{
break;
}
foreach (object[] rawProperties in rows)
{
if (!this.EnlistItem(new PropertyArrayProxy(DumpsterQuotaEnforcer.PropertyColumns, rawProperties)))
{
flag = true;
DumpsterQuotaEnforcer.Tracer.TraceDebug <DumpsterQuotaEnforcer, bool>((long)this.GetHashCode(), "{0}: EnlistItem returned false. theEnd={1}.", this, flag);
break;
}
}
base.SysCleanupSubAssistant.ThrottleStoreCallAndCheckForShutdown(base.MailboxDataForTags.MailboxSession.MailboxOwner);
}
}
}
return(flag);
}
// Token: 0x06000673 RID: 1651 RVA: 0x0003133C File Offset: 0x0002F53C
private void ProcessFolderContents(Folder folder, ItemQueryType itemQueryType)
{
int num = base.FolderItemTypeCount(folder, itemQueryType);
if (num <= 0)
{
CalendarLogExpirationEnforcer.Tracer.TraceDebug <CalendarLogExpirationEnforcer, string, ItemQueryType>((long)this.GetHashCode(), "{0}:{1} Folder is Empty of type {2}", this, folder.Id.ObjectId.ToHexEntryId(), itemQueryType);
return;
}
using (QueryResult queryResult = folder.ItemQuery(itemQueryType, null, new SortBy[]
{
new SortBy(CalendarLogExpirationEnforcer.agePropertyDefinition, SortOrder.Ascending)
}, CalendarLogExpirationEnforcer.PropertyColumns.PropertyDefinitions))
{
queryResult.SeekToOffset(SeekReference.OriginBeginning, 0);
bool flag = false;
while (!flag)
{
object[][] rows = queryResult.GetRows(100);
if (rows.Length <= 0)
{
break;
}
foreach (object[] rawProperties in rows)
{
PropertyArrayProxy propertyArrayProxy = new PropertyArrayProxy(CalendarLogExpirationEnforcer.PropertyColumns, rawProperties);
if (!ElcMailboxHelper.Exists(propertyArrayProxy[CalendarLogExpirationEnforcer.agePropertyDefinition]))
{
CalendarLogExpirationEnforcer.Tracer.TraceDebug <CalendarLogExpirationEnforcer>((long)this.GetHashCode(), "{0}: Last Modified date is missing. Skipping items from here on.", this);
flag = true;
break;
}
if (!this.EnlistItem(propertyArrayProxy))
{
flag = true;
break;
}
}
base.SysCleanupSubAssistant.ThrottleStoreCallAndCheckForShutdown(base.MailboxDataForTags.MailboxSession.MailboxOwner);
}
}
}
internal static ContentsTableFlags ItemQueryTypeToContentsTableFlags(ItemQueryType itemQueryFlags)
{
EnumValidator.ThrowIfInvalid <ItemQueryType>(itemQueryFlags, "itemQueryFlags");
ContentsTableFlags contentsTableFlags = ContentsTableFlags.None;
if ((itemQueryFlags & ItemQueryType.Associated) != ItemQueryType.None)
{
contentsTableFlags |= ContentsTableFlags.Associated;
}
if ((itemQueryFlags & ItemQueryType.SoftDeleted) != ItemQueryType.None)
{
contentsTableFlags |= ContentsTableFlags.ShowSoftDeletes;
}
if ((itemQueryFlags & ItemQueryType.RetrieveFromIndex) != ItemQueryType.None)
{
contentsTableFlags |= ContentsTableFlags.RetrieveFromIndex;
}
if ((itemQueryFlags & ItemQueryType.ConversationViewMembers) != ItemQueryType.None)
{
contentsTableFlags |= ContentsTableFlags.ShowConversationMembers;
}
if ((itemQueryFlags & ItemQueryType.ConversationView) != ItemQueryType.None)
{
contentsTableFlags |= ContentsTableFlags.ShowConversations;
}
if ((itemQueryFlags & ItemQueryType.DocumentIdView) != ItemQueryType.None)
{
contentsTableFlags |= ContentsTableFlags.DocumentIdView;
}
if ((itemQueryFlags & ItemQueryType.PrereadExtendedProperties) != ItemQueryType.None)
{
contentsTableFlags |= ContentsTableFlags.PrereadExtendedProperties;
}
if ((itemQueryFlags & ItemQueryType.NoNotifications) != ItemQueryType.None)
{
contentsTableFlags |= ContentsTableFlags.NoNotifications;
}
return(contentsTableFlags);
}
// Token: 0x06000666 RID: 1638 RVA: 0x00030BD8 File Offset: 0x0002EDD8
private bool ProcessFolderContents(DefaultFolderType folderToCollect, ItemQueryType itemQueryType)
{
if (AuditQuotaEnforcer.Tracer.IsTraceEnabled(TraceType.DebugTrace))
{
AuditQuotaEnforcer.Tracer.TraceDebug <AuditQuotaEnforcer, DefaultFolderType, ItemQueryType>((long)this.GetHashCode(), "{0}: ProcessFolderContents: folderToCollect={1}, itemQueryType={2}.", this, folderToCollect, itemQueryType);
}
StoreId adminAuditLogsFolderId = base.MailboxDataForTags.MailboxSession.GetAdminAuditLogsFolderId();
int num = 0;
AuditLogCollection auditLogCollection = new AuditLogCollection(base.MailboxDataForTags.MailboxSession, adminAuditLogsFolderId, AuditQuotaEnforcer.Tracer);
foreach (IAuditLog auditLog in auditLogCollection.GetAuditLogs())
{
AuditLog auditLog2 = (AuditLog)auditLog;
this.itemsInDumpster += auditLog2.EstimatedItemCount;
foreach (ItemData itemData in auditLog2.FindAuditRecords <ItemData>(this))
{
base.TagExpirationExecutor.AddToDoomedHardDeleteList(itemData, false);
this.deletedItemsSize += (ulong)((long)itemData.MessageSize);
this.itemsExpired++;
num++;
if (num % 100 == 0)
{
base.SysCleanupSubAssistant.ThrottleStoreCallAndCheckForShutdown(base.MailboxDataForTags.MailboxSession.MailboxOwner);
}
}
if (this.dumpsterSize - this.deletedItemsSize <= this.dumpsterQuota.Value.ToBytes())
{
if (AuditQuotaEnforcer.Tracer.IsTraceEnabled(TraceType.DebugTrace))
{
AuditQuotaEnforcer.Tracer.TraceDebug <AuditQuotaEnforcer, ulong, ulong>((long)this.GetHashCode(), "{0}: Collected sufficient items. dumspterSize={1}, deletedItemsSize={2}.", this, this.dumpsterSize, this.deletedItemsSize);
break;
}
break;
}
}
return(true);
}
public static MailboxSyncQueryProcessor.IQueryResult ItemQuery(Folder folder, ItemQueryType itemQueryType, QueryFilter filter, QueryFilter optimizationFilter, SortBy[] sortBy, PropertyDefinition[] queryColumns, bool allowTableRestrict, bool useSortOrder)
{
if (!(optimizationFilter is FalseFilter))
{
return(new MailboxSyncQueryProcessor.InMemoryFilterQueryResult(folder, itemQueryType, filter, optimizationFilter, sortBy, queryColumns, useSortOrder));
}
if (MailboxSyncQueryProcessor.InMemoryFilterQueryResult.Match(filter, sortBy))
{
return(new MailboxSyncQueryProcessor.InMemoryFilterQueryResult(folder, itemQueryType, filter, sortBy, queryColumns, useSortOrder));
}
if (allowTableRestrict)
{
return(new MailboxSyncQueryProcessor.SlowQueryResult(folder, itemQueryType, filter, sortBy, queryColumns));
}
throw new InvalidOperationException(ServerStrings.ExNoOptimizedCodePath);
}
public InMemoryFilterQueryResult(Folder folder, ItemQueryType itemQueryType, QueryFilter filter, QueryFilter optimizationFilter, SortBy[] sortBy, PropertyDefinition[] queryColumns, bool useSortOrder)
{
this.BuildResultSet(folder, itemQueryType, filter, optimizationFilter, sortBy, queryColumns, useSortOrder);
}
public SlowQueryResult(Folder folder, ItemQueryType itemQueryType, QueryFilter filter, SortBy[] sortBy, PropertyDefinition[] queryColumns)
{
this.queryResult = folder.ItemQuery(itemQueryType, filter, sortBy, queryColumns);
this.disposeTracker = this.GetDisposeTracker();
}
public QueryResult GroupedItemQuery(QueryFilter queryFilter, ItemQueryType queryFlags, GroupByAndOrder[] groupBy, int expandCount, SortBy[] sortColumns, params PropertyDefinition[] dataColumns)
{
throw new NotImplementedException();
}
private void BuildResultSet(Folder folder, ItemQueryType itemQueryType, QueryFilter filter, QueryFilter optimizationFilter, SortBy[] sortBy, PropertyDefinition[] queryColumns, bool useSortOrder)
{
MailboxSyncPropertyBag mailboxSyncPropertyBag = new MailboxSyncPropertyBag(queryColumns);
ComparisonFilter comparisonFilter = optimizationFilter as ComparisonFilter;
mailboxSyncPropertyBag.AddColumnsFromFilter(filter);
this.idxSortColumn = mailboxSyncPropertyBag.AddColumn(sortBy[0].ColumnDefinition);
SortBy[] sortColumns = null;
if (comparisonFilter != null && useSortOrder)
{
SortOrder sortOrder;
switch (comparisonFilter.ComparisonOperator)
{
case ComparisonOperator.LessThan:
case ComparisonOperator.LessThanOrEqual:
sortOrder = SortOrder.Descending;
break;
default:
sortOrder = SortOrder.Ascending;
break;
}
sortColumns = new SortBy[]
{
new SortBy(comparisonFilter.Property, sortOrder)
};
}
QueryResult queryResult2;
QueryResult queryResult = queryResult2 = folder.ItemQuery(itemQueryType, null, sortColumns, mailboxSyncPropertyBag.Columns);
try
{
bool flag = 0 != queryResult.EstimatedRowCount;
if (comparisonFilter != null)
{
flag = queryResult.SeekToCondition(SeekReference.OriginBeginning, comparisonFilter);
int currentRow = queryResult.CurrentRow;
}
if (flag)
{
int currentRow = queryResult.CurrentRow;
int num = -1;
if (comparisonFilter != null)
{
QueryFilter seekFilter = MailboxSyncQueryProcessor.InMemoryFilterQueryResult.CreateNegatedComparisonFilter(comparisonFilter);
if (queryResult.SeekToCondition(SeekReference.OriginCurrent, seekFilter))
{
num = queryResult.CurrentRow;
}
queryResult.SeekToOffset(SeekReference.OriginBeginning, currentRow);
}
this.result = new List <object[]>(queryResult.EstimatedRowCount);
do
{
int num2 = 10000;
if (-1 != num)
{
num2 = num - currentRow;
}
if (num2 > 10000)
{
num2 = 10000;
}
object[][] rows = queryResult.GetRows(num2);
if (rows.Length == 0)
{
break;
}
for (int i = 0; i < rows.Length; i++)
{
mailboxSyncPropertyBag.Bind(rows[i]);
if (EvaluatableFilter.Evaluate(filter, mailboxSyncPropertyBag))
{
this.result.Add(rows[i]);
}
}
}while (-1 == num || queryResult.CurrentRow < num);
}
}
finally
{
if (queryResult2 != null)
{
((IDisposable)queryResult2).Dispose();
}
}
if (this.result != null)
{
this.result.Sort(this.GetSortByComparer(sortBy[0]));
}
}
// Token: 0x060006B3 RID: 1715 RVA: 0x00033498 File Offset: 0x00031698
private void ProcessFolderContents(Folder folder, DefaultFolderType folderTypeToCollect, ItemQueryType itemQueryType)
{
int num = base.FolderItemTypeCount(folder, itemQueryType);
if (num <= 0)
{
MigrateToArchiveEnforcer.Tracer.TraceDebug <MigrateToArchiveEnforcer, string, ItemQueryType>((long)this.GetHashCode(), "{0}:{1} Folder is Empty of type {2}", this, folder.Id.ObjectId.ToHexEntryId(), itemQueryType);
return;
}
using (QueryResult queryResult = folder.ItemQuery(itemQueryType, null, null, MigrateToArchiveEnforcer.PropertyColumns.PropertyDefinitions))
{
queryResult.SeekToOffset(SeekReference.OriginBeginning, 0);
bool flag = false;
while (!flag)
{
object[][] rows = queryResult.GetRows(100);
if (rows.Length <= 0)
{
break;
}
foreach (object[] rawProperties in rows)
{
PropertyArrayProxy itemProperties = new PropertyArrayProxy(MigrateToArchiveEnforcer.PropertyColumns, rawProperties);
this.EnlistItem(itemProperties, folderTypeToCollect);
if (this.MaxItemsCollectedForThisCycle(folderTypeToCollect))
{
flag = true;
break;
}
}
base.SysCleanupSubAssistant.ThrottleStoreCallAndCheckForShutdown(base.MailboxDataForTags.MailboxSession.MailboxOwner);
}
}
}
List <MessageRec> IFolder.EnumerateMessages(EnumerateMessagesFlags emFlags, PropTag[] additionalPtagsToLoad)
{
MrsTracer.Provider.Function("StorageFolder.EnumerateMessages: {0}", new object[]
{
this.DisplayNameForTracing
});
List <MessageRec> result = new List <MessageRec>();
ItemQueryType[] array = new ItemQueryType[]
{
ItemQueryType.None,
ItemQueryType.Associated
};
for (int i = 0; i < array.Length; i++)
{
ItemQueryType flags = array[i];
bool doingFAI = (flags & ItemQueryType.Associated) != ItemQueryType.None;
bool doingDeletes = (flags & ItemQueryType.SoftDeleted) != ItemQueryType.None;
if ((emFlags & ((!doingDeletes || 2 != 0) ? EnumerateMessagesFlags.RegularMessages : ((EnumerateMessagesFlags)0))) != (EnumerateMessagesFlags)0)
{
List <NativeStorePropertyDefinition> dataColumns = new List <NativeStorePropertyDefinition>(5);
int idxEntryId = -1;
int idxCreationTime = -1;
int idxMessageClass = -1;
int idxRuleMsgVersion = -1;
int idxMessageSize = -1;
idxEntryId = dataColumns.Count;
dataColumns.Add(this.Mailbox.ConvertPropTagsToDefinitions(new PropTag[]
{
PropTag.EntryId
})[0]);
if ((emFlags & EnumerateMessagesFlags.IncludeExtendedData) != (EnumerateMessagesFlags)0)
{
idxMessageSize = dataColumns.Count;
dataColumns.Add(this.Mailbox.ConvertPropTagsToDefinitions(new PropTag[]
{
PropTag.MessageSize
})[0]);
idxCreationTime = dataColumns.Count;
dataColumns.Add(this.Mailbox.ConvertPropTagsToDefinitions(new PropTag[]
{
PropTag.CreationTime
})[0]);
}
if (doingFAI)
{
idxMessageClass = dataColumns.Count;
dataColumns.Add(this.Mailbox.ConvertPropTagsToDefinitions(new PropTag[]
{
PropTag.MessageClass
})[0]);
idxRuleMsgVersion = dataColumns.Count;
dataColumns.Add(this.Mailbox.ConvertPropTagsToDefinitions(new PropTag[]
{
PropTag.RuleMsgVersion
})[0]);
}
int idxExtraPtags = dataColumns.Count;
if (additionalPtagsToLoad != null)
{
dataColumns.AddRange(this.Mailbox.ConvertPropTagsToDefinitions(additionalPtagsToLoad));
}
MrsTracer.Provider.Debug("StorageFolder.GetContentsTable({0})", new object[]
{
flags
});
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("StorageFolder.EnumerateMessages", OperationType.None),
new SimpleValueDataContext("Flags", flags)
}).Execute(delegate
{
QueryFilter queryFilter = null;
if (this.contentsRestriction != null)
{
queryFilter = this.contentsRestriction.GetQueryFilter(this.Mailbox.StoreSession);
}
using (QueryResult queryResult = this.CoreFolder.QueryExecutor.ItemQuery(flags, queryFilter, null, dataColumns.ToArray()))
{
MrsTracer.Provider.Debug("StorageFolder.EnumerateMessages: ItemQuery returned {0} items.", new object[]
{
queryResult.EstimatedRowCount
});
object[][] rows;
do
{
using (this.Mailbox.RHTracker.Start())
{
rows = queryResult.GetRows(1000);
}
object[][] array2 = rows;
int j = 0;
while (j < array2.Length)
{
object[] array3 = array2[j];
if (!doingFAI)
{
goto IL_197;
}
string x = (string)array3[idxMessageClass];
if ((this.Mailbox.Options & MailboxOptions.IgnoreExtendedRuleFAIs) != MailboxOptions.None)
{
if (!StringComparer.OrdinalIgnoreCase.Equals(x, "IPM.Rule.Message") && !StringComparer.OrdinalIgnoreCase.Equals(x, "IPM.Rule.Version2.Message"))
{
if (!StringComparer.OrdinalIgnoreCase.Equals(x, "IPM.ExtendedRule.Message"))
{
goto IL_197;
}
}
}
else if (!StringComparer.OrdinalIgnoreCase.Equals(x, "IPM.Rule.Message") || !(array3[idxRuleMsgVersion] as short? == 1))
{
goto IL_197;
}
IL_3E6:
j++;
continue;
IL_197:
DateTime dateTime = DateTime.MinValue;
if (idxCreationTime != -1)
{
object obj = array3[idxCreationTime];
if (obj is ExDateTime)
{
dateTime = (DateTime)((ExDateTime)obj);
}
}
byte[] entryId = (byte[])array3[idxEntryId];
if (emFlags.HasFlag(EnumerateMessagesFlags.SkipICSMidSetMissing) && this.Mailbox.SupportsSavingSyncState)
{
SyncContentsManifestState syncContentsManifestState = this.Mailbox.SyncState[this.FolderId];
if (syncContentsManifestState != null && !syncContentsManifestState.IdSetGivenContainsEntryId(entryId))
{
MrsTracer.Provider.Debug("entry id {0} with creation time {1} not found in given items.", new object[]
{
TraceUtils.DumpEntryId(entryId),
dateTime
});
goto IL_3E6;
}
}
List <PropValueData> list = null;
if (additionalPtagsToLoad != null && additionalPtagsToLoad.Length > 0)
{
list = new List <PropValueData>();
for (int k = idxExtraPtags; k < array3.Length; k++)
{
list.Add(new PropValueData(additionalPtagsToLoad[k - idxExtraPtags], array3[k]));
}
}
int messageSize = 1000;
if (idxMessageSize != -1)
{
object obj2 = array3[idxMessageSize];
if (obj2 is int)
{
messageSize = (int)obj2;
}
}
if (emFlags.HasFlag(EnumerateMessagesFlags.ReturnLongTermIDs))
{
if (list == null)
{
list = new List <PropValueData>();
}
list.Add(new PropValueData(PropTag.LTID, this.Mailbox.StoreSession.IdConverter.GetLongTermIdFromId(this.Mailbox.StoreSession.IdConverter.GetMidFromMessageId(StoreObjectId.FromProviderSpecificId(entryId)))));
}
MsgRecFlags msgRecFlags = doingFAI ? MsgRecFlags.Associated : MsgRecFlags.None;
if (doingDeletes)
{
msgRecFlags |= MsgRecFlags.Deleted;
}
MessageRec item = new MessageRec(entryId, this.FolderId, dateTime, messageSize, msgRecFlags, (list == null) ? null : list.ToArray());
result.Add(item);
goto IL_3E6;
}
}while (rows.Length > 0);
}
});
}
}
MrsTracer.Provider.Debug("StorageFolder.EnumerateMessages returns {0} items.", new object[]
{
result.Count
});
return(result);
}
internal static QueryResult GetPositionedQueryResult(Folder folderToQuery, StoreObjectId abqMailId, FirstTimeSyncWatermark minWatermark, ExDateTime?filterCutoffDate, ICollection <PropertyDefinition> propDefs, bool trackAssociatedMessageChanges, out int rowsToFetch)
{
AirSyncDiagnostics.TraceDebug <string, string, string>(ExTraceGlobals.SyncProcessTracer, null, "[FirstTimeSyncProvider.GetPositionedQueryResult] Folder: {0}, filterCutoffDate: {1}, minWatermark: {2}", folderToQuery.DisplayName, (filterCutoffDate != null) ? filterCutoffDate.Value.ToString() : "<NULL>", minWatermark.IsNew ? "<NEW>" : minWatermark.ReceivedDateUtc.ToString());
ComparisonFilter comparisonFilter = null;
rowsToFetch = -1;
if (abqMailId != null)
{
AirSyncDiagnostics.TraceDebug <StoreObjectId>(ExTraceGlobals.SyncProcessTracer, null, "[FirstTimeSyncProvider.GetPositionedQueryResult] ABQMail Id is not null. Limiting result set to item: {0}", abqMailId);
comparisonFilter = new ComparisonFilter(ComparisonOperator.Equal, ItemSchema.Id, abqMailId);
rowsToFetch = 1;
}
else if (!minWatermark.IsNew)
{
AirSyncDiagnostics.TraceDebug <ExDateTime>(ExTraceGlobals.SyncProcessTracer, null, "[FirstTimeSyncProvider.GetPositionedQueryResult] Watermark is not new. Starting watermark received date: {0}", minWatermark.ReceivedDateUtc);
comparisonFilter = new ComparisonFilter(ComparisonOperator.LessThanOrEqual, ItemSchema.ReceivedTime, minWatermark.ReceivedDateUtc);
}
else
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.SyncProcessTracer, null, "[FirstTimeSyncProvider.GetPositionedQueryResult] Watermark is NEW.");
}
SortBy[] sortColumns = FirstTimeSyncProvider.newestFirstSortOrder;
QueryResult queryResult = null;
bool flag = false;
try
{
ItemQueryType itemQueryType = ItemQueryType.None;
if (trackAssociatedMessageChanges)
{
itemQueryType |= ItemQueryType.Associated;
}
queryResult = folderToQuery.ItemQuery(itemQueryType, null, sortColumns, propDefs);
if (comparisonFilter != null)
{
if (!queryResult.SeekToCondition(SeekReference.OriginBeginning, comparisonFilter))
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.SyncProcessTracer, null, "[FirstTimeSyncProvider.GetPositionedQueryResult] Did not find any matching items for our initial seekToFilter.");
rowsToFetch = 0;
flag = true;
return(queryResult);
}
AirSyncDiagnostics.TraceDebug <int, int>(ExTraceGlobals.SyncProcessTracer, null, "[FirstTimeSyncProvider.GetPositionedQueryResult] Done seeking to condition. Current Row: {0}, Estimated Row Count: {1}", queryResult.CurrentRow, queryResult.EstimatedRowCount);
}
else
{
AirSyncDiagnostics.TraceDebug(ExTraceGlobals.SyncProcessTracer, null, "[FirstTimeSyncProvider.GetPositionedQueryResult] No seekToFilter, positioning at beginning.");
queryResult.SeekToOffset(SeekReference.OriginBeginning, 0);
}
if (abqMailId == null)
{
int currentRow = queryResult.CurrentRow;
if (filterCutoffDate != null && currentRow >= 0)
{
ComparisonFilter seekFilter = new ComparisonFilter(ComparisonOperator.LessThan, ItemSchema.ReceivedTime, filterCutoffDate.Value);
bool flag2 = queryResult.SeekToCondition(SeekReference.OriginCurrent, seekFilter);
int num = queryResult.CurrentRow - (flag2 ? 1 : 0);
rowsToFetch = num - currentRow + 1;
if (rowsToFetch < 0)
{
rowsToFetch = 0;
}
AirSyncDiagnostics.TraceDebug <bool, int>(ExTraceGlobals.SyncProcessTracer, null, "[FirstTimeSyncProvider.GetPositionedQueryResult] Finding ending condition. Found? {0}. Rows to fetch: {1}", flag2, rowsToFetch);
queryResult.SeekToOffset(SeekReference.OriginBeginning, currentRow);
}
}
flag = true;
}
finally
{
if (!flag && queryResult != null)
{
queryResult.Dispose();
}
}
return(queryResult);
}
public static IStorePropertyBag[] FindItemsFromInternetId(MailboxSession session, string internetMessageId, ItemQueryType itemQueryType, params PropertyDefinition[] propertyDefinitions)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullOrEmptyArgument(internetMessageId, "internetMessageId");
Util.ThrowOnNullOrEmptyArgument(propertyDefinitions, "propertyDefinitions");
ICollection <PropertyDefinition> properties = InternalSchema.Combine <PropertyDefinition>(propertyDefinitions, new PropertyDefinition[]
{
ItemSchema.InternetMessageId,
ItemSchema.InternetMessageIdHash
});
int internetMessageIdHash = (int)AllItemsFolderHelper.GetHashValue(internetMessageId);
IStorePropertyBag[] array = AllItemsFolderHelper.RunQueryOnAllItemsFolder <IStorePropertyBag[]>(session, AllItemsFolderHelper.SupportedSortBy.InternetMessageIdHash, internetMessageIdHash, null, (QueryResult queryResult) => AllItemsFolderHelper.ProcessQueryResult(queryResult, internetMessageId, internetMessageIdHash), properties, itemQueryType);
return(array ?? Array <IStorePropertyBag> .Empty);
}
public static G RunQueryOnAllItemsFolder <G>(MailboxSession session, AllItemsFolderHelper.SupportedSortBy supportedSortBy, object seekToValue, G defaultValue, AllItemsFolderHelper.DoQueryProcessing <G> queryProcessor, ICollection <PropertyDefinition> properties, ItemQueryType itemQueryType)
{
return(AllItemsFolderHelper.RunQueryOnAllItemsFolder <G>(session, supportedSortBy, delegate(QueryResult queryResult)
{
if (queryResult.SeekToCondition(SeekReference.OriginBeginning, new ComparisonFilter(ComparisonOperator.Equal, AllItemsFolderHelper.sortOrderMap[supportedSortBy][0].ColumnDefinition, seekToValue)))
{
return queryProcessor(queryResult);
}
return defaultValue;
}, properties, itemQueryType));
}
public virtual IQueryResult IItemQuery(ItemQueryType queryFlags, QueryFilter queryFilter, SortBy[] sortColumns, ICollection <PropertyDefinition> dataColumns)
{
throw new NotImplementedException();
}
public void SetExtendedProps(PropTag[] promotedProperties, RestrictionData[] restrictions, SortOrderData[] views, ICSViewData[] icsViews)
{
MrsTracer.Provider.Function("StorageDestinationFolder.SetExtendedProps: {0}", new object[]
{
base.DisplayNameForTracing
});
if (promotedProperties != null && promotedProperties.Length > 0)
{
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("StorageDestinationFolder.SetPromotedProps", OperationType.None),
new PropTagsDataContext(promotedProperties)
}).Execute(delegate
{
PropertyDefinition[] dataColumns = this.Mailbox.ConvertPropTagsToDefinitions(promotedProperties);
using (this.Mailbox.RHTracker.Start())
{
using (QueryResult queryResult = this.CoreFolder.QueryExecutor.ItemQuery(ItemQueryType.None, null, null, dataColumns))
{
this.GetRowsIgnoreKnownFailures(queryResult);
}
}
});
}
if (restrictions != null && restrictions.Length > 0)
{
MrsTracer.Provider.Debug("Applying restrictions.", new object[0]);
for (int i = 0; i < restrictions.Length; i++)
{
RestrictionData rd = restrictions[i];
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("StorageDestinationFolder.ApplyRestriction", OperationType.None),
new RestrictionDataContext(rd)
}).Execute(delegate
{
QueryFilter queryFilter = rd.GetQueryFilter(this.Mailbox.StoreSession);
PropertyDefinition[] dataColumns = new PropertyDefinition[]
{
CoreObjectSchema.EntryId
};
using (this.Mailbox.RHTracker.Start())
{
using (new SortLCIDContext(this.Mailbox.StoreSession, rd.LCID))
{
using (QueryResult queryResult = this.CoreFolder.QueryExecutor.ItemQuery(ItemQueryType.None, queryFilter, null, dataColumns))
{
this.GetRowsIgnoreKnownFailures(queryResult);
}
}
}
});
}
}
if (views != null && views.Length > 0)
{
MrsTracer.Provider.Debug("Applying views.", new object[0]);
for (int j = 0; j < views.Length; j++)
{
SortOrderData sod = views[j];
if (sod.Members != null && sod.Members.Length != 0)
{
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("StorageDestinationFolder.ApplySortOrder", OperationType.None),
new SortOrderDataContext(sod)
}).Execute(delegate
{
List <SortBy> list;
List <GroupByAndOrder> list2;
int expandCount;
this.GetSortBy(sod, out list, out list2, out expandCount);
ItemQueryType itemQueryType = ItemQueryType.None;
if (sod.FAI)
{
itemQueryType |= ItemQueryType.Associated;
}
else if (sod.Conversation)
{
itemQueryType |= ItemQueryType.ConversationView;
}
PropertyDefinition[] dataColumns = new PropertyDefinition[]
{
CoreObjectSchema.EntryId
};
using (this.Mailbox.RHTracker.Start())
{
using (new SortLCIDContext(this.Mailbox.StoreSession, sod.LCID))
{
QueryResult queryResult;
if (list2.Count > 0)
{
queryResult = this.CoreFolder.QueryExecutor.GroupedItemQuery(null, itemQueryType, list2.ToArray(), expandCount, list.ToArray(), dataColumns);
}
else
{
queryResult = this.CoreFolder.QueryExecutor.ItemQuery(itemQueryType, null, (list.Count == 0) ? null : list.ToArray(), dataColumns);
}
using (queryResult)
{
this.GetRowsIgnoreKnownFailures(queryResult);
}
}
}
});
}
}
}
if (icsViews != null && icsViews.Length > 0)
{
MrsTracer.Provider.Debug("Applying ICS views.", new object[0]);
for (int k = 0; k < icsViews.Length; k++)
{
ICSViewData icsView = icsViews[k];
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("StorageDestinationFolder.ApplyICSView", OperationType.None),
new ICSViewDataContext(icsView)
}).Execute(delegate
{
using (MailboxSyncProvider mailboxSyncProvider = new MailboxSyncProvider(this.Folder, true, !icsView.Conversation, true, icsView.Conversation, true, false, null))
{
mailboxSyncProvider.GetMaxItemWatermark(mailboxSyncProvider.CreateNewWatermark());
}
});
}
}
}
public virtual QueryResult ItemQuery(ItemQueryType queryFlags, QueryFilter queryFilter, SortBy[] sortColumns, ICollection <PropertyDefinition> dataColumns)
{
Util.ThrowOnNullArgument(dataColumns, "dataColumns");
return(this.InternalItemQuery(QueryExecutor.ItemQueryTypeToContentsTableFlags(queryFlags), queryFilter, sortColumns, QueryExclusionType.Row, dataColumns, null));
}
public QueryResult ItemQuery(ItemQueryType queryFlags, QueryFilter queryFilter, SortBy[] sortColumns, params PropertyDefinition[] dataColumns)
{
return(this.ItemQuery(queryFlags, queryFilter, sortColumns, (ICollection <PropertyDefinition>)dataColumns));
}
protected SingleInstanceItemHandler(ItemQueryType itemQueryType, string queryItemClass)
{
ArgumentValidator.ThrowIfNullOrWhiteSpace("queryItemClass", queryItemClass);
this.itemQueryType = itemQueryType;
this.queryItemClass = queryItemClass;
}
public static G RunQueryOnAllItemsFolder <G>(MailboxSession session, AllItemsFolderHelper.SupportedSortBy supportedSortBy, AllItemsFolderHelper.DoQueryProcessing <G> queryProcessor, ICollection <PropertyDefinition> properties, ItemQueryType itemQueryType)
{
AllItemsFolderHelper.CheckAndCreateDefaultFolders(session);
G result;
using (SearchFolder searchFolder = SearchFolder.Bind(session, DefaultFolderType.AllItems))
{
using (QueryResult queryResult = searchFolder.ItemQuery(itemQueryType, null, AllItemsFolderHelper.sortOrderMap[supportedSortBy], properties))
{
result = queryProcessor(queryResult);
}
}
return(result);
}
