Example #1
0
        public static BindVariableConfiguration GetBindVariable(OracleStatementSemanticModel semanticModel, string bindVariableIdentifier)
        {
            var normalizedIdentifier = bindVariableIdentifier.ToQuotedIdentifier();

            return(semanticModel.Statement.BindVariables
                   .SingleOrDefault(v => v.Nodes.Any(n => String.Equals(n.Token.Value.ToQuotedIdentifier(), normalizedIdentifier))));
        }
        public static ICollection <CommandExecutionHandler> ResolveCommandHandlers(OracleStatementSemanticModel semanticModel, StatementGrammarNode currentTerminal)
        {
            CheckParametersNotNull(semanticModel, currentTerminal);

            var commands = new List <CommandExecutionHandler>();

            if (currentTerminal.Id != Terminals.Identifier && currentTerminal.Id != Terminals.RowIdPseudocolumn)
            {
                return(EmptyHandlerCollection);
            }

            var columnReference = semanticModel.AllReferenceContainers.SelectMany(qb => qb.ColumnReferences).SingleOrDefault(c => c.ColumnNode == currentTerminal);

            if (columnReference == null || columnReference.ColumnNodeObjectReferences.Count <= 1)
            {
                return(EmptyHandlerCollection);
            }

            var identifiers = OracleObjectIdentifier.GetUniqueReferences(columnReference.ColumnNodeObjectReferences.Select(r => r.FullyQualifiedObjectName).ToArray());
            var actions     = columnReference.ColumnNodeObjectReferences
                              .Where(r => identifiers.Contains(r.FullyQualifiedObjectName))
                              .Select(
                r =>
                new CommandExecutionHandler
            {
                Name             = r.FullyQualifiedObjectName + "." + columnReference.Name,
                ExecutionHandler = c => new ResolveAmbiguousColumnCommand(c, r.FullyQualifiedObjectName + "." + columnReference.Name)
                                   .Execute(),
                CanExecuteHandler = c => true
            });

            commands.AddRange(actions);

            return(commands.AsReadOnly());
        }
Example #3
0
        private void ResolveSqlStatements(OraclePlSqlProgram program)
        {
            var sqlStatementNodes = program.RootNode.GetPathFilterDescendants(
                n => !String.Equals(n.Id, NonTerminals.ItemList2) && !(String.Equals(n.Id, NonTerminals.PlSqlBlock) && String.Equals(n.ParentNode.Id, NonTerminals.PlSqlStatementType)),
                NonTerminals.SelectStatement, NonTerminals.InsertStatement, NonTerminals.UpdateStatement, NonTerminals.MergeStatement);

            foreach (var sqlStatementNode in sqlStatementNodes)
            {
                var childStatement =
                    new OracleStatement
                {
                    RootNode       = sqlStatementNode,
                    ParseStatus    = Statement.ParseStatus,
                    SourcePosition = sqlStatementNode.SourcePosition
                };

                var sqlStatementSemanticModel = new OracleStatementSemanticModel(sqlStatementNode.GetText(StatementText), childStatement, DatabaseModel).Build(CancellationToken);
                program.SqlModels.Add(sqlStatementSemanticModel);

                foreach (var queryBlock in sqlStatementSemanticModel.QueryBlocks)
                {
                    QueryBlockNodes.Add(queryBlock.RootNode, queryBlock);
                }

                foreach (var plSqlVariableReference in sqlStatementSemanticModel.AllReferenceContainers.SelectMany(c => c.PlSqlVariableReferences))
                {
                    plSqlVariableReference.PlSqlProgram = program;
                }
            }
        }
        public OracleReferenceContainer(OracleStatementSemanticModel semanticModel)
        {
            if (semanticModel == null)
            {
                throw new ArgumentNullException(nameof(semanticModel));
            }

            SemanticModel = semanticModel;
        }
Example #5
0
		public OracleReferenceContainer(OracleStatementSemanticModel semanticModel)
		{
			if (semanticModel == null)
			{
				throw new ArgumentNullException(nameof(semanticModel));
			}

			SemanticModel = semanticModel;
		}
Example #6
0
        protected static void CheckParametersNotNull(OracleStatementSemanticModel semanticModel, StatementGrammarNode currentTerminal)
        {
            if (semanticModel == null)
            {
                throw new InvalidOperationException("semanticModel");
            }

            if (currentTerminal == null)
            {
                throw new InvalidOperationException("currentTerminal");
            }
        }
Example #7
0
		private FindUsagesCommand(ActionExecutionContext executionContext)
		{
			if (executionContext.DocumentRepository == null || executionContext.DocumentRepository.StatementText != executionContext.StatementText)
			{
				return;
			}

			_currentNode = GetFindUsagesCompatibleTerminal(executionContext.DocumentRepository.Statements, executionContext.CaretOffset);
			if (_currentNode == null)
			{
				return;
			}

			_semanticModel = (OracleStatementSemanticModel)executionContext.DocumentRepository.ValidationModels[_currentNode.Statement].SemanticModel;
			_queryBlock = _semanticModel.GetQueryBlock(_currentNode);
			_executionContext = executionContext;
		}
