Example #1
0
        private static void MergeSelectExpressionsAndFields(MergeProposal mergeProposal, Dictionary <string, ExpressionSyntax> selectExpressionDict, MergeSuggestions mergeSuggestion)
        {
            foreach (var curProposedData in mergeProposal.ProposedForMerge)
            {
                foreach (var curExpr in curProposedData.SelectExpressions)
                {
                    var expression     = curExpr.Value as MemberAccessExpressionSyntax;
                    var identifierName = ExtractIdentifierFromExpression(expression);

                    if (identifierName != null && identifierName == curProposedData.FromIdentifier)
                    {
                        if (expression.Expression is MemberAccessExpressionSyntax)
                        {
                            var valueStr    = ExtractValueFromExpression(curExpr.Value);
                            var valueExp    = SyntaxFactory.ParseExpression(valueStr).NormalizeWhitespace();
                            var innerName   = ExtractIdentifierFromExpression(valueExp as MemberAccessExpressionSyntax);
                            var innerMember = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                                   SyntaxFactory.IdentifierName("doc"), SyntaxFactory.IdentifierName(innerName));
                            expression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, innerMember, expression.Name);
                        }

                        else if (expression.Expression is SimpleNameSyntax)
                        {
                            expression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("doc"), expression.Name);
                        }
                    }

                    selectExpressionDict[curExpr.Key] = expression ?? curExpr.Value;
                }

                mergeSuggestion.CanMerge.Add(curProposedData.IndexName);
                DataDictionaryMerge(mergeSuggestion.MergedIndex.Fields, curProposedData.Index.Fields);
                mergeSuggestion.MergedIndex.Fields = mergeSuggestion.MergedIndex.Fields;
            }
        }
Example #2
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);
            }
        }
Example #3
0
        private List <MergeProposal> MergeIndexes(List <IndexData> indexes)
        {
            var mergedIndexesData = new List <MergeProposal>();

            foreach (var indexData in indexes.Where(indexData => !indexData.IsAlreadyMerged))
            {
                indexData.IsAlreadyMerged = true;
                var mergeData = new MergeProposal();

                List <string> failComments = CheckForUnsuitableIndexForMerging(indexData);

                if (failComments.Count != 0)
                {
                    indexData.Comment          = string.Join(Environment.NewLine, failComments);
                    indexData.IsSuitedForMerge = false;
                    mergeData.MergedData       = indexData;
                    mergedIndexesData.Add(mergeData);
                    continue;
                }

                mergeData.ProposedForMerge.Add(indexData);

                foreach (IndexData current in indexes) // Note, we have O(N**2) here, known and understood
                {
                    if (current.IsMapReduceOrMultiMap)
                    {
                        continue;
                    }
                    if (mergeData.ProposedForMerge.All(other => CanMergeIndexes(other, current)) == false)
                    {
                        continue;
                    }

                    if (AreSelectClausesCompatible(current, indexData) == false)
                    {
                        continue;
                    }

                    current.IsSuitedForMerge = true;
                    mergeData.ProposedForMerge.Add(current);
                }

                mergedIndexesData.Add(mergeData);
            }

            return(mergedIndexesData);
        }
Example #4
0
        private static void TrySetCollectionName(MergeProposal mergeProposal, MergeSuggestions mergeSuggestion)
        {
            if (mergeProposal.ProposedForMerge[0].Collection != null)
            {
                mergeSuggestion.Collection = mergeProposal.ProposedForMerge[0].Collection;
            }

            else if (mergeProposal.ProposedForMerge[0].FromExpression is SimpleNameSyntax name)
            {
                mergeSuggestion.Collection = name.Identifier.ValueText;
            }

            else if (mergeProposal.ProposedForMerge[0].FromExpression is MemberAccessExpressionSyntax member)
            {
                var identifier = ExtractIdentifierFromExpression(member);
                if (identifier == "docs")
                {
                    mergeSuggestion.Collection = ExtractValueFromExpression(member);
                }
            }
        }