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); }