Пример #1
0
        private static void RemoveMatchingIndexes(MergeProposal mergeProposal, Dictionary <string, ExpressionSyntax> selectExpressionDict, MergeSuggestions mergeSuggestion,
                                                  IndexMergeResults indexMergeResults)
        {
            if (mergeProposal.ProposedForMerge.Count > 1)
            {
                var matchingExistingIndexes = mergeProposal.ProposedForMerge.Where(x =>
                                                                                   AreSelectClausesTheSame(x, selectExpressionDict) &&
                                                                                   (x.Index.Compare(mergeSuggestion.MergedIndex) == IndexDefinitionCompareDifferences.None ||
                                                                                    x.Index.Compare(mergeSuggestion.MergedIndex) == IndexDefinitionCompareDifferences.Maps))
                                              .OrderBy(x => x.IndexName.StartsWith("Auto/", StringComparison.CurrentCultureIgnoreCase))
                                              .ToList();

                if (matchingExistingIndexes.Count > 0)
                {
                    var surpassingIndex = matchingExistingIndexes.First();
                    mergeSuggestion.SurpassingIndex = surpassingIndex.IndexName;

                    mergeSuggestion.MergedIndex = null;
                    mergeSuggestion.CanMerge.Clear();
                    mergeSuggestion.CanDelete = mergeProposal.ProposedForMerge.Except(new[]
                    {
                        surpassingIndex
                    }).Select(x => x.IndexName).ToList();
                }

                indexMergeResults.Suggestions.Add(mergeSuggestion);
            }
        }
Пример #2
0
        private static IndexMergeResults ExcludePartialResults(IndexMergeResults originalIndexes)
        {
            var resultingIndexMerge = new IndexMergeResults();

            foreach (var suggestion in originalIndexes.Suggestions)
            {
                suggestion.CanMerge.Sort();
            }

            var hasMatch = false;

            for (var i = 0; i < originalIndexes.Suggestions.Count; i++)
            {
                var sug1 = originalIndexes.Suggestions[i];
                for (var j = i + 1; j < originalIndexes.Suggestions.Count; j++)
                {
                    var sug2 = originalIndexes.Suggestions[j];
                    if (sug1 != sug2 && sug1.CanMerge.Count <= sug2.CanMerge.Count)
                    {
                        var sugCanMergeSet = new HashSet <string>(sug1.CanMerge);
                        hasMatch = sugCanMergeSet.IsSubsetOf(sug2.CanMerge);
                        if (hasMatch)
                        {
                            break;
                        }
                    }
                }
                if (!hasMatch)
                {
                    resultingIndexMerge.Suggestions.Add(sug1);
                }
                hasMatch = false;
            }
            resultingIndexMerge.Unmergables = originalIndexes.Unmergables;
            return(resultingIndexMerge);
        }
Пример #3
0
        private IndexMergeResults CreateMergeIndexDefinition(List <MergeProposal> indexDataForMerge)
        {
            var indexMergeResults = new IndexMergeResults();

            foreach (var mergeProposal in indexDataForMerge.Where(m => m.ProposedForMerge.Count == 0 && m.MergedData != null))
            {
                indexMergeResults.Unmergables.Add(mergeProposal.MergedData.IndexName, mergeProposal.MergedData.Comment);
            }

            foreach (var mergeProposal in indexDataForMerge)
            {
                if (mergeProposal.ProposedForMerge.Count == 0)
                {
                    continue;
                }

                var mergeSuggestion      = new MergeSuggestions();
                var selectExpressionDict = new Dictionary <string, ExpressionSyntax>();

                MergeSelectExpressionsAndFields(mergeProposal, selectExpressionDict, mergeSuggestion);
                TrySetCollectionName(mergeProposal, mergeSuggestion);

                var map = mergeProposal.ProposedForMerge[0].BuildExpression(selectExpressionDict);
                mergeSuggestion.MergedIndex.Maps.Add(map);
                RemoveMatchingIndexes(mergeProposal, selectExpressionDict, mergeSuggestion, indexMergeResults);

                if (mergeProposal.ProposedForMerge.Count == 1 && mergeProposal.ProposedForMerge[0].IsSuitedForMerge == false)
                {
                    const string comment = "Can't find any other index to merge this with";
                    indexMergeResults.Unmergables.Add(mergeProposal.ProposedForMerge[0].IndexName, comment);
                }
            }

            indexMergeResults = ExcludePartialResults(indexMergeResults);
            return(indexMergeResults);
        }