Example #8
0
        private FindUsagesCommand(ActionExecutionContext executionContext)
        {
            if (executionContext.DocumentRepository == null || executionContext.DocumentRepository.StatementText != executionContext.StatementText)
            {
                return;
            }

            _currentNode = GetFindUsagesCompatibleTerminal(executionContext.DocumentRepository.Statements, executionContext.CaretOffset);
            if (_currentNode == null)
            {
                return;
            }

            _semanticModel    = (OracleStatementSemanticModel)executionContext.DocumentRepository.ValidationModels[_currentNode.Statement].SemanticModel;
            _queryBlock       = _semanticModel.GetQueryBlock(_currentNode);
            _executionContext = executionContext;
        }
Example #9
0
		public static ICollection<CommandExecutionHandler> ResolveCommandHandlers(OracleStatementSemanticModel semanticModel, StatementGrammarNode currentTerminal)
		{
			CheckParametersNotNull(semanticModel, currentTerminal);

			var commands = new List<CommandExecutionHandler>();

			if (!CanConvertCurrentTerminal(currentTerminal))
			{
				return EmptyHandlerCollection;
			}

			var requiredPrecedingTerminalId = GetRequiredPrecedingTerminalId(currentTerminal);
			var literalTerminals = FindUsagesCommand.GetEqualValueLiteralTerminals(semanticModel.Statement, currentTerminal)
				.Where(t => requiredPrecedingTerminalId == t.PrecedingTerminal.Id || (requiredPrecedingTerminalId == null && !t.PrecedingTerminal.Id.In(Terminals.Date, Terminals.Timestamp)))
				.ToArray();

			var singleOccurenceConvertAction =
				new CommandExecutionHandler
				{
					Name = "Convert to bind variable",
					ExecutionHandler = c => new LiteralBindVariableConversionCommand(c, new[] { currentTerminal }, requiredPrecedingTerminalId)
						.Execute(),
					CanExecuteHandler = c => true
				};

			commands.Add(singleOccurenceConvertAction);

			if (literalTerminals.Length > 1)
			{
				var allOccurencesConvertAction =
					new CommandExecutionHandler
					{
						Name = "Convert all occurences to bind variable",
						ExecutionHandler = c => new LiteralBindVariableConversionCommand(c, literalTerminals, requiredPrecedingTerminalId)
							.Execute(),
						CanExecuteHandler = c => true
					};

				commands.Add(allOccurencesConvertAction);
			}

			return commands.AsReadOnly();
		}
        public static ICollection <CommandExecutionHandler> ResolveCommandHandlers(OracleStatementSemanticModel semanticModel, StatementGrammarNode currentTerminal)
        {
            CheckParametersNotNull(semanticModel, currentTerminal);

            var commands = new List <CommandExecutionHandler>();

            if (!CanConvertCurrentTerminal(currentTerminal))
            {
                return(EmptyHandlerCollection);
            }

            var requiredPrecedingTerminalId = GetRequiredPrecedingTerminalId(currentTerminal);
            var literalTerminals            = FindUsagesCommand.GetEqualValueLiteralTerminals(semanticModel.Statement, currentTerminal)
                                              .Where(t => requiredPrecedingTerminalId == t.PrecedingTerminal.Id || (requiredPrecedingTerminalId == null && !t.PrecedingTerminal.Id.In(Terminals.Date, Terminals.Timestamp)))
                                              .ToArray();

            var singleOccurenceConvertAction =
                new CommandExecutionHandler
            {
                Name             = "Convert to bind variable",
                ExecutionHandler =
                    c => new LiteralBindVariableConversionCommand(c, new[] { currentTerminal }, requiredPrecedingTerminalId).Execute(),
                CanExecuteHandler = c => true
            };

            commands.Add(singleOccurenceConvertAction);

            if (literalTerminals.Length > 1)
            {
                var allOccurencesConvertAction =
                    new CommandExecutionHandler
                {
                    Name             = "Convert all occurences to bind variable",
                    ExecutionHandler =
                        c => new LiteralBindVariableConversionCommand(c, literalTerminals, requiredPrecedingTerminalId).Execute(),
                    CanExecuteHandler = c => true
                };

                commands.Add(allOccurencesConvertAction);
            }

            return(commands.AsReadOnly());
        }
        private static IToolTip BuildParameterToolTip(OracleStatementSemanticModel semanticModel, StatementGrammarNode node)
        {
            Func <ProgramParameterReference, bool> parameterFilter = p => p.OptionalIdentifierTerminal == node;
            var programReference = semanticModel.AllReferenceContainers
                                   .SelectMany(c => c.AllReferences)
                                   .OfType <OracleProgramReferenceBase>()
                                   .SingleOrDefault(r => r.ParameterReferences != null && r.ParameterReferences.Any(parameterFilter));

            if (programReference?.Metadata == null)
            {
                return(null);
            }

            var parameter     = programReference.ParameterReferences.Single(parameterFilter);
            var parameterName = parameter.OptionalIdentifierTerminal.Token.Value.ToQuotedIdentifier();

            if (!programReference.Metadata.NamedParameters.TryGetValue(parameterName, out OracleProgramParameterMetadata parameterMetadata))
            {
                return(null);
            }

            var comment = String.Empty;

            if (OracleHelpProvider.PackageProgramDocumentations.TryGetValue(programReference.Metadata.Identifier, out DocumentationPackageSubProgram documentation))
            {
                comment = documentation.Parameters
                          ?.SingleOrDefault(p => String.Equals(p.Name.ToQuotedIdentifier(), parameterName))
                          ?.Value;
            }

            return
                (new ToolTipView
            {
                DataContext =
                    new ObjectDetailsModel
                {
                    Title = $"{parameterMetadata.Name.ToSimpleIdentifier()}: {parameterMetadata.FullDataTypeName}",
                    Comment = comment
                }
            });
        }
        public static ICollection <CommandExecutionHandler> ResolveCommandHandlers(OracleStatementSemanticModel semanticModel, StatementGrammarNode currentTerminal)
        {
            CheckParametersNotNull(semanticModel, currentTerminal);

            if (!String.Equals(currentTerminal.Id, Terminals.BindVariableIdentifier))
            {
                return(EmptyHandlerCollection);
            }

            var bindVariable = FindUsagesCommand.GetBindVariable(semanticModel, currentTerminal.Token.Value);

            var singleOccurenceConvertAction =
                new CommandExecutionHandler
            {
                Name             = "Convert to literal",
                ExecutionHandler = c => new BindVariableLiteralConversionCommand(c, bindVariable, false)
                                   .Execute(),
                CanExecuteHandler = c => true
            };

            var commands = new List <CommandExecutionHandler> {
                singleOccurenceConvertAction
            };

            if (bindVariable.Nodes.Count > 1)
            {
                var allOccurencesConvertAction =
                    new CommandExecutionHandler
                {
                    Name             = "Convert all accurences to literal",
                    ExecutionHandler = c => new BindVariableLiteralConversionCommand(c, bindVariable, true)
                                       .Execute(),
                    CanExecuteHandler = c => true
                };

                commands.Add(allOccurencesConvertAction);
            }

            return(commands.AsReadOnly());
        }
Example #13
0
        public OracleSqlModelReference(OracleStatementSemanticModel semanticModel, IReadOnlyList <OracleSelectListColumn> columns, IEnumerable <OracleDataObjectReference> sourceReferences, StatementGrammarNode measureExpressionList)
            : base(ReferenceType.SqlModel)
        {
            ColumnDefinitions = columns;

            MeasureExpressionList = measureExpressionList;

            SourceReferenceContainer = new OracleReferenceContainer(semanticModel);
            foreach (var column in columns)
            {
                TransferReferences(column.ColumnReferences, SourceReferenceContainer.ColumnReferences);
                TransferReferences(column.ProgramReferences, SourceReferenceContainer.ProgramReferences);
                TransferReferences(column.TypeReferences, SourceReferenceContainer.TypeReferences);
            }

            SourceReferenceContainer.ObjectReferences.AddRange(sourceReferences);

            DimensionReferenceContainer = new OracleReferenceContainer(semanticModel);
            MeasuresReferenceContainer  = new OracleReferenceContainer(semanticModel);

            ChildContainers = new[] { SourceReferenceContainer, DimensionReferenceContainer, MeasuresReferenceContainer };
        }
Example #14
0
		public OraclePivotTableReference(OracleStatementSemanticModel semanticModel, OracleDataObjectReference sourceReference, StatementGrammarNode pivotClause)
			: base(ReferenceType.PivotTable)
		{
			foreach (var sourceColumn in sourceReference.QueryBlocks.SelectMany(qb => qb.Columns).Where(c => !c.IsAsterisk))
			{
				sourceColumn.RegisterOuterReference();
			}

			PivotClause = pivotClause;
			SourceReference = sourceReference;

			RootNode = sourceReference.RootNode;
			var innerTableReferenceRootNode = sourceReference.RootNode.GetPathFilterDescendants(NodeFilters.BreakAtNestedQueryBlock, NonTerminals.InnerTableReference, NonTerminals.InnerSpecialTableReference).Last();
			sourceReference.RootNode = innerTableReferenceRootNode;

			Container = Owner = sourceReference.Owner;
			Owner.ObjectReferences.Remove(sourceReference);
			Owner.ObjectReferences.Add(this);

			SourceReferenceContainer = new OracleReferenceContainer(semanticModel);
			SourceReferenceContainer.ObjectReferences.Add(sourceReference);

			var aggregateExpressions = new List<StatementGrammarNode>();

			var pivotExpressions = PivotClause[NonTerminals.PivotAliasedAggregationFunctionList];
			if (pivotExpressions != null)
			{
				foreach (var pivotAggregationFunction in pivotExpressions.GetDescendants(NonTerminals.PivotAliasedAggregationFunction))
				{
					var aliasNode = pivotAggregationFunction[NonTerminals.ColumnAsAlias, Terminals.ColumnAlias];
					_columnNameExtensions.Add(aliasNode == null ? String.Empty : $"_{aliasNode.Token.Value.ToQuotedIdentifier().Trim('"')}");
					aggregateExpressions.Add(pivotAggregationFunction);
				}
			}

			AggregateFunctions = aggregateExpressions.AsReadOnly();
		}
Example #15
0
		public OracleQueryBlock(OracleStatement statement, StatementGrammarNode rootNode, OracleStatementSemanticModel semanticModel) : base(semanticModel)
		{
			if (rootNode == null)
			{
				throw new ArgumentNullException(nameof(rootNode));
			}

			if (!String.Equals(rootNode.Id, NonTerminals.QueryBlock))
			{
				throw new ArgumentException($"'rootNode' parameter must be '{NonTerminals.QueryBlock}' non-terminal. ", nameof(rootNode));
			}

			Statement = statement;
			RootNode = rootNode;

			FromClause = rootNode[NonTerminals.FromClause];
			HierarchicalQueryClause = rootNode[NonTerminals.HierarchicalQueryClause];

			if (HierarchicalQueryClause != null)
			{
				var hasNoCycleSupport = HierarchicalQueryClause[NonTerminals.HierarchicalQueryConnectByClause, OracleGrammarDescription.Terminals.NoCycle] != null;
				HierarchicalClauseReference = new OracleHierarchicalClauseReference(hasNoCycleSupport);
			}
		}
Example #16
0
		public static ICollection<CommandExecutionHandler> ResolveCommandHandlers(OracleStatementSemanticModel semanticModel, StatementGrammarNode currentTerminal)
		{
			CheckParametersNotNull(semanticModel, currentTerminal);

			if (!String.Equals(currentTerminal.Id, Terminals.BindVariableIdentifier))
				return EmptyHandlerCollection;

			var bindVariable = FindUsagesCommand.GetBindVariable(semanticModel, currentTerminal.Token.Value);

			var singleOccurenceConvertAction =
				new CommandExecutionHandler
				{
					Name = "Convert to literal",
					ExecutionHandler = c => new BindVariableLiteralConversionCommand(c, bindVariable, false)
						.Execute(),
					CanExecuteHandler = c => true
				};

			var commands = new List<CommandExecutionHandler> { singleOccurenceConvertAction };
			
			if (bindVariable.Nodes.Count > 1)
			{
				var allOccurencesConvertAction =
					new CommandExecutionHandler
					{
						Name = "Convert all accurences to literal",
						ExecutionHandler = c => new BindVariableLiteralConversionCommand(c, bindVariable, true)
							.Execute(),
						CanExecuteHandler = c => true
					};

				commands.Add(allOccurencesConvertAction);
			}

			return commands.AsReadOnly();
		}
 public OracleSelectListColumn(OracleStatementSemanticModel semanticModel, OracleSelectListColumn asteriskColumn)
     : base(semanticModel)
 {
     AsteriskColumn = asteriskColumn;
 }
Example #18
0
		public OracleMainObjectReferenceContainer(OracleStatementSemanticModel semanticModel)
			: base(semanticModel)
		{
		}
 public OracleMainObjectReferenceContainer(OracleStatementSemanticModel semanticModel)
     : base(semanticModel)
 {
 }
Example #20
0
		private static IToolTip BuildParameterToolTip(OracleStatementSemanticModel semanticModel, StatementGrammarNode node)
		{
			Func<ProgramParameterReference, bool> parameterFilter = p => p.OptionalIdentifierTerminal == node;
			var programReference = semanticModel.AllReferenceContainers
				.SelectMany(c => c.AllReferences)
				.OfType<OracleProgramReferenceBase>()
				.SingleOrDefault(r => r.ParameterReferences != null && r.ParameterReferences.Any(parameterFilter));

			if (programReference?.Metadata == null)
			{
				return null;
			}

			var parameter = programReference.ParameterReferences.Single(parameterFilter);
			var parameterName = parameter.OptionalIdentifierTerminal.Token.Value.ToQuotedIdentifier();

			OracleProgramParameterMetadata parameterMetadata;
			if (!programReference.Metadata.NamedParameters.TryGetValue(parameterName, out parameterMetadata))
			{
				return null;
			}

			var comment = String.Empty;
			DocumentationPackageSubProgram documentation;
			if (OracleHelpProvider.PackageProgramDocumentations.TryGetValue(programReference.Metadata.Identifier, out documentation))
			{
				comment = documentation.Parameters
					?.SingleOrDefault(p => String.Equals(p.Name.ToQuotedIdentifier(), parameterName))
					?.Value;
			}

			return
				new ToolTipView
				{
					DataContext =
						new ObjectDetailsModel
						{
							Title = $"{parameterMetadata.Name.ToSimpleIdentifier()}: {parameterMetadata.FullDataTypeName}",
							Comment = comment
						}
				};
		}
Example #21
0
        public OracleQueryBlock(OracleStatement statement, StatementGrammarNode rootNode, OracleStatementSemanticModel semanticModel) : base(semanticModel)
        {
            if (rootNode == null)
            {
                throw new ArgumentNullException(nameof(rootNode));
            }

            if (!String.Equals(rootNode.Id, NonTerminals.QueryBlock))
            {
                throw new ArgumentException($"'rootNode' parameter must be '{NonTerminals.QueryBlock}' non-terminal. ", nameof(rootNode));
            }

            Statement = statement;
            RootNode  = rootNode;

            FromClause = rootNode[NonTerminals.FromClause];
            HierarchicalQueryClause = rootNode[NonTerminals.HierarchicalQueryClause];

            if (HierarchicalQueryClause != null)
            {
                var hasNoCycleSupport = HierarchicalQueryClause[NonTerminals.HierarchicalQueryConnectByClause, OracleGrammarDescription.Terminals.NoCycle] != null;
                HierarchicalClauseReference = new OracleHierarchicalClauseReference(hasNoCycleSupport);
            }
        }
Example #22
0
		internal static IEnumerable<StatementGrammarNode> GetColumnUsages(OracleStatementSemanticModel semanticModel, StatementGrammarNode columnNode, bool onlyAliasOrigin)
		{
			return GetColumnUsagesInternal(semanticModel, columnNode, onlyAliasOrigin)
				.Select(u => u.Terminal);
		}
Example #23
0
        private static IEnumerable <TerminalUsage> GetColumnUsagesInternal(OracleStatementSemanticModel semanticModel, StatementGrammarNode columnNode, bool onlyAliasOrigin)
        {
            var usages          = Enumerable.Empty <TerminalUsage>();
            var columnReference = semanticModel.AllReferenceContainers
                                  .SelectMany(c => c.ColumnReferences)
                                  .FirstOrDefault(c => (c.ColumnNode == columnNode || c.SelectListColumn?.AliasNode == columnNode) && c.ColumnNodeObjectReferences.Count == 1 && c.ColumnNodeColumnReferences.Count == 1);

            OracleSelectListColumn selectListColumn;

            if (columnReference != null)
            {
                var objectReference        = columnReference.ColumnNodeObjectReferences.First();
                var sourceColumnReferences = objectReference.Owner == null ? objectReference.Container.ColumnReferences : objectReference.Owner.AllColumnReferences;
                var columnReferences       = sourceColumnReferences.Where(c => IsValidReference(c, columnReference, objectReference)).ToArray();
                usages = columnReferences.Select(c => new TerminalUsage {
                    Terminal = c.ColumnNode, Option = DisplayOptions.Usage
                });

                if (objectReference is OraclePivotTableReference pivotTableReference)
                {
                    var pivotColumnAliases = pivotTableReference.PivotColumns
                                             .Where(c => c.AliasNode != null && String.Equals(c.NormalizedName, columnReference.NormalizedName))
                                             .Select(c => new TerminalUsage {
                        Terminal = c.AliasNode, Option = DisplayOptions.Definition
                    });

                    usages = usages.Concat(pivotColumnAliases);
                }

                bool searchChildren;
                if (String.Equals(columnNode.Id, Terminals.Identifier))
                {
                    searchChildren = true;

                    selectListColumn = columnReference.SelectListColumn;
                    if (selectListColumn == null)
                    {
                        selectListColumn = columnReferences.FirstOrDefault(c => c.SelectListColumn != null && c.SelectListColumn.IsDirectReference && c.SelectListColumn.HasExplicitDefinition)?.SelectListColumn;
                    }
                    else if (!selectListColumn.IsDirectReference)
                    {
                        selectListColumn = null;
                    }

                    if (selectListColumn != null && !onlyAliasOrigin && selectListColumn.HasExplicitAlias)
                    {
                        var definition = new TerminalUsage {
                            Terminal = selectListColumn.AliasNode, Option = DisplayOptions.Definition
                        };
                        usages = usages.Concat(new[] { definition });
                    }
                }
                else
                {
                    selectListColumn = columnReference.Owner.Columns.Single(c => c.AliasNode == columnNode);
                    var nodeList = Enumerable.Repeat(new TerminalUsage {
                        Terminal = selectListColumn.AliasNode, Option = DisplayOptions.Definition
                    }, 1);
                    searchChildren = selectListColumn.IsDirectReference;

                    usages = searchChildren ? usages.Concat(nodeList) : nodeList;
                }

                usages = usages.Concat(GetModelClauseAndPivotTableReferences(columnReference, onlyAliasOrigin));

                if (searchChildren)
                {
                    usages = usages.Concat(GetChildQueryBlockColumnReferences(objectReference, columnReference, onlyAliasOrigin));
                }
            }
            else
            {
                var queryBlock = semanticModel.GetQueryBlock(columnNode);
                selectListColumn = queryBlock.Columns.SingleOrDefault(c => c.AliasNode == columnNode || c.ExplicitAliasNode == columnNode);

                var usageOption = DisplayOptions.Usage;
                if (selectListColumn?.ExplicitAliasNode == columnNode)
                {
                    usageOption = DisplayOptions.Definition;

                    if (queryBlock.IsRecursive && queryBlock.FollowingConcatenatedQueryBlock != null)
                    {
                        var oracleDataObjectReference = queryBlock.FollowingConcatenatedQueryBlock.ObjectReferences.FirstOrDefault(o => o.QueryBlocks.Count == 1 && o.QueryBlocks.First() == queryBlock.FollowingConcatenatedQueryBlock);
                        usages =
                            queryBlock.FollowingConcatenatedQueryBlock.AllColumnReferences
                            .Where(c => String.Equals(c.NormalizedName, selectListColumn.NormalizedName) && c.ColumnNodeColumnReferences.Count == 1 && c.ColumnNodeObjectReferences.Count == 1 && c.ColumnNodeObjectReferences.First() == oracleDataObjectReference)
                            .Select(c => CreateStandardTerminalUsage(c.ColumnNode));
                    }
                }

                var usage = new TerminalUsage {
                    Terminal = columnNode, Option = usageOption
                };
                usages = usages.Concat(Enumerable.Repeat(usage, 1));

                if (selectListColumn == null)
                {
                    if (queryBlock.ModelReference != null)
                    {
                        selectListColumn = queryBlock.ModelReference.ColumnDefinitions.SingleOrDefault(c => c.AliasNode == columnNode);
                        if (selectListColumn != null)
                        {
                            columnReference = queryBlock.ModelReference.DimensionReferenceContainer.ColumnReferences
                                              .Concat(queryBlock.ModelReference.MeasuresReferenceContainer.ColumnReferences)
                                              .Concat(queryBlock.AllColumnReferences)
                                              .FirstOrDefault(c => String.Equals(c.NormalizedName, selectListColumn.NormalizedName));

                            if (columnReference != null)
                            {
                                return(GetColumnUsagesInternal(semanticModel, columnReference.ColumnNode, onlyAliasOrigin));
                            }
                        }
                    }
                    else
                    {
                        var pivotTableColumn =
                            queryBlock.ObjectReferences.OfType <OraclePivotTableReference>()
                            .SelectMany(pt => pt.PivotColumns.Select(c => new { PivotTable = pt, Column = c }))
                            .SingleOrDefault(ptc => ptc.Column.AliasNode == columnNode);

                        if (pivotTableColumn != null)
                        {
                            selectListColumn = pivotTableColumn.Column;
                            var pivotUsages = queryBlock.AllColumnReferences
                                              .Where(c => c.ValidObjectReference == pivotTableColumn.PivotTable && c.HasExplicitDefinition && String.Equals(c.NormalizedName, selectListColumn.NormalizedName))
                                              .Select(c => new TerminalUsage {
                                Terminal = c.ColumnNode, Option = DisplayOptions.Usage
                            });

                            usages = usages.Concat(pivotUsages);
                        }
                    }
                }
                else
                {
                    var orderByReferenceUsages = queryBlock.ColumnReferences
                                                 .Where(c => c.Placement == StatementPlacement.OrderBy && c.ValidObjectReference == queryBlock.SelfObjectReference && String.Equals(c.NormalizedName, selectListColumn.NormalizedName))
                                                 .Select(c => new TerminalUsage {
                        Terminal = c.ColumnNode, Option = DisplayOptions.Usage
                    });
                    usages = usages.Concat(orderByReferenceUsages);
                }
            }

            var parentUsages = GetParentQueryBlockUsages(selectListColumn);

            if (onlyAliasOrigin)
            {
                var columnName = columnNode.Token.Value.ToQuotedIdentifier();
                parentUsages = parentUsages.TakeWhile(u => String.Equals(u.Terminal.Token.Value.ToQuotedIdentifier(), columnName));
            }

            usages = usages.Concat(parentUsages);

            return(usages);
        }
Example #24
0
 internal static IEnumerable <StatementGrammarNode> GetColumnUsages(OracleStatementSemanticModel semanticModel, StatementGrammarNode columnNode, bool onlyAliasOrigin)
 {
     return(GetColumnUsagesInternal(semanticModel, columnNode, onlyAliasOrigin)
            .Select(u => u.Terminal));
 }
Example #25
0
		private static IEnumerable<TerminalUsage> GetColumnUsagesInternal(OracleStatementSemanticModel semanticModel, StatementGrammarNode columnNode, bool onlyAliasOrigin)
		{
			var usages = Enumerable.Empty<TerminalUsage>();
			var columnReference = semanticModel.AllReferenceContainers
				.SelectMany(c => c.ColumnReferences)
				.FirstOrDefault(c => (c.ColumnNode == columnNode || c.SelectListColumn?.AliasNode == columnNode) && c.ColumnNodeObjectReferences.Count == 1 && c.ColumnNodeColumnReferences.Count == 1);

			OracleSelectListColumn selectListColumn;
			if (columnReference != null)
			{
				var objectReference = columnReference.ColumnNodeObjectReferences.First();
				var sourceColumnReferences = objectReference.Owner == null ? objectReference.Container.ColumnReferences : objectReference.Owner.AllColumnReferences;
				var columnReferences = sourceColumnReferences.Where(c => IsValidReference(c, columnReference, objectReference)).ToArray();
				usages = columnReferences.Select(c => new TerminalUsage { Terminal = c.ColumnNode, Option = DisplayOptions.Usage });

				var pivotTableReference = objectReference as OraclePivotTableReference;
				if (pivotTableReference != null)
				{
					var pivotColumnAliases = pivotTableReference.PivotColumns
						.Where(c => c.AliasNode != null && String.Equals(c.NormalizedName, columnReference.NormalizedName))
						.Select(c => new TerminalUsage { Terminal = c.AliasNode, Option = DisplayOptions.Definition });

					usages = usages.Concat(pivotColumnAliases);
				}

				bool searchChildren;
				if (String.Equals(columnNode.Id, Terminals.Identifier))
				{
					searchChildren = true;

					selectListColumn = columnReference.SelectListColumn;
					if (selectListColumn == null)
					{
						selectListColumn = columnReferences.FirstOrDefault(c => c.SelectListColumn != null && c.SelectListColumn.IsDirectReference && c.SelectListColumn.HasExplicitDefinition)?.SelectListColumn;
					}
					else if (!selectListColumn.IsDirectReference)
					{
						selectListColumn = null;
					}

					if (selectListColumn != null && !onlyAliasOrigin && selectListColumn.HasExplicitAlias)
					{
						var definition = new TerminalUsage { Terminal = selectListColumn.AliasNode, Option = DisplayOptions.Definition };
						usages = usages.Concat(new[] { definition });
					}
				}
				else
				{
					selectListColumn = columnReference.Owner.Columns.Single(c => c.AliasNode == columnNode);
					var nodeList = Enumerable.Repeat(new TerminalUsage { Terminal = selectListColumn.AliasNode, Option = DisplayOptions.Definition }, 1);
					searchChildren = selectListColumn.IsDirectReference;

					usages = searchChildren ? usages.Concat(nodeList) : nodeList;
				}

				usages = usages.Concat(GetModelClauseAndPivotTableReferences(columnReference, onlyAliasOrigin));

				if (searchChildren)
				{
					usages = usages.Concat(GetChildQueryBlockColumnReferences(objectReference, columnReference, onlyAliasOrigin));
				}
			}
			else
			{
				var queryBlock = semanticModel.GetQueryBlock(columnNode);
				selectListColumn = queryBlock.Columns.SingleOrDefault(c => c.AliasNode == columnNode || c.ExplicitAliasNode == columnNode);

				var usageOption = DisplayOptions.Usage;
				if (selectListColumn?.ExplicitAliasNode == columnNode)
				{
					usageOption = DisplayOptions.Definition;

					if (queryBlock.IsRecursive && queryBlock.FollowingConcatenatedQueryBlock != null)
					{
						var oracleDataObjectReference = queryBlock.FollowingConcatenatedQueryBlock.ObjectReferences.FirstOrDefault(o => o.QueryBlocks.Count == 1 && o.QueryBlocks.First() == queryBlock.FollowingConcatenatedQueryBlock);
						usages =
							queryBlock.FollowingConcatenatedQueryBlock.AllColumnReferences
								.Where(c => String.Equals(c.NormalizedName, selectListColumn.NormalizedName) && c.ColumnNodeColumnReferences.Count == 1 && c.ColumnNodeObjectReferences.Count == 1 && c.ColumnNodeObjectReferences.First() == oracleDataObjectReference)
								.Select(c => CreateStandardTerminalUsage(c.ColumnNode));
					}
				}

				var usage = new TerminalUsage { Terminal = columnNode, Option = usageOption };
				usages = usages.Concat(Enumerable.Repeat(usage, 1));

				if (selectListColumn == null)
				{
					if (queryBlock.ModelReference != null)
					{
						selectListColumn = queryBlock.ModelReference.ColumnDefinitions.SingleOrDefault(c => c.AliasNode == columnNode);
						if (selectListColumn != null)
						{
							columnReference = queryBlock.ModelReference.DimensionReferenceContainer.ColumnReferences
								.Concat(queryBlock.ModelReference.MeasuresReferenceContainer.ColumnReferences)
								.Concat(queryBlock.AllColumnReferences)
								.FirstOrDefault(c => String.Equals(c.NormalizedName, selectListColumn.NormalizedName));

							if (columnReference != null)
							{
								return GetColumnUsagesInternal(semanticModel, columnReference.ColumnNode, onlyAliasOrigin);
							}
						}
					}
					else
					{
						var pivotTableColumn =
							queryBlock.ObjectReferences.OfType<OraclePivotTableReference>()
								.SelectMany(pt => pt.PivotColumns.Select(c => new { PivotTable = pt, Column = c }))
								.SingleOrDefault(ptc => ptc.Column.AliasNode == columnNode);

						if (pivotTableColumn != null)
						{
							selectListColumn = pivotTableColumn.Column;
							var pivotUsages = queryBlock.AllColumnReferences
								.Where(c => c.ValidObjectReference == pivotTableColumn.PivotTable && c.HasExplicitDefinition && String.Equals(c.NormalizedName, selectListColumn.NormalizedName))
								.Select(c => new TerminalUsage { Terminal = c.ColumnNode, Option = DisplayOptions.Usage });

							usages = usages.Concat(pivotUsages);
						}
					}
				}
				else
				{
					var orderByReferenceUsages = queryBlock.ColumnReferences
						.Where(c => c.Placement == StatementPlacement.OrderBy && c.ValidObjectReference == queryBlock.SelfObjectReference && String.Equals(c.NormalizedName, selectListColumn.NormalizedName))
						.Select(c => new TerminalUsage { Terminal = c.ColumnNode, Option = DisplayOptions.Usage });
					usages = usages.Concat(orderByReferenceUsages);
				}
			}

			var parentUsages = GetParentQueryBlockUsages(selectListColumn);
			if (onlyAliasOrigin)
			{
				var columnName = columnNode.Token.Value.ToQuotedIdentifier();
				parentUsages = parentUsages.TakeWhile(u => String.Equals(u.Terminal.Token.Value.ToQuotedIdentifier(), columnName));
			}

			usages = usages.Concat(parentUsages);

			return usages;
		}
Example #26
0
 public OracleInsertTarget(OracleStatementSemanticModel semanticModel) : base(semanticModel)
 {
 }
Example #27
0
		private static IEnumerable<ICodeCompletionItem> GenerateCommonTableExpressionReferenceItems(OracleStatementSemanticModel model, string referenceNamePart, StatementGrammarNode node, int insertOffset)
		{
			var formatOption = FormatOptions.Alias;
			// TODO: Make proper resolution of CTE accessibility
			return model.QueryBlocks
				.Where(qb => qb.Type == QueryBlockType.CommonTableExpression && qb.PrecedingConcatenatedQueryBlock == null && referenceNamePart.ToQuotedIdentifier() != qb.NormalizedAlias && CodeCompletionSearchHelper.IsMatch(qb.Alias, referenceNamePart))
				.Select(qb =>
				{
					var alias = OracleStatementFormatter.FormatTerminalValue(qb.Alias, formatOption);
					return new OracleCodeCompletionItem
					{
						Name = alias,
						Text = alias,
						StatementNode = node,
						Category = OracleCodeCompletionCategory.CommonTableExpression,
						InsertOffset = insertOffset,
						CategoryPriority = -1
					};
				});
		}
        private static IReadOnlyList <SourcePosition> FindCorrespondingColumnAndExpression(OracleStatementSemanticModel semanticModel, StatementGrammarNode terminal)
        {
            var correspondingSourcePositions = new List <SourcePosition>();

            int?columnIndex;
            StatementGrammarNode columnNode;

            foreach (var queryBlock in semanticModel.QueryBlocks)
            {
                if (queryBlock.PrecedingConcatenatedQueryBlock != null)
                {
                    continue;
                }

                columnNode = FindItemAndIndexIndex(queryBlock.ExplicitColumnNames?.Keys, t => t == terminal, out columnIndex);
                if (columnIndex == null)
                {
                    columnIndex = FindSelectColumnIndex(queryBlock, terminal);

                    if (columnIndex.HasValue)
                    {
                        columnNode = queryBlock.ExplicitColumnNames?.Keys.Skip(columnIndex.Value).FirstOrDefault();
                    }
                }

                var sourcePositions = SelectQueryBlockColumns(columnNode, queryBlock, columnIndex).ToArray();
                if (sourcePositions.Length > 1)
                {
                    correspondingSourcePositions.AddRange(sourcePositions);
                }
            }

            foreach (var insertTarget in semanticModel.InsertTargets)
            {
                if (insertTarget.Columns == null)
                {
                    continue;
                }

                if (insertTarget.ValueList != null && insertTarget.ValueList.SourcePosition.Contains(terminal.SourcePosition))
                {
                    var valueExpression = FindItemAndIndexIndex(insertTarget.ValueExpressions, e => e.SourcePosition.Contains(terminal.SourcePosition), out columnIndex);
                    if (valueExpression != null && insertTarget.Columns.Count > columnIndex)
                    {
                        correspondingSourcePositions.Add(valueExpression.SourcePosition);
                        correspondingSourcePositions.Add(GetInsertTargetColumnAtPosition(insertTarget, columnIndex.Value).SourcePosition);
                    }

                    continue;
                }

                if (insertTarget.ColumnListNode.SourcePosition.Contains(terminal.SourcePosition))
                {
                    columnNode = FindItemAndIndexIndex(insertTarget.Columns.Keys, t => t == terminal, out columnIndex);
                    if (columnIndex == null)
                    {
                        continue;
                    }

                    if (insertTarget.ValueExpressions?.Count > columnIndex)
                    {
                        correspondingSourcePositions.Add(columnNode.SourcePosition);
                        correspondingSourcePositions.Add(insertTarget.ValueExpressions[columnIndex.Value].SourcePosition);
                    }
                    else
                    {
                        correspondingSourcePositions.AddRange(SelectQueryBlockColumns(columnNode, insertTarget.RowSource, columnIndex.Value));
                    }

                    continue;
                }

                columnIndex = FindSelectColumnIndex(insertTarget.RowSource, terminal);

                if (columnIndex.HasValue)
                {
                    var insertColumn = GetInsertTargetColumnAtPosition(insertTarget, columnIndex.Value);
                    if (insertTarget.RowSource.FollowingConcatenatedQueryBlock == null)
                    {
                        correspondingSourcePositions.AddRange(SelectQueryBlockColumns(insertColumn, insertTarget.RowSource, columnIndex.Value));
                    }
                    else if (insertColumn != null)
                    {
                        correspondingSourcePositions.Add(insertColumn.SourcePosition);
                    }
                }
            }

            return(correspondingSourcePositions.AsReadOnly());
        }
Example #29
0
		public static BindVariableConfiguration GetBindVariable(OracleStatementSemanticModel semanticModel, string bindVariableIdentifier)
		{
			var normalizedIdentifier = bindVariableIdentifier.ToQuotedIdentifier();
			return semanticModel.Statement.BindVariables
				.SingleOrDefault(v => v.Nodes.Any(n => String.Equals(n.Token.Value.ToQuotedIdentifier(), normalizedIdentifier)));
		}
Example #30
0
		public OracleSelectListColumn(OracleStatementSemanticModel semanticModel, OracleSelectListColumn asteriskColumn)
			: base(semanticModel)
		{
			AsteriskColumn = asteriskColumn;
		